mirror of
https://github.com/ansible-collections/community.general.git
synced 2024-09-14 20:13:21 +02:00
203747027e
* Move licenses to LICENSES/, run add-license.py, add LICENSES/MIT.txt.
* Replace 'Copyright:' with 'Copyright'
sed -i 's|Copyright:\(.*\)|Copyright\1|' $(rg -l 'Copyright:')
Co-authored-by: Maxwell G <gotmax@e.email>
(cherry picked from commit 123c7efe5e)
Co-authored-by: Felix Fontein <felix@fontein.de>
119 lines
3.7 KiB
Python
119 lines
3.7 KiB
Python
# -*- coding: utf-8 -*-
|
|
#
|
|
# Copyright (c) 2019, Bojan Vitnik <bvitnik@mainstream.rs>
|
|
# GNU General Public License v3.0+ (see LICENSES/GPL-3.0-or-later.txt or https://www.gnu.org/licenses/gpl-3.0.txt)
|
|
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
from __future__ import (absolute_import, division, print_function)
|
|
__metaclass__ = type
|
|
|
|
|
|
import sys
|
|
import importlib
|
|
import os
|
|
import json
|
|
import pytest
|
|
|
|
from .FakeAnsibleModule import FakeAnsibleModule
|
|
from ansible.module_utils import six
|
|
from mock import MagicMock
|
|
|
|
|
|
@pytest.fixture
|
|
def fake_ansible_module(request):
|
|
"""Returns fake AnsibleModule with fake module params."""
|
|
if hasattr(request, 'param'):
|
|
return FakeAnsibleModule(request.param)
|
|
else:
|
|
params = {
|
|
"hostname": "somehost",
|
|
"username": "someuser",
|
|
"password": "somepwd",
|
|
"validate_certs": True,
|
|
}
|
|
|
|
return FakeAnsibleModule(params)
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def XenAPI():
|
|
"""Imports and returns fake XenAPI module."""
|
|
|
|
# Import of fake XenAPI module is wrapped by fixture so that it does not
|
|
# affect other unit tests which could potentially also use XenAPI module.
|
|
|
|
# First we use importlib.import_module() to import the module and assign
|
|
# it to a local symbol.
|
|
fake_xenapi = importlib.import_module('ansible_collections.community.general.tests.unit.plugins.module_utils.xenserver.FakeXenAPI')
|
|
|
|
# Now we populate Python module cache with imported fake module using the
|
|
# original module name (XenAPI). That way, any 'import XenAPI' statement
|
|
# will just load already imported fake module from the cache.
|
|
sys.modules['XenAPI'] = fake_xenapi
|
|
|
|
return fake_xenapi
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def xenserver(XenAPI):
|
|
"""Imports and returns xenserver module util."""
|
|
|
|
# Since we are wrapping fake XenAPI module inside a fixture, all modules
|
|
# that depend on it have to be imported inside a test function. To make
|
|
# this easier to handle and remove some code repetition, we wrap the import
|
|
# of xenserver module util with a fixture.
|
|
from ansible_collections.community.general.plugins.module_utils import xenserver
|
|
|
|
return xenserver
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_xenapi_failure(XenAPI, mocker):
|
|
"""
|
|
Returns mock object that raises XenAPI.Failure on any XenAPI
|
|
method call.
|
|
"""
|
|
fake_error_msg = "Fake XAPI method call error!"
|
|
|
|
# We need to use our MagicMock based class that passes side_effect to its
|
|
# children because calls to xenapi methods can generate an arbitrary
|
|
# hierarchy of mock objects. Any such object when called should use the
|
|
# same side_effect as its parent mock object.
|
|
class MagicMockSideEffect(MagicMock):
|
|
def _get_child_mock(self, **kw):
|
|
child_mock = super(MagicMockSideEffect, self)._get_child_mock(**kw)
|
|
child_mock.side_effect = self.side_effect
|
|
return child_mock
|
|
|
|
mocked_xenapi = mocker.patch.object(XenAPI.Session, 'xenapi', new=MagicMockSideEffect(), create=True)
|
|
mocked_xenapi.side_effect = XenAPI.Failure(fake_error_msg)
|
|
|
|
return mocked_xenapi, fake_error_msg
|
|
|
|
|
|
@pytest.fixture
|
|
def fixture_data_from_file(request):
|
|
"""Loads fixture data from files."""
|
|
if not hasattr(request, 'param'):
|
|
return {}
|
|
|
|
fixture_path = os.path.join(os.path.dirname(__file__), 'fixtures')
|
|
fixture_data = {}
|
|
|
|
if isinstance(request.param, six.string_types):
|
|
request.param = [request.param]
|
|
|
|
for fixture_name in request.param:
|
|
path = os.path.join(fixture_path, fixture_name)
|
|
|
|
with open(path) as f:
|
|
data = f.read()
|
|
|
|
try:
|
|
data = json.loads(data)
|
|
except Exception:
|
|
pass
|
|
|
|
fixture_data[fixture_name] = data
|
|
|
|
return fixture_data
|