def test_finder_setup(): # ensure scalar path is listified f = _AnsibleCollectionFinder(paths='/bogus/bogus') assert isinstance(f._n_collection_paths, list) # ensure sys.path paths that have an ansible_collections dir are added to the end of the collections paths with patch.object(sys, 'path', [ '/bogus', default_test_collection_paths[1], '/morebogus', default_test_collection_paths[0] ]): with patch('os.path.isdir', side_effect=lambda x: b'bogus' not in x): f = _AnsibleCollectionFinder(paths=['/explicit', '/other']) assert f._n_collection_paths == [ '/explicit', '/other', default_test_collection_paths[1], default_test_collection_paths[0] ] configured_paths = ['/bogus'] playbook_paths = ['/playbookdir'] with patch.object(sys, 'path', ['/bogus', '/playbookdir']) and patch( 'os.path.isdir', side_effect=lambda x: b'bogus' in x): f = _AnsibleCollectionFinder(paths=configured_paths) assert f._n_collection_paths == configured_paths f.set_playbook_paths(playbook_paths) assert f._n_collection_paths == extend_paths( playbook_paths, 'collections') + configured_paths # ensure scalar playbook_paths gets listified f.set_playbook_paths(playbook_paths[0]) assert f._n_collection_paths == extend_paths( playbook_paths, 'collections') + configured_paths
def pytest_configure(): """Configure this pytest plugin.""" try: if pytest_configure.executed: return except AttributeError: pytest_configure.executed = True # If ANSIBLE_HOME is set make sure we add it to the PYTHONPATH to ensure it is picked up. Not all env vars are # picked up by vscode (.bashrc is a notable one) so a user can define it manually in their .env file. ansible_home = os.environ.get('ANSIBLE_HOME', None) if ansible_home: sys.path.insert(0, os.path.join(ansible_home, 'lib')) from ansible.utils.collection_loader._collection_finder import _AnsibleCollectionFinder # allow unit tests to import code from collections # noinspection PyProtectedMember _AnsibleCollectionFinder(paths=[os.path.dirname(ANSIBLE_COLLECTIONS_PATH)])._install() # pylint: disable=protected-access # noinspection PyProtectedMember from _pytest import pathlib as pytest_pathlib pytest_pathlib.resolve_package_path = collection_resolve_package_path
def test_loader_remove(): fake_mp = [ MagicMock(), _AnsibleCollectionFinder(), MagicMock(), _AnsibleCollectionFinder() ] fake_ph = [ MagicMock().m1, MagicMock().m2, _AnsibleCollectionFinder()._ansible_collection_path_hook, NonCallableMagicMock ] # must nest until 2.6 compilation is totally donezo with patch.object(sys, 'meta_path', fake_mp): with patch.object(sys, 'path_hooks', fake_ph): _AnsibleCollectionFinder()._remove() assert len(sys.meta_path) == 2 # no AnsibleCollectionFinders on the meta path after remove is called assert all((not isinstance(mpf, _AnsibleCollectionFinder) for mpf in sys.meta_path)) assert len(sys.path_hooks) == 3 # none of the remaining path hooks should point at an AnsibleCollectionFinder assert all((not isinstance(ph.__self__, _AnsibleCollectionFinder) for ph in sys.path_hooks if hasattr(ph, '__self__'))) assert AnsibleCollectionConfig.collection_finder is None
def pytest_configure(): """Configure this pytest plugin.""" try: if pytest_configure.executed: return except AttributeError: pytest_configure.executed = True # noinspection PyProtectedMember from ansible.utils.collection_loader._collection_finder import _AnsibleCollectionFinder # allow unit tests to import code from collections # noinspection PyProtectedMember _AnsibleCollectionFinder( paths=[os.path.dirname(ANSIBLE_COLLECTIONS_PATH)])._install() # pylint: disable=protected-access try: # noinspection PyProtectedMember from _pytest import pathlib as _pytest_pathlib except ImportError: _pytest_pathlib = None if hasattr(_pytest_pathlib, 'resolve_package_path'): _pytest_pathlib.resolve_package_path = collection_resolve_package_path else: # looks like pytest <= 6.0.0, use the old hack against py.path # noinspection PyProtectedMember import py._path.local # force collections unit tests to be loaded with the ansible_collections namespace # original idea from https://stackoverflow.com/questions/50174130/how-do-i-pytest-a-project-using-pep-420-namespace-packages/50175552#50175552 # noinspection PyProtectedMember py._path.local.LocalPath.pypkgpath = collection_pypkgpath # pylint: disable=protected-access
def test_finder_ns(): # ensure we can still load ansible_collections and ansible_collections.ansible when they don't exist on disk f = _AnsibleCollectionFinder(paths=['/bogus/bogus']) loader = f.find_module('ansible_collections') assert isinstance(loader, _AnsibleCollectionRootPkgLoader) loader = f.find_module('ansible_collections.ansible', path=['/bogus/bogus']) assert isinstance(loader, _AnsibleCollectionNSPkgLoader) f = get_default_finder() loader = f.find_module('ansible_collections') assert isinstance(loader, _AnsibleCollectionRootPkgLoader) # path is not allowed for top-level with pytest.raises(ValueError): f.find_module('ansible_collections', path=['whatever']) # path is required for subpackages with pytest.raises(ValueError): f.find_module('ansible_collections.whatever', path=None) paths = [ os.path.join(p, 'ansible_collections/nonexistns') for p in default_test_collection_paths ] # test missing loader = f.find_module('ansible_collections.nonexistns', paths) assert loader is None
def test_path_hook_importerror(): # ensure that AnsiblePathHookFinder.find_module swallows ImportError from path hook delegation on Py3, eg if the delegated # path hook gets passed a file on sys.path (python36.zip) reset_collections_loader_state() path_to_a_file = os.path.join(default_test_collection_paths[0], 'ansible_collections/testns/testcoll/plugins/action/my_action.py') # it's a bug if the following pops an ImportError... assert _AnsiblePathHookFinder(_AnsibleCollectionFinder(), path_to_a_file).find_module('foo.bar.my_action') is None
def test_find_module_py3(): dir_to_a_file = os.path.dirname(ping_module.__file__) path_hook_finder = _AnsiblePathHookFinder(_AnsibleCollectionFinder(), dir_to_a_file) # setuptools may fall back to find_module on Python 3 if find_spec returns None # see https://github.com/pypa/setuptools/pull/2918 assert path_hook_finder.find_spec('missing') is None assert path_hook_finder.find_module('missing') is None
def pytest_configure(): """Configure this pytest plugin.""" try: if pytest_configure.executed: return except AttributeError: pytest_configure.executed = True # allow unit tests to import code from collections # noinspection PyProtectedMember _AnsibleCollectionFinder( paths=[os.path.dirname(ANSIBLE_COLLECTIONS_PATH)])._install() # pylint: disable=protected-access # noinspection PyProtectedMember from _pytest import pathlib as pytest_pathlib pytest_pathlib.resolve_package_path = collection_resolve_package_path
def test_loader_install(): fake_mp = [MagicMock(), _AnsibleCollectionFinder(), MagicMock(), _AnsibleCollectionFinder()] fake_ph = [MagicMock().m1, MagicMock().m2, _AnsibleCollectionFinder()._ansible_collection_path_hook, NonCallableMagicMock] # must nest until 2.6 compilation is totally donezo with patch.object(sys, 'meta_path', fake_mp): with patch.object(sys, 'path_hooks', fake_ph): f = _AnsibleCollectionFinder() f._install() assert len(sys.meta_path) == 3 # should have removed the existing ACFs and installed a new one assert sys.meta_path[0] is f # at the front # the rest of the meta_path should not be AnsibleCollectionFinders assert all((not isinstance(mpf, _AnsibleCollectionFinder) for mpf in sys.meta_path[1:])) assert len(sys.path_hooks) == 4 # should have removed the existing ACF path hooks and installed a new one # the first path hook should be ours, make sure it's pointing at the right instance assert hasattr(sys.path_hooks[0], '__self__') and sys.path_hooks[0].__self__ is f # the rest of the path_hooks should not point at an AnsibleCollectionFinder assert all((not isinstance(ph.__self__, _AnsibleCollectionFinder) for ph in sys.path_hooks[1:] if hasattr(ph, '__self__'))) assert AnsibleCollectionConfig.collection_finder is f with pytest.raises(ValueError): AnsibleCollectionConfig.collection_finder = f
def main(): """ Main program function used to isolate globals from imported code. Changes to globals in imported modules on Python 2.x will overwrite our own globals. """ import ansible import contextlib import datetime import json import os import re import runpy import subprocess import sys import traceback import types import warnings ansible_path = os.path.dirname(os.path.dirname(ansible.__file__)) temp_path = os.environ['SANITY_TEMP_PATH'] + os.path.sep external_python = os.environ.get('SANITY_EXTERNAL_PYTHON') or sys.executable collection_full_name = os.environ.get('SANITY_COLLECTION_FULL_NAME') collection_root = os.environ.get('ANSIBLE_COLLECTIONS_PATH') import_type = os.environ.get('SANITY_IMPORTER_TYPE') try: # noinspection PyCompatibility from importlib import import_module except ImportError: def import_module(name): __import__(name) return sys.modules[name] try: # noinspection PyCompatibility from StringIO import StringIO except ImportError: from io import StringIO if collection_full_name: # allow importing code from collections when testing a collection from ansible.module_utils.common.text.converters import to_bytes, to_text, to_native, text_type from ansible.utils.collection_loader._collection_finder import _AnsibleCollectionFinder from ansible.utils.collection_loader import _collection_finder yaml_to_json_path = os.path.join(os.path.dirname(__file__), 'yaml_to_json.py') yaml_to_dict_cache = {} # unique ISO date marker matching the one present in yaml_to_json.py iso_date_marker = 'isodate:f23983df-f3df-453c-9904-bcd08af468cc:' iso_date_re = re.compile('^%s([0-9]{4})-([0-9]{2})-([0-9]{2})$' % iso_date_marker) def parse_value(value): """Custom value parser for JSON deserialization that recognizes our internal ISO date format.""" if isinstance(value, text_type): match = iso_date_re.search(value) if match: value = datetime.date(int(match.group(1)), int(match.group(2)), int(match.group(3))) return value def object_hook(data): """Object hook for custom ISO date deserialization from JSON.""" return dict((key, parse_value(value)) for key, value in data.items()) def yaml_to_dict(yaml, content_id): """ Return a Python dict version of the provided YAML. Conversion is done in a subprocess since the current Python interpreter does not have access to PyYAML. """ if content_id in yaml_to_dict_cache: return yaml_to_dict_cache[content_id] try: cmd = [external_python, yaml_to_json_path] proc = subprocess.Popen([to_bytes(c) for c in cmd], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout_bytes, stderr_bytes = proc.communicate(to_bytes(yaml)) if proc.returncode != 0: raise Exception('command %s failed with return code %d: %s' % ([to_native(c) for c in cmd], proc.returncode, to_native(stderr_bytes))) data = yaml_to_dict_cache[content_id] = json.loads(to_text(stdout_bytes), object_hook=object_hook) return data except Exception as ex: raise Exception('internal importer error - failed to parse yaml: %s' % to_native(ex)) _collection_finder._meta_yml_to_dict = yaml_to_dict # pylint: disable=protected-access collection_loader = _AnsibleCollectionFinder(paths=[collection_root]) # noinspection PyProtectedMember collection_loader._install() # pylint: disable=protected-access else: # do not support collection loading when not testing a collection collection_loader = None # remove all modules under the ansible package list(map(sys.modules.pop, [m for m in sys.modules if m.partition('.')[0] == ansible.__name__])) if import_type == 'module': # pre-load an empty ansible package to prevent unwanted code in __init__.py from loading # this more accurately reflects the environment that AnsiballZ runs modules under # it also avoids issues with imports in the ansible package that are not allowed ansible_module = types.ModuleType(ansible.__name__) ansible_module.__file__ = ansible.__file__ ansible_module.__path__ = ansible.__path__ ansible_module.__package__ = ansible.__package__ sys.modules[ansible.__name__] = ansible_module class ImporterAnsibleModuleException(Exception): """Exception thrown during initialization of ImporterAnsibleModule.""" class ImporterAnsibleModule: """Replacement for AnsibleModule to support import testing.""" def __init__(self, *args, **kwargs): raise ImporterAnsibleModuleException() class RestrictedModuleLoader: """Python module loader that restricts inappropriate imports.""" def __init__(self, path, name, restrict_to_module_paths): self.path = path self.name = name self.loaded_modules = set() self.restrict_to_module_paths = restrict_to_module_paths def find_module(self, fullname, path=None): """Return self if the given fullname is restricted, otherwise return None. :param fullname: str :param path: str :return: RestrictedModuleLoader | None """ if fullname in self.loaded_modules: return None # ignore modules that are already being loaded if is_name_in_namepace(fullname, ['ansible']): if not self.restrict_to_module_paths: return None # for non-modules, everything in the ansible namespace is allowed if fullname in ('ansible.module_utils.basic',): return self # intercept loading so we can modify the result if is_name_in_namepace(fullname, ['ansible.module_utils', self.name]): return None # module_utils and module under test are always allowed if any(os.path.exists(candidate_path) for candidate_path in convert_ansible_name_to_absolute_paths(fullname)): return self # restrict access to ansible files that exist return None # ansible file does not exist, do not restrict access if is_name_in_namepace(fullname, ['ansible_collections']): if not collection_loader: return self # restrict access to collections when we are not testing a collection if not self.restrict_to_module_paths: return None # for non-modules, everything in the ansible namespace is allowed if is_name_in_namepace(fullname, ['ansible_collections...plugins.module_utils', self.name]): return None # module_utils and module under test are always allowed if collection_loader.find_module(fullname, path): return self # restrict access to collection files that exist return None # collection file does not exist, do not restrict access # not a namespace we care about return None def load_module(self, fullname): """Raise an ImportError. :type fullname: str """ if fullname == 'ansible.module_utils.basic': module = self.__load_module(fullname) # stop Ansible module execution during AnsibleModule instantiation module.AnsibleModule = ImporterAnsibleModule # no-op for _load_params since it may be called before instantiating AnsibleModule module._load_params = lambda *args, **kwargs: {} # pylint: disable=protected-access return module raise ImportError('import of "%s" is not allowed in this context' % fullname) def __load_module(self, fullname): """Load the requested module while avoiding infinite recursion. :type fullname: str :rtype: module """ self.loaded_modules.add(fullname) return import_module(fullname) def run(restrict_to_module_paths): """Main program function.""" base_dir = os.getcwd() messages = set() for path in sys.argv[1:] or sys.stdin.read().splitlines(): name = convert_relative_path_to_name(path) test_python_module(path, name, base_dir, messages, restrict_to_module_paths) if messages: sys.exit(10) def test_python_module(path, name, base_dir, messages, restrict_to_module_paths): """Test the given python module by importing it. :type path: str :type name: str :type base_dir: str :type messages: set[str] :type restrict_to_module_paths: bool """ if name in sys.modules: return # cannot be tested because it has already been loaded is_ansible_module = (path.startswith('lib/ansible/modules/') or path.startswith('plugins/modules/')) and os.path.basename(path) != '__init__.py' run_main = is_ansible_module if path == 'lib/ansible/modules/async_wrapper.py': # async_wrapper is a non-standard Ansible module (does not use AnsibleModule) so we cannot test the main function run_main = False capture_normal = Capture() capture_main = Capture() run_module_ok = False try: with monitor_sys_modules(path, messages): with restrict_imports(path, name, messages, restrict_to_module_paths): with capture_output(capture_normal): import_module(name) if run_main: run_module_ok = is_ansible_module with monitor_sys_modules(path, messages): with restrict_imports(path, name, messages, restrict_to_module_paths): with capture_output(capture_main): runpy.run_module(name, run_name='__main__', alter_sys=True) except ImporterAnsibleModuleException: # module instantiated AnsibleModule without raising an exception if not run_module_ok: if is_ansible_module: report_message(path, 0, 0, 'module-guard', "AnsibleModule instantiation not guarded by `if __name__ == '__main__'`", messages) else: report_message(path, 0, 0, 'non-module', "AnsibleModule instantiated by import of non-module", messages) except BaseException as ex: # pylint: disable=locally-disabled, broad-except # intentionally catch all exceptions, including calls to sys.exit exc_type, _exc, exc_tb = sys.exc_info() message = str(ex) results = list(reversed(traceback.extract_tb(exc_tb))) line = 0 offset = 0 full_path = os.path.join(base_dir, path) base_path = base_dir + os.path.sep source = None # avoid line wraps in messages message = re.sub(r'\n *', ': ', message) for result in results: if result[0] == full_path: # save the line number for the file under test line = result[1] or 0 if not source and result[0].startswith(base_path) and not result[0].startswith(temp_path): # save the first path and line number in the traceback which is in our source tree source = (os.path.relpath(result[0], base_path), result[1] or 0, 0) if isinstance(ex, SyntaxError): # SyntaxError has better information than the traceback if ex.filename == full_path: # pylint: disable=locally-disabled, no-member # syntax error was reported in the file under test line = ex.lineno or 0 # pylint: disable=locally-disabled, no-member offset = ex.offset or 0 # pylint: disable=locally-disabled, no-member elif ex.filename.startswith(base_path) and not ex.filename.startswith(temp_path): # pylint: disable=locally-disabled, no-member # syntax error was reported in our source tree source = (os.path.relpath(ex.filename, base_path), ex.lineno or 0, ex.offset or 0) # pylint: disable=locally-disabled, no-member # remove the filename and line number from the message # either it was extracted above, or it's not really useful information message = re.sub(r' \(.*?, line [0-9]+\)$', '', message) if source and source[0] != path: message += ' (at %s:%d:%d)' % (source[0], source[1], source[2]) report_message(path, line, offset, 'traceback', '%s: %s' % (exc_type.__name__, message), messages) finally: capture_report(path, capture_normal, messages) capture_report(path, capture_main, messages) def is_name_in_namepace(name, namespaces): """Returns True if the given name is one of the given namespaces, otherwise returns False.""" name_parts = name.split('.') for namespace in namespaces: namespace_parts = namespace.split('.') length = min(len(name_parts), len(namespace_parts)) truncated_name = name_parts[0:length] truncated_namespace = namespace_parts[0:length] # empty parts in the namespace are treated as wildcards # to simplify the comparison, use those empty parts to indicate the positions in the name to be empty as well for idx, part in enumerate(truncated_namespace): if not part: truncated_name[idx] = part # example: name=ansible, allowed_name=ansible.module_utils # example: name=ansible.module_utils.system.ping, allowed_name=ansible.module_utils if truncated_name == truncated_namespace: return True return False def check_sys_modules(path, before, messages): """Check for unwanted changes to sys.modules. :type path: str :type before: dict[str, module] :type messages: set[str] """ after = sys.modules removed = set(before.keys()) - set(after.keys()) changed = set(key for key, value in before.items() if key in after and value != after[key]) # additions are checked by our custom PEP 302 loader, so we don't need to check them again here for module in sorted(removed): report_message(path, 0, 0, 'unload', 'unloading of "%s" in sys.modules is not supported' % module, messages) for module in sorted(changed): report_message(path, 0, 0, 'reload', 'reloading of "%s" in sys.modules is not supported' % module, messages) def convert_ansible_name_to_absolute_paths(name): """Calculate the module path from the given name. :type name: str :rtype: list[str] """ return [ os.path.join(ansible_path, name.replace('.', os.path.sep)), os.path.join(ansible_path, name.replace('.', os.path.sep)) + '.py', ] def convert_relative_path_to_name(path): """Calculate the module name from the given path. :type path: str :rtype: str """ if path.endswith('/__init__.py'): clean_path = os.path.dirname(path) else: clean_path = path clean_path = os.path.splitext(clean_path)[0] name = clean_path.replace(os.path.sep, '.') if collection_loader: # when testing collections the relative paths (and names) being tested are within the collection under test name = 'ansible_collections.%s.%s' % (collection_full_name, name) else: # when testing ansible all files being imported reside under the lib directory name = name[len('lib/'):] return name class Capture: """Captured output and/or exception.""" def __init__(self): self.stdout = StringIO() self.stderr = StringIO() def capture_report(path, capture, messages): """Report on captured output. :type path: str :type capture: Capture :type messages: set[str] """ if capture.stdout.getvalue(): first = capture.stdout.getvalue().strip().splitlines()[0].strip() report_message(path, 0, 0, 'stdout', first, messages) if capture.stderr.getvalue(): first = capture.stderr.getvalue().strip().splitlines()[0].strip() report_message(path, 0, 0, 'stderr', first, messages) def report_message(path, line, column, code, message, messages): """Report message if not already reported. :type path: str :type line: int :type column: int :type code: str :type message: str :type messages: set[str] """ message = '%s:%d:%d: %s: %s' % (path, line, column, code, message) if message not in messages: messages.add(message) print(message) @contextlib.contextmanager def restrict_imports(path, name, messages, restrict_to_module_paths): """Restrict available imports. :type path: str :type name: str :type messages: set[str] :type restrict_to_module_paths: bool """ restricted_loader = RestrictedModuleLoader(path, name, restrict_to_module_paths) # noinspection PyTypeChecker sys.meta_path.insert(0, restricted_loader) sys.path_importer_cache.clear() try: yield finally: if import_type == 'plugin': from ansible.utils.collection_loader._collection_finder import _AnsibleCollectionFinder _AnsibleCollectionFinder._remove() # pylint: disable=protected-access if sys.meta_path[0] != restricted_loader: report_message(path, 0, 0, 'metapath', 'changes to sys.meta_path[0] are not permitted', messages) while restricted_loader in sys.meta_path: # noinspection PyTypeChecker sys.meta_path.remove(restricted_loader) sys.path_importer_cache.clear() @contextlib.contextmanager def monitor_sys_modules(path, messages): """Monitor sys.modules for unwanted changes, reverting any additions made to our own namespaces.""" snapshot = sys.modules.copy() try: yield finally: check_sys_modules(path, snapshot, messages) for key in set(sys.modules.keys()) - set(snapshot.keys()): if is_name_in_namepace(key, ('ansible', 'ansible_collections')): del sys.modules[key] # only unload our own code since we know it's native Python @contextlib.contextmanager def capture_output(capture): """Capture sys.stdout and sys.stderr. :type capture: Capture """ old_stdout = sys.stdout old_stderr = sys.stderr sys.stdout = capture.stdout sys.stderr = capture.stderr # clear all warnings registries to make all warnings available for module in sys.modules.values(): try: # noinspection PyUnresolvedReferences module.__warningregistry__.clear() except AttributeError: pass with warnings.catch_warnings(): warnings.simplefilter('error') if sys.version_info[0] == 2: warnings.filterwarnings( "ignore", "Python 2 is no longer supported by the Python core team. Support for it is now deprecated in cryptography," " and will be removed in a future release.") warnings.filterwarnings( "ignore", "Python 2 is no longer supported by the Python core team. Support for it is now deprecated in cryptography," " and will be removed in the next release.") if sys.version_info[:2] == (3, 5): warnings.filterwarnings( "ignore", "Python 3.5 support will be dropped in the next release ofcryptography. Please upgrade your Python.") warnings.filterwarnings( "ignore", "Python 3.5 support will be dropped in the next release of cryptography. Please upgrade your Python.") warnings.filterwarnings( "ignore", "The _yaml extension module is now located at yaml._yaml and its location is subject to change. To use the " "LibYAML-based parser and emitter, import from `yaml`: `from yaml import CLoader as Loader, CDumper as Dumper`.") try: yield finally: sys.stdout = old_stdout sys.stderr = old_stderr run(import_type == 'module')
def get_default_finder(): return _AnsibleCollectionFinder(paths=default_test_collection_paths)
def test_import_from_collection(monkeypatch): collection_root = os.path.join(os.path.dirname(__file__), 'fixtures', 'collections') collection_path = os.path.join( collection_root, 'ansible_collections/testns/testcoll/plugins/module_utils/my_util.py') # THIS IS UNSTABLE UNDER A DEBUGGER # the trace we're expecting to be generated when running the code below: # answer = question() expected_trace_log = [ (collection_path, 5, 'call'), (collection_path, 6, 'line'), (collection_path, 6, 'return'), ] # define the collection root before any ansible code has been loaded # otherwise config will have already been loaded and changing the environment will have no effect monkeypatch.setenv('ANSIBLE_COLLECTIONS_PATH', collection_root) finder = _AnsibleCollectionFinder(paths=[collection_root]) reset_collections_loader_state(finder) from ansible_collections.testns.testcoll.plugins.module_utils.my_util import question original_trace_function = sys.gettrace() trace_log = [] if original_trace_function: # enable tracing while preserving the existing trace function (coverage) def my_trace_function(frame, event, arg): trace_log.append((frame.f_code.co_filename, frame.f_lineno, event)) # the original trace function expects to have itself set as the trace function sys.settrace(original_trace_function) # call the original trace function original_trace_function(frame, event, arg) # restore our trace function sys.settrace(my_trace_function) return my_trace_function else: # no existing trace function, so our trace function is much simpler def my_trace_function(frame, event, arg): trace_log.append((frame.f_code.co_filename, frame.f_lineno, event)) return my_trace_function sys.settrace(my_trace_function) try: # run a minimal amount of code while the trace is running # adding more code here, including use of a context manager, will add more to our trace answer = question() finally: sys.settrace(original_trace_function) # make sure 'import ... as ...' works on builtin synthetic collections # the following import is not supported (it tries to find module_utils in ansible.plugins) # import ansible_collections.ansible.builtin.plugins.module_utils as c1 import ansible_collections.ansible.builtin.plugins.action as c2 import ansible_collections.ansible.builtin.plugins as c3 import ansible_collections.ansible.builtin as c4 import ansible_collections.ansible as c5 import ansible_collections as c6 # make sure 'import ...' works on builtin synthetic collections import ansible_collections.ansible.builtin.plugins.module_utils import ansible_collections.ansible.builtin.plugins.action assert ansible_collections.ansible.builtin.plugins.action == c3.action == c2 import ansible_collections.ansible.builtin.plugins assert ansible_collections.ansible.builtin.plugins == c4.plugins == c3 import ansible_collections.ansible.builtin assert ansible_collections.ansible.builtin == c5.builtin == c4 import ansible_collections.ansible assert ansible_collections.ansible == c6.ansible == c5 import ansible_collections assert ansible_collections == c6 # make sure 'from ... import ...' works on builtin synthetic collections from ansible_collections.ansible import builtin from ansible_collections.ansible.builtin import plugins assert builtin.plugins == plugins from ansible_collections.ansible.builtin.plugins import action from ansible_collections.ansible.builtin.plugins.action import command assert action.command == command from ansible_collections.ansible.builtin.plugins.module_utils import basic from ansible_collections.ansible.builtin.plugins.module_utils.basic import AnsibleModule assert basic.AnsibleModule == AnsibleModule # make sure relative imports work from collections code # these require __package__ to be set correctly import ansible_collections.testns.testcoll.plugins.module_utils.my_other_util import ansible_collections.testns.testcoll.plugins.action.my_action # verify that code loaded from a collection does not inherit __future__ statements from the collection loader if sys.version_info[0] == 2: # if the collection code inherits the division future feature from the collection loader this will fail assert answer == 1 else: assert answer == 1.5 # verify that the filename and line number reported by the trace is correct # this makes sure that collection loading preserves file paths and line numbers assert trace_log == expected_trace_log