def test_manual_construction_parent_interactions(self):
self.assertTrue(ModuleLoaderRegistry(
'calmjs.module.loader', _working_set=WorkingSet({})))
# forcibly stub out the real calmjs.module
self.addCleanup(root_registry.records.pop, 'calmjs.module')
root_registry.records['calmjs.module'] = None
with self.assertRaises(ValueError) as e:
ModuleLoaderRegistry(
'calmjs.module.loader', _working_set=WorkingSet({}))
self.assertEqual(
"could not construct child module registry 'calmjs.module.loader' "
"as its parent registry 'calmjs.module' could not be found",
str(e.exception)
)
def test_to_plugin_name(self):
registry = LoaderPluginRegistry(
'calmjs.loader_plugin', _working_set=WorkingSet({}))
self.assertEqual('example', registry.to_plugin_name('example'))
self.assertEqual('example', registry.to_plugin_name('example?hi'))
self.assertEqual('example', registry.to_plugin_name('example!hi'))
self.assertEqual('example', registry.to_plugin_name('example?arg!hi'))
def test_initialize_warning_dupe_plugin(self):
# ensure that we have a proper working registry
working_set = WorkingSet({'calmjs.loader_plugin': [
'example = calmjs.tests.test_loaderplugin:DupePlugin',
'example = calmjs.loaderplugin:NPMLoaderPluginHandler',
]})
# should not trigger import failure
with pretty_logging(stream=StringIO()) as stream:
registry = LoaderPluginRegistry(
'calmjs.loader_plugin', _working_set=working_set)
self.assertIn(
"loader plugin handler for 'example' was already registered to an "
"instance of 'calmjs.tests.test_loaderplugin:DupePlugin'",
stream.getvalue()
)
# the second one will be registered
self.assertTrue(
isinstance(registry.get('example'), LoaderPluginHandler))
# ensure that the handler can be acquired from a full name
self.assertEqual('example', registry.get('example!hi').name)
self.assertEqual('example', registry.get('example?arg!hi').name)
self.assertEqual('example', registry.get('example?arg').name)
self.assertIsNone(registry.get('examplearg'))
self.assertIsNone(registry.get('ex'))
self.assertIsNone(registry.get('ex!ample'))
def test_plugin_loaders_modname_source_to_target(self):
class InterceptHandler(LoaderPluginHandler):
def modname_source_to_target(self, *a, **kw):
# failed to inspect and call parent
return 'intercepted'
reg = LoaderPluginRegistry('simloaders', _working_set=WorkingSet({}))
base = reg.records['base'] = LoaderPluginHandler(reg, 'base')
extra = reg.records['extra'] = LoaderPluginHandler(reg, 'extra')
reg.records['intercept'] = InterceptHandler(reg, 'intercept')
toolchain = NullToolchain()
spec = Spec()
self.assertEqual('fun.file', base.modname_source_to_target(
toolchain, spec, 'base!fun.file', '/some/path/fun.file'))
self.assertEqual('fun.file', extra.modname_source_to_target(
toolchain, spec, 'extra!fun.file', '/some/path/fun.file'))
self.assertEqual('fun.file', base.modname_source_to_target(
toolchain, spec, 'extra!base!fun.file', '/some/path/fun.file'))
# no plugin was found, so no modification
self.assertEqual('noplugin!fun.file', base.modname_source_to_target(
toolchain, spec, 'extra!noplugin!fun.file', '/some/path/fun.file'))
# chained of the same type
self.assertEqual('fun.file', base.modname_source_to_target(
toolchain, spec, 'base!base!base!fun.file',
'/some/path/fun.file'))
# chained but overloaded
self.assertEqual('intercepted', base.modname_source_to_target(
toolchain, spec, 'base!intercept!base!fun.file',
'/some/path/fun.file'))
def test_module_loader_registry_integration(self):
working_set = WorkingSet({
'calmjs.module': [
'module4 = calmjs.testing.module4',
],
'calmjs.module.loader': [
'css = css[style]',
],
__name__: [
'calmjs.module = calmjs.module:ModuleRegistry',
'calmjs.module.loader = '
'calmjs.loaderplugin:ModuleLoaderRegistry',
]},
dist=Distribution(project_name='calmjs.testing', version='0.0')
)
stub_mod_working_set(self, [calmjs.base], working_set)
# Not going to use the global registry, and using our custom
# reservation entry
local_root_registry = Registry(
__name__, 'calmjs.testing', _working_set=working_set)
with pretty_logging(stream=StringIO()):
# silences "distribution 'calmjs.testing 0.0' not found"
# warnings from stdout produced by the indexer, as the
# provided working_set is invalid with entry points that do
# not have a valid distribution.
module_registry = root_registry_get('calmjs.module')
module_loader_registry = root_registry_get('calmjs.module.loader')
registry = local_root_registry.get_record('calmjs.module')
loader_registry = local_root_registry.get_record(
'calmjs.module.loader')
self.assertIsNot(registry, module_registry)
self.assertIsNot(loader_registry, module_loader_registry)
self.assertEqual(
sorted(k for k, v in registry.iter_records()), [
'calmjs.testing.module4',
]
)
# test the basic items.
results = registry.get_records_for_package('calmjs.testing')
self.assertEqual(sorted(results.keys()), [
'calmjs/testing/module4/widget',
])
module4 = registry.get_record('calmjs.testing.module4')
self.assertIn('calmjs/testing/module4/widget', module4)
self.assertEqual({
'css!calmjs/testing/module4/widget.style': resource_filename(
'calmjs.testing', join('module4', 'widget.style')),
}, loader_registry.get_records_for_package('calmjs.testing'))
self.assertEqual(
['css'],
loader_registry.get_loaders_for_package('calmjs.testing')
)
def setUp(self):
working_set = WorkingSet({
'calmjs.rjs.loader_plugin': [
'text = calmjs.rjs.plugin:TextPlugin',
]
})
self.registry = LoaderPluginRegistry('calmjs.rjs.loader_plugin',
_working_set=working_set)
def test_initialize_standard(self):
# ensure that we have a proper working registry
working_set = WorkingSet({
'calmjs.rjs.loader_plugin': [
'text = calmjs.rjs.plugin:TextPlugin',
]
})
registry = LoaderPluginRegistry('calmjs.rjs.loader_plugin',
_working_set=working_set)
self.assertTrue(isinstance(registry.get('text'), TextPlugin))
def test_initialize_standard(self):
# ensure that we have a proper working registry
working_set = WorkingSet({'calmjs.loader_plugin': [
'example = calmjs.loaderplugin:LoaderPluginHandler',
]})
registry = LoaderPluginRegistry(
'calmjs.loader_plugin', _working_set=working_set)
plugin = registry.get('example')
self.assertTrue(isinstance(plugin, LoaderPluginHandler))
self.assertEqual({}, plugin.generate_handler_sourcepath(
NullToolchain(), Spec(), {}))
def test_initialize_failure_missing(self):
working_set = WorkingSet({'calmjs.loader_plugin': [
'not_plugin = calmjs.not_plugin:nothing',
]})
# should not trigger import failure
with pretty_logging(stream=StringIO()) as stream:
registry = LoaderPluginRegistry(
'calmjs.loader_plugin', _working_set=working_set)
self.assertIsNone(registry.get('not_plugin'))
self.assertIn(
"registry 'calmjs.loader_plugin' failed to load loader plugin "
"handler for entry point 'not_plugin =", stream.getvalue(),
)
def test_plugin_loaders_modname_source_to_target_identity(self):
# manually create a registry
reg = LoaderPluginRegistry('simloaders', _working_set=WorkingSet({}))
base = reg.records['local/dev'] = LoaderPluginHandler(reg, 'local/dev')
toolchain = NullToolchain()
spec = Spec()
self.assertEqual('fun.file', base.modname_source_to_target(
toolchain, spec, 'local/dev!fun.file',
'/some/path/fun.file'))
# a redundant usage test
self.assertEqual('local/dev', base.modname_source_to_target(
toolchain, spec, 'local/dev',
'/some/path/to/the/plugin'))
def test_plugin_generate_handler_sourcepath_resolved_registry(self):
base = LoaderPluginHandler(None, 'base')
reg = LoaderPluginRegistry('loaders', _working_set=WorkingSet({}))
toolchain = NullToolchain()
spec = Spec(
working_dir=mkdtemp(self), calmjs_loaderplugin_registry=reg)
with pretty_logging(stream=StringIO()) as stream:
self.assertEqual(
base.generate_handler_sourcepath(toolchain, spec, {
'base!bad': 'base!bad',
}), {})
self.assertIn(
"loaderplugin registry 'loaders' already assigned to spec",
stream.getvalue())
def test_initialize_failure_not_plugin(self):
working_set = WorkingSet({'calmjs.loader_plugin': [
'not_plugin = calmjs.tests.test_loaderplugin:NotPlugin',
]})
# should not trigger import failure
with pretty_logging(stream=StringIO()) as stream:
registry = LoaderPluginRegistry(
'calmjs.loader_plugin', _working_set=working_set)
self.assertIsNone(registry.get('not_plugin'))
self.assertIn(
"'not_plugin = calmjs.tests.test_loaderplugin:NotPlugin' does not "
"lead to a valid loader plugin handler class",
stream.getvalue()
)
def test_initialize_failure_bad_plugin(self):
working_set = WorkingSet({'calmjs.loader_plugin': [
'bad_plugin = calmjs.tests.test_loaderplugin:BadPlugin',
]}, dist=Distribution(project_name='plugin', version='1.0'))
# should not trigger import failure
with pretty_logging(stream=StringIO()) as stream:
registry = LoaderPluginRegistry(
'calmjs.loader_plugin', _working_set=working_set)
self.assertIsNone(registry.get('bad_plugin'))
self.assertIn(
"registration of entry point "
"'bad_plugin = calmjs.tests.test_loaderplugin:BadPlugin' from "
"'plugin 1.0' to registry 'calmjs.loader_plugin' failed",
stream.getvalue()
)
def test_build_bundle_with_data(self):
bundle_dir = utils.mkdtemp(self)
build_dir = utils.mkdtemp(self)
transpile_source_map = {}
transpile_source_map.update(self._example_package_map)
# include custom loader and data
transpile_source_map.update(self._example_package_loader)
bundle_source_map = {}
export_target = join(bundle_dir, 'example.package')
requirejs_plugins = {
'example/package/loader': self._example_package_data
}
custom_registry = LoaderPluginRegistry(
'custom', _working_set=WorkingSet({
'custom': [
'example/package/loader = calmjs.rjs.plugin:TextPlugin']})
)
rjs = toolchain.RJSToolchain()
rjs.loader_plugin_registry = custom_registry
spec = Spec(
transpile_source_map=transpile_source_map,
bundle_source_map=bundle_source_map,
requirejs_plugins=requirejs_plugins,
export_target=export_target,
build_dir=build_dir,
)
with pretty_logging(stream=StringIO()):
# to avoid logging the issue of mismatch map to extension
# to stderr.
rjs(spec)
self.assertTrue(exists(export_target))
# verify that the bundle works with node
stdout, stderr = run_node(
'var requirejs = require("requirejs");\n'
'var define = requirejs.define;\n'
'%s\n'
'var result = requirejs(\n'
' "example/package/loader!example/package/data");\n'
'process.stdout.write("" + result.results.item_count);\n',
export_target,
)
self.assertEqual(stderr, '')
self.assertEqual(stdout, '0')
def test_initialize_failure_bad_plugin(self):
working_set = WorkingSet({
'calmjs.rjs.loader_plugin': [
'bad_plugin = calmjs.rjs.tests.test_registry:BadPlugin',
]
})
# should not trigger import failure
with pretty_logging(stream=StringIO()) as stream:
registry = LoaderPluginRegistry('calmjs.rjs.loader_plugin',
_working_set=working_set)
self.assertIsNone(registry.get('bad_plugin'))
self.assertIn(
"the loader plugin class registered at 'bad_plugin = "
"calmjs.rjs.tests.test_registry:BadPlugin' failed "
"to be instantiated with the following exception",
stream.getvalue())
def test_initialize_warning_dupe_plugin(self):
# ensure that we have a proper working registry
working_set = WorkingSet({
'calmjs.rjs.loader_plugin': [
'text = calmjs.rjs.tests.test_registry:DupePlugin',
'text = calmjs.rjs.plugin:TextPlugin',
]
})
# should not trigger import failure
with pretty_logging(stream=StringIO()) as stream:
registry = LoaderPluginRegistry('calmjs.rjs.loader_plugin',
_working_set=working_set)
self.assertIn(
"loader plugin handler for 'text' was already registered to an "
"instance of 'calmjs.rjs.tests.test_registry:DupePlugin'",
stream.getvalue())
# the second one will be registered
self.assertTrue(isinstance(registry.get('text'), TextPlugin))
def create_base_extra_plugins(self, working_dir):
# manually create a registry
reg = LoaderPluginRegistry('simloaders', _working_set=WorkingSet({}))
base = reg.records['base'] = NPMLoaderPluginHandler(reg, 'base')
base.node_module_pkg_name = 'dummy_pkg1'
extra = reg.records['extra'] = NPMLoaderPluginHandler(reg, 'extra')
extra.node_module_pkg_name = 'dummy_pkg2'
pkg_dir1 = join(working_dir, 'node_modules', 'dummy_pkg1')
pkg_dir2 = join(working_dir, 'node_modules', 'dummy_pkg2')
makedirs(pkg_dir1)
makedirs(pkg_dir2)
with open(join(pkg_dir1, 'package.json'), 'w') as fd:
fd.write('{"main": "base.js"}')
with open(join(pkg_dir2, 'package.json'), 'w') as fd:
fd.write('{"main": "extra.js"}')
return reg, base, extra, pkg_dir1, pkg_dir2
def test_module_loader_registry_multiple_loaders(self):
working_set = WorkingSet({
'calmjs.module': [
'module4 = calmjs.testing.module4',
],
'calmjs.module.loader': [
'css = css[style,css]',
'json = json[json]',
'empty = empty[]',
],
__name__: [
'calmjs.module = calmjs.module:ModuleRegistry',
'calmjs.module.loader = '
'calmjs.loaderplugin:ModuleLoaderRegistry',
]},
# use a real distribution instead for this case
dist=root_working_set.find(Requirement.parse('calmjs')),
)
registry = ModuleRegistry('calmjs.module', _working_set=working_set)
loader_registry = ModuleLoaderRegistry(
'calmjs.module.loader', _working_set=working_set, _parent=registry)
self.assertEqual({
'calmjs': ['calmjs.testing.module4'],
}, loader_registry.package_module_map)
self.assertEqual(
['css', 'empty', 'json'],
sorted(loader_registry.get_loaders_for_package('calmjs'))
)
self.assertEqual([
'css!calmjs/testing/module4/other.css',
'css!calmjs/testing/module4/widget.style',
'json!calmjs/testing/module4/data.json',
], sorted(loader_registry.get_records_for_package('calmjs').keys()))
# was not registered to calmjs.testing
self.assertEqual([], loader_registry.get_loaders_for_package(
'calmjs.testing'))
self.assertEqual({}, loader_registry.get_records_for_package(
'calmjs.testing'))
def test_module_loader_registry_multiple_loaders(self):
working_set = WorkingSet(
{
'calmjs.module': [
'module4 = calmjs.testing.module4',
],
'calmjs.module.webpackloader': [
'style!css = css[css]',
'json = json[json]',
],
__name__: [
'calmjs.module = calmjs.module:ModuleRegistry',
'calmjs.module.webpackloader = '
'calmjs.webpack.loaderplugin:WebpackModuleLoaderRegistry',
]
},
# use a real distribution instead for this case
dist=root_working_set.find(Requirement.parse('calmjs')),
)
registry = ModuleRegistry('calmjs.module', _working_set=working_set)
loader_registry = WebpackModuleLoaderRegistry(
'calmjs.module.webpackloader',
_working_set=working_set,
_parent=registry)
self.assertEqual({
'calmjs': ['calmjs.testing.module4'],
}, loader_registry.package_module_map)
self.assertEqual(
['json', 'style!css'],
sorted(loader_registry.get_loaders_for_package('calmjs')))
self.assertEqual([
WebpackModuleLoaderRegistryKey(
loader='json', modname='calmjs/testing/module4/data.json'),
WebpackModuleLoaderRegistryKey(
loader='style!css',
modname='calmjs/testing/module4/other.css'),
], sorted(loader_registry.get_records_for_package('calmjs').keys()))
def test_plugin_package_dynamic_selection(self):
class CustomHandler(NPMLoaderPluginHandler):
def find_node_module_pkg_name(self, toolchain, spec):
return spec.get('loaderplugin')
reg = LoaderPluginRegistry('lp.reg', _working_set=WorkingSet({}))
base = CustomHandler(reg, 'base')
toolchain = NullToolchain()
spec = Spec(working_dir=mkdtemp(self))
pkg_dir = join(spec['working_dir'], 'node_modules', 'dummy_pkg')
makedirs(pkg_dir)
with open(join(pkg_dir, 'package.json'), 'w') as fd:
fd.write('{"main": "base.js"}')
with pretty_logging(stream=StringIO()) as stream:
self.assertEqual(
{}, base.generate_handler_sourcepath(toolchain, spec, {}))
self.assertIn(
"no npm package name specified or could be resolved for "
"loaderplugin 'base' of registry 'lp.reg'",
stream.getvalue()
)
self.assertIn(
"test_loaderplugin:CustomHandler may be at fault",
stream.getvalue()
)
self.assertNotIn("for loader plugin 'base'", stream.getvalue())
# plug the value into the spec to satisfy the condition for this
# particular loader
spec['loaderplugin'] = 'dummy_pkg'
with pretty_logging(stream=StringIO()) as stream:
self.assertEqual(
join(pkg_dir, 'base.js'),
base.generate_handler_sourcepath(toolchain, spec, {})['base'],
)
self.assertIn("base.js' for loader plugin 'base'", stream.getvalue())
def test_manual_construction_invalid_suffix_fail(self):
with self.assertRaises(ValueError) as e:
ModuleLoaderRegistry('some.module', _working_set=WorkingSet({}))
self.assertEqual(
"child module registry name defined with invalid suffix "
"('some.module' does not end with '.loader')", str(e.exception))
