9fe9d27865
Consolidate next-stage docs, archive superseded narratives, and preserve frozen document inputs. Retain invalid P2 pairs, partial RootXY training, failed attempts and nonselectable checkpoints as explicit limitations. Include supervised evaluation/training, desktop GPU admission, bounded evidence and atomic-publication monitor repairs with CPU regressions. Ignore local dotenv configuration. Validation: 1403 passed, 6 skipped for contact-cycle and related contracts/CLI tests. Full-suite legacy ABI and registration tests require Python 3.12/Torch 2.10/pxr; no runtime checks relaxed. No new physical run or accepted skill.
422 lines
21 KiB
Python
422 lines
21 KiB
Python
"""CPU provenance fixtures; no Kit launch or installed-tree mutation."""
|
|
import ast
|
|
import importlib
|
|
import importlib.machinery
|
|
import importlib.util
|
|
import sys
|
|
from pathlib import Path
|
|
from types import CodeType, FunctionType, ModuleType, SimpleNamespace
|
|
|
|
import pytest
|
|
from test_contact_cycle_sim_evaluation_binding import ROOT, binding, load, replay
|
|
from test_contact_cycle_sim_evaluation_namespaces import namespace # noqa: F401
|
|
|
|
|
|
@pytest.fixture
|
|
def installed_links(tmp_path, monkeypatch):
|
|
physical = tmp_path / 'sim-6'
|
|
physical.mkdir()
|
|
source = physical / 'module.py'
|
|
source.write_text('VALUE = 1\n')
|
|
intermediate, alias = tmp_path / 'sim', tmp_path / '_sim'
|
|
intermediate.symlink_to(physical)
|
|
alias.symlink_to(intermediate)
|
|
links = tuple((str(p), str(p.readlink()), p.lstat().st_dev, p.lstat().st_ino)
|
|
for p in (alias, intermediate))
|
|
monkeypatch.setattr(binding, 'SIM_ROOT', physical)
|
|
monkeypatch.setattr(binding, 'RUNTIME_LINKS', links)
|
|
return alias, intermediate, source
|
|
|
|
|
|
def test_installed_alias_chain_binds_raw_physical_links_and_source(installed_links, monkeypatch):
|
|
alias, intermediate, source = installed_links
|
|
module = load('_runtime_alias_cpu', alias / source.name, monkeypatch)
|
|
module.__spec__.origin = str(source)
|
|
record = binding._dependency_module_identity(module.__name__)
|
|
assert record['raw_path'] == str(alias / source.name)
|
|
assert record['path'] == str(source)
|
|
assert record['sha256'] == binding.sha256(source.read_bytes())
|
|
assert [link['path'] for link in record['links']] == [str(alias), str(intermediate)]
|
|
assert all(link['target_sha256'] == binding.sha256(link['target'].encode()) for link in record['links'])
|
|
assert record['origin']['raw_path'] == str(source)
|
|
with pytest.raises(ValueError, match='Noncanonical'):
|
|
binding._file(alias / source.name) # project/config helper remains strict
|
|
|
|
|
|
@pytest.mark.parametrize('change', ['target', 'inode', 'foreign', 'extra-link', 'dot', 'origin'])
|
|
def test_installed_alias_rejects_unbound_paths(installed_links, monkeypatch, tmp_path, change):
|
|
alias, intermediate, source = installed_links
|
|
module = load('_runtime_alias_cpu', alias / source.name, monkeypatch)
|
|
if change == 'target':
|
|
alias.unlink()
|
|
alias.symlink_to(source.parent)
|
|
elif change == 'inode':
|
|
monkeypatch.setattr(binding, 'RUNTIME_LINKS', tuple((p, t, d, i + 1) for p, t, d, i in binding.RUNTIME_LINKS))
|
|
elif change == 'foreign':
|
|
monkeypatch.setattr(binding, 'SIM_ROOT', tmp_path / 'foreign')
|
|
elif change == 'extra-link':
|
|
extra = source.parent / 'extra.py'
|
|
extra.symlink_to(source)
|
|
module.__file__ = str(alias / extra.name)
|
|
elif change == 'dot':
|
|
module.__file__ = str(alias) + '/./module.py'
|
|
else:
|
|
other = tmp_path / 'other.py'
|
|
other.write_bytes(source.read_bytes())
|
|
module.__spec__.origin = str(other)
|
|
with pytest.raises(ValueError):
|
|
binding._dependency_module_identity(module.__name__)
|
|
|
|
|
|
def test_inspected_installed_aliases_read_only():
|
|
physical = binding.SIM_ROOT / binding.FAST_IMPORTER_RELATIVE
|
|
if not physical.exists():
|
|
pytest.skip('inspected installation absent')
|
|
record = binding._runtime_path(Path('/home/cen/IsaacLab/_isaac_sim') / binding.FAST_IMPORTER_RELATIVE)
|
|
assert record['sha256'] == binding.FAST_IMPORTER_SHA256
|
|
assert len(record['links']) == 2
|
|
assert record['path'] == str(physical)
|
|
|
|
|
|
@pytest.fixture
|
|
def fast_namespace(namespace, monkeypatch): # noqa: F811
|
|
module, directory = namespace
|
|
path = binding.SIM_ROOT / binding.FAST_IMPORTER_RELATIVE
|
|
if not path.exists():
|
|
pytest.skip('inspected installation absent')
|
|
# Execute only the installed FastFinder method, with CPU-only cache fixtures.
|
|
# Its function code is still independently compared against the full source.
|
|
spec = importlib.util.spec_from_file_location(binding.FAST_IMPORTER, path)
|
|
importer = importlib.util.module_from_spec(spec)
|
|
importer._bootstrap = importlib.import_module('_frozen_importlib')
|
|
importer._bootstrap_external = importlib.import_module('_frozen_importlib_external')
|
|
importer._cache = SimpleNamespace(modules={}, namespaces={module.__name__: [str(directory)]})
|
|
compiled = compile(path.read_bytes(), str(path), 'exec', dont_inherit=True)
|
|
cls_code = next(c for c in compiled.co_consts if isinstance(c, CodeType) and c.co_name == 'FastFinder')
|
|
method_code = next(c for c in cls_code.co_consts if isinstance(c, CodeType) and c.co_name == 'find_spec')
|
|
importer.FastFinder = type('FastFinder', (), {
|
|
'find_spec': classmethod(FunctionType(method_code, vars(importer), argdefs=(None, None)))})
|
|
monkeypatch.setitem(sys.modules, binding.FAST_IMPORTER, importer)
|
|
monkeypatch.setattr(sys, 'meta_path', [importer.FastFinder, *sys.meta_path])
|
|
locations = importer.FastFinder.find_spec(module.__name__, [str(directory.parent)]).submodule_search_locations
|
|
module.__path__ = module.__spec__.submodule_search_locations = module.__loader__._path = locations
|
|
return module, directory, importer
|
|
|
|
|
|
def test_actual_pinned_fastfinder_code_and_duplicate_paths(fast_namespace, tmp_path):
|
|
module, directory, _ = fast_namespace
|
|
record = binding._namespace_identity(module.__name__, tmp_path)
|
|
assert record['importer']['kind'] == 'kit-fastfinder'
|
|
assert record['importer']['source']['sha256'] == binding.FAST_IMPORTER_SHA256
|
|
assert record['search_locations'] == [str(directory)]
|
|
assert record['raw_search_locations'] == [str(directory), str(directory)]
|
|
|
|
|
|
@pytest.mark.parametrize('change', ['callback', 'pin', 'meta-path', 'foreign-location', 'source'])
|
|
def test_fastfinder_rejects_changed_provenance(fast_namespace, tmp_path, monkeypatch, change):
|
|
module, directory, importer = fast_namespace
|
|
if change == 'callback':
|
|
module.__path__._path_finder = lambda *args: None
|
|
elif change == 'pin':
|
|
monkeypatch.setattr(binding, 'FAST_IMPORTER_SHA256', '0' * 64)
|
|
elif change == 'meta-path':
|
|
monkeypatch.setattr(sys, 'meta_path', [v for v in sys.meta_path if v is not importer.FastFinder])
|
|
elif change == 'foreign-location':
|
|
module.__path__._path.append(str(tmp_path))
|
|
else:
|
|
other = tmp_path / 'fast_importer.py'
|
|
other.write_bytes(Path(importer.__file__).read_bytes())
|
|
importer.__file__ = importer.__spec__.origin = str(other)
|
|
with pytest.raises(ValueError):
|
|
binding._namespace_identity(module.__name__, tmp_path)
|
|
|
|
|
|
def test_multiprocessing_alias_requires_real_main_object(tmp_path, monkeypatch):
|
|
monkeypatch.setattr(binding, 'ISAAC_PINS', {})
|
|
for name in tuple(sys.modules):
|
|
if name.split('.')[0] in ('SkillFactory', 'isaaclab', 'isaaclab_physx'):
|
|
monkeypatch.delitem(sys.modules, name)
|
|
path = tmp_path / 'entry.py'
|
|
path.write_text('VALUE = 1\n')
|
|
main = load('__main__', path, monkeypatch)
|
|
monkeypatch.setitem(sys.modules, '__mp_main__', main)
|
|
record = binding._imports({'__main__'}, tmp_path)['__main__']
|
|
assert record['standard_aliases']['__mp_main__']['same_module_object']
|
|
duplicate = ModuleType('__main__')
|
|
duplicate.__file__ = str(path)
|
|
monkeypatch.setitem(sys.modules, '__mp_main__', duplicate)
|
|
with pytest.raises(ValueError, match='Unbound imported-path alias'):
|
|
binding._imports({'__main__'}, tmp_path)
|
|
monkeypatch.setitem(sys.modules, '__mp_main__', main)
|
|
monkeypatch.setitem(sys.modules, 'arbitrary_alias', main)
|
|
with pytest.raises(ValueError, match='Unbound imported-path alias'):
|
|
binding._imports({'__main__'}, tmp_path)
|
|
|
|
|
|
def make_pxr_wrapper(package, short_name, monkeypatch):
|
|
path = package / short_name / '__init__.py'
|
|
path.parent.mkdir(parents=True)
|
|
path.write_text('# CPU wrapper fixture\n')
|
|
name = 'pxr.' + short_name
|
|
wrapper = load(name, path, monkeypatch)
|
|
native_name = name + '._' + short_name[0].lower() + short_name[1:]
|
|
native_path = path.parent / (native_name.rsplit('.', 1)[1] + '.so')
|
|
native_path.write_bytes(b'CPU fixture only; never dlopen')
|
|
native = ModuleType(native_name)
|
|
native.__file__ = str(native_path)
|
|
native.__spec__ = importlib.util.spec_from_file_location(native_name, native_path)
|
|
native.__loader__ = native.__spec__.loader
|
|
monkeypatch.setitem(sys.modules, native_name, native)
|
|
wrapper.__spec__, wrapper.__loader__ = native.__spec__, native.__loader__
|
|
return wrapper, native
|
|
|
|
|
|
@pytest.fixture(params=['Usd', 'PhysxSchema', 'PhysicsSchemaTools'])
|
|
def pxr_wrapper(request, tmp_path, monkeypatch):
|
|
monkeypatch.setattr(binding, 'SIM_ROOT', tmp_path)
|
|
libs = tmp_path / 'extscache/omni.usd.libs-pinned/pxr'
|
|
schema = tmp_path / 'extscache/omni.usd.schema.physx-pinned/pxr'
|
|
manifests = {}
|
|
for package in (libs, schema):
|
|
manifest = package.parent / 'config/extension.toml'
|
|
manifest.parent.mkdir(parents=True)
|
|
manifest.write_text('# owner: ' + package.parent.name + '\n[[python.module]]\nname = "pxr"\n')
|
|
manifests[str(manifest)] = binding.sha256(manifest.read_bytes())
|
|
monkeypatch.setattr(binding, 'RUNTIME_LAYOUT_PINS', manifests)
|
|
tf, _ = make_pxr_wrapper(libs, 'Tf', monkeypatch)
|
|
wrapper, native = make_pxr_wrapper(libs if request.param == 'Usd' else schema,
|
|
request.param, monkeypatch)
|
|
monkeypatch.setattr(binding, 'REQUIRED_RUNTIME', {
|
|
module.__name__: ('usd-wrapper', module.__file__, binding.sha256(Path(module.__file__).read_bytes()))
|
|
for module in (tf, wrapper)})
|
|
return wrapper, native
|
|
|
|
|
|
def test_pxr_copied_native_spec_binds_wrapper_and_binary(pxr_wrapper):
|
|
wrapper, native = pxr_wrapper
|
|
record = binding._dependency_module_identity(wrapper.__name__)
|
|
assert record['spec_name'] == native.__name__
|
|
assert record['wrapper']['native']['path'] == native.__file__
|
|
assert record['wrapper']['wrapper_source']['path'] == wrapper.__file__
|
|
tf = sys.modules['pxr.Tf']
|
|
tf_record = record['wrapper']['prepare_module_identity']
|
|
assert tf_record['module'] == 'pxr.Tf'
|
|
assert tf_record['observation'] == binding.module_diagnostic('pxr.Tf')
|
|
assert tf_record['wrapper_source'] == record['wrapper']['prepare_module_source']
|
|
assert tf_record['wrapper_source']['path'] == tf.__file__
|
|
assert tf_record['native']['path'] == sys.modules['pxr.Tf._tf'].__file__
|
|
assert tf_record['native']['sha256'] == binding.sha256(Path(sys.modules['pxr.Tf._tf'].__file__).read_bytes())
|
|
assert tf_record['extension_manifest']['path'] == str(Path(tf.__file__).parents[2] / 'config/extension.toml')
|
|
if wrapper.__name__ != 'pxr.Usd':
|
|
assert tf_record['extension_manifest']['path'] != record['wrapper']['extension_manifest']['path']
|
|
assert not (Path(wrapper.__file__).parents[1] / 'Tf').exists()
|
|
# Tf's self-use is finite, not recursive or dependent on an invented spec.
|
|
assert binding._dependency_module_identity('pxr.Tf')['wrapper']['prepare_module_identity'] == tf_record
|
|
|
|
|
|
@pytest.mark.parametrize('change', ['name', 'object', 'loader', 'spec_loader', 'binary', 'wrapper'])
|
|
def test_pxr_rejects_foreign_or_replaced_native_identity(pxr_wrapper, monkeypatch, tmp_path, change):
|
|
wrapper, native = pxr_wrapper
|
|
if change == 'name':
|
|
native.__spec__.name = wrapper.__name__ + '._foreign'
|
|
elif change == 'object':
|
|
wrapper.__spec__ = importlib.util.spec_from_file_location(native.__name__, native.__file__)
|
|
elif change == 'loader':
|
|
wrapper.__loader__ = object()
|
|
elif change == 'spec_loader':
|
|
native.__spec__.loader = importlib.machinery.ExtensionFileLoader(native.__name__, native.__file__)
|
|
elif change == 'binary':
|
|
foreign = tmp_path / '_foreign.so'
|
|
foreign.write_bytes(b'foreign')
|
|
native.__file__ = native.__spec__.origin = str(foreign)
|
|
else:
|
|
foreign = tmp_path / '__init__.py'
|
|
foreign.write_bytes(Path(wrapper.__file__).read_bytes())
|
|
wrapper.__file__ = str(foreign)
|
|
with pytest.raises(ValueError):
|
|
binding._dependency_module_identity(wrapper.__name__)
|
|
|
|
|
|
@pytest.mark.parametrize('change', [
|
|
'missing', 'swapped', 'foreign', 'source_missing', 'source_changed',
|
|
'native_missing', 'native_foreign', 'spec_replaced', 'loader_replaced',
|
|
'manifest_missing', 'manifest_changed', 'manifest_unpinned', 'manifest_swapped', 'manifest_foreign',
|
|
'schema_manifest_missing', 'schema_manifest_changed',
|
|
])
|
|
def test_pxr_rejects_missing_swapped_foreign_tf_and_manifests(pxr_wrapper, monkeypatch, tmp_path, change):
|
|
wrapper, _ = pxr_wrapper
|
|
tf, native = sys.modules['pxr.Tf'], sys.modules['pxr.Tf._tf']
|
|
path = Path(tf.__file__)
|
|
if change == 'missing':
|
|
monkeypatch.delitem(sys.modules, 'pxr.Tf')
|
|
elif change == 'swapped':
|
|
monkeypatch.setitem(sys.modules, 'pxr.Tf', wrapper)
|
|
elif change == 'foreign':
|
|
# Identical bytes under even the pinned schema owner cannot replace Tf.
|
|
foreign = tmp_path / 'extscache/omni.usd.schema.physx-pinned/pxr/Tf/__init__.py'
|
|
foreign.parent.mkdir(parents=True)
|
|
foreign.write_bytes(path.read_bytes())
|
|
tf.__file__ = str(foreign)
|
|
elif change == 'source_missing':
|
|
path.unlink()
|
|
elif change == 'source_changed':
|
|
path.write_text('# changed Tf\n')
|
|
elif change == 'native_missing':
|
|
monkeypatch.delitem(sys.modules, native.__name__)
|
|
elif change == 'native_foreign':
|
|
foreign = tmp_path / '_tf.so'
|
|
foreign.write_bytes(Path(native.__file__).read_bytes())
|
|
native.__file__ = native.__spec__.origin = native.__loader__.path = str(foreign)
|
|
elif change == 'spec_replaced':
|
|
tf.__spec__ = importlib.util.spec_from_file_location(native.__name__, native.__file__)
|
|
elif change == 'loader_replaced':
|
|
tf.__loader__ = object()
|
|
else:
|
|
owner = Path(wrapper.__file__) if change.startswith('schema_') else path
|
|
manifest = owner.parents[2] / 'config/extension.toml'
|
|
if change.endswith('missing'):
|
|
manifest.unlink()
|
|
elif change.endswith('changed'):
|
|
manifest.write_text('# changed owner\n')
|
|
elif change.endswith('swapped'):
|
|
other = next(Path(p) for p in binding.RUNTIME_LAYOUT_PINS if p != str(manifest))
|
|
manifest.write_bytes(other.read_bytes())
|
|
elif change.endswith('foreign'):
|
|
foreign = tmp_path / 'foreign-extension.toml'
|
|
foreign.write_bytes(manifest.read_bytes())
|
|
manifest.unlink()
|
|
manifest.symlink_to(foreign)
|
|
else:
|
|
monkeypatch.delitem(binding.RUNTIME_LAYOUT_PINS, str(manifest))
|
|
with pytest.raises((ValueError, FileNotFoundError)):
|
|
binding._dependency_module_identity(wrapper.__name__)
|
|
|
|
|
|
def test_pxr_tf_binds_actual_raw_alias_not_schema_adjacent_path(pxr_wrapper, monkeypatch, tmp_path):
|
|
wrapper, _ = pxr_wrapper
|
|
tf = sys.modules['pxr.Tf']
|
|
physical = Path(tf.__file__)
|
|
alias = tmp_path / 'usd-libs-alias'
|
|
alias.symlink_to(physical.parents[2])
|
|
monkeypatch.setattr(binding, 'RUNTIME_LINKS', (
|
|
(str(alias), str(alias.readlink()), alias.lstat().st_dev, alias.lstat().st_ino),))
|
|
tf.__file__ = str(alias / 'pxr/Tf/__init__.py')
|
|
record = binding._dependency_module_identity(wrapper.__name__)['wrapper']
|
|
source = record['prepare_module_source']
|
|
assert source['raw_path'] == tf.__file__
|
|
assert source['path'] == str(physical)
|
|
assert source['links'][0]['path'] == str(alias)
|
|
assert record['prepare_module_identity']['wrapper_source'] == source
|
|
|
|
|
|
def test_installed_tf_prepare_module_copies_native_spec_loader_read_only():
|
|
# Execute only the inspected pure-Python definition, never import pxr/Kit or dlopen.
|
|
_, filename, digest = binding.REQUIRED_RUNTIME['pxr.Tf']
|
|
source = Path(filename).read_bytes()
|
|
assert binding.sha256(source) == digest
|
|
tree = ast.parse(source)
|
|
prepare = next(node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name == 'PrepareModule')
|
|
definitions = {}
|
|
exec(compile(ast.Module(body=[prepare], type_ignores=[]), filename, 'exec'), definitions)
|
|
native = ModuleType('pxr.Tf._tf')
|
|
native.__file__ = '/not-loaded/_tf.so'
|
|
native.__spec__ = importlib.util.spec_from_file_location(native.__name__, native.__file__)
|
|
native.__loader__ = native.__spec__.loader
|
|
result = {'__name__': 'pxr.Tf', '__file__': filename, '__package__': 'pxr.Tf', '__path__': ['original']}
|
|
definitions['PrepareModule'](native, result)
|
|
assert result['__spec__'] is native.__spec__
|
|
assert result['__loader__'] is native.__loader__
|
|
assert result['__name__'] == result['__package__'] == 'pxr.Tf'
|
|
assert result['__file__'] == filename and result['__path__'] == ['original']
|
|
assert any(isinstance(node, ast.Expr) and isinstance(node.value, ast.Call)
|
|
and isinstance(node.value.func, ast.Name) and node.value.func.id == 'PreparePythonModule'
|
|
for node in tree.body)
|
|
|
|
|
|
@pytest.fixture(params=['omni', 'usdrt', 'omni.metrics.assembler.core.bindings',
|
|
'omni.metrics.assembler.core.scripts', 'omni.kit', 'usdrt.internal.namespace'])
|
|
def provider(request, tmp_path, monkeypatch):
|
|
name = request.param
|
|
for key in tuple(sys.modules):
|
|
if key.split('.')[0] in ('omni', 'usdrt'):
|
|
monkeypatch.delitem(sys.modules, key)
|
|
monkeypatch.setattr(binding, 'SIM_ROOT', tmp_path)
|
|
extension = tmp_path / 'exts/provider'
|
|
directory = extension.joinpath(*name.split('.'))
|
|
directory.mkdir(parents=True)
|
|
(extension / 'config').mkdir()
|
|
manifest = extension / 'config/extension.toml'
|
|
manifest.write_text('[[python.module]]\nname = "' + name + '.child"\n')
|
|
(directory / 'child.py').write_text('VALUE = 1\n')
|
|
monkeypatch.syspath_prepend(str(extension))
|
|
for child in ['.'.join(name.split('.')[:i]) for i in range(1, len(name.split('.')) + 1)] + [name + '.child']:
|
|
monkeypatch.setitem(sys.modules, child, None)
|
|
del sys.modules[child]
|
|
module = importlib.import_module(name)
|
|
importlib.import_module(name + '.child')
|
|
return name, module, manifest
|
|
|
|
|
|
def test_explicit_provider_records_manifest_children_and_limitation(provider):
|
|
name, module, manifest = provider
|
|
record = binding._dependency_module_identity(name)
|
|
assert record['kind'] == 'kit-provider-namespace'
|
|
assert record['implementation_identity'] == 'unobserved dynamic-provider internals'
|
|
assert record['imported_child_files'][name + '.child']['sha256']
|
|
assert record['extension_manifests'][str(manifest)]['sha256']
|
|
assert 'sha256' not in record and not module.__file__
|
|
manifest.write_text('# changed manifest\n')
|
|
assert record != binding._dependency_module_identity(name)
|
|
|
|
|
|
@pytest.mark.parametrize('change', ['loader', 'manifest', 'child', 'foreign', 'forged-path', 'changed-location'])
|
|
def test_provider_rejects_unbound_evidence(provider, monkeypatch, tmp_path, change):
|
|
name, module, manifest = provider
|
|
if change == 'loader':
|
|
module.__loader__ = object()
|
|
elif change == 'manifest':
|
|
manifest.unlink()
|
|
elif change == 'child':
|
|
monkeypatch.delitem(sys.modules, name + '.child')
|
|
elif change == 'forged-path':
|
|
module.__path__ = module.__spec__.submodule_search_locations = module.__loader__._path = list(module.__path__)
|
|
elif change == 'changed-location':
|
|
other = tmp_path / 'foreign'
|
|
other.mkdir()
|
|
module.__path__._path[:] = [str(other)]
|
|
else:
|
|
monkeypatch.setattr(binding, 'SIM_ROOT', tmp_path / 'foreign')
|
|
with pytest.raises(ValueError):
|
|
binding._dependency_module_identity(name)
|
|
|
|
|
|
def test_frozen_verifier_real_artifacts_unchanged():
|
|
if not (ROOT / replay.CANDIDATE).is_file():
|
|
pytest.skip('frozen artifacts absent; never synthesize a candidate')
|
|
manifest, record = replay.verify_bundle(ROOT)
|
|
assert record['candidate_sha256'] == replay.CANDIDATE_SHA256
|
|
assert record['manifest_sha256'] == replay.MANIFEST_SHA256
|
|
assert record['snapshot_files_verified'] == len(manifest['sources'])
|
|
|
|
|
|
def test_unknown_provider_is_not_an_allowlist_skip(tmp_path, monkeypatch):
|
|
unknown = ModuleType('omni.unknown')
|
|
monkeypatch.setitem(sys.modules, unknown.__name__, unknown)
|
|
with pytest.raises(ValueError, match='Unbound provider namespace spec'):
|
|
binding._dependency_module_identity(unknown.__name__)
|
|
foreign = ModuleType('other_provider')
|
|
monkeypatch.setitem(sys.modules, foreign.__name__, foreign)
|
|
with pytest.raises(ValueError, match='Unreviewed fileless provider'):
|
|
binding._dependency_module_identity(foreign.__name__)
|
|
|
|
|
|
def test_diagnostic_does_not_recalculate_namespace_path(namespace): # noqa: F811
|
|
module, directory = namespace
|
|
module.__path__._path_finder = lambda *args: pytest.fail('must not rediscover')
|
|
before = dict(vars(module.__path__))
|
|
report = binding.module_diagnostic(module.__name__)
|
|
assert report['search_locations'] == [str(directory)]
|
|
assert report['spec_name'] == module.__name__
|
|
assert vars(module.__path__) == before
|
|
binding.canonical_json(report)
|