def test_modname_loader_map(self):
srcfile = join(mkdtemp(self), 'some.css')
spec = Spec(
build_dir=mkdtemp(self),
calmjs_webpack_modname_loader_map={'some.css': ['style', 'css']},
)
toolchain = Toolchain()
with open(srcfile, 'w') as fd:
fd.write('.body {}')
reg = LoaderPluginRegistry('calmjs.webpack.loaders')
reg.records['style'] = text = loaderplugin.WebpackLoaderHandler(
reg, 'style')
reg.records['css'] = loaderplugin.WebpackLoaderHandler(reg, 'css')
modpaths, targets, export_module_names = text(toolchain, spec,
'style!css!some.css',
srcfile, 'some.css',
'style!css!some.css')
self.assertEqual({'style!css!some.css': 'style!css!some.css'},
modpaths)
self.assertEqual({
'some.css': 'some.css',
'./some.css': 'some.css',
}, targets)
self.assertEqual([], export_module_names)
def test_call_loader_chaining(self):
srcfile = join(mkdtemp(self), 'some.css')
spec = Spec(build_dir=mkdtemp(self))
toolchain = Toolchain()
with open(srcfile, 'w') as fd:
fd.write('body { color: #000; }')
reg = LoaderPluginRegistry('calmjs.webpack.loaders')
reg.records['text'] = text = loaderplugin.WebpackLoaderHandler(
reg, 'text')
reg.records['css'] = loaderplugin.WebpackLoaderHandler(reg, 'css')
modpaths, targets, export_module_names = text(toolchain, spec,
'text!css!some.css',
srcfile, 'some.css',
'text!css!some.css')
self.assertEqual({'text!css!some.css': 'text!css!some.css'}, modpaths)
self.assertEqual({
'some.css': 'some.css',
'./some.css': 'some.css',
}, targets)
self.assertEqual(['text!css!some.css'], export_module_names)
self.assertTrue(exists(join(spec['build_dir'], 'some.css')))
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_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_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_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_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_call_dir_nesting(self):
srcfile = join(mkdtemp(self), 'some.file.txt')
tgtfile = join('dir', 'some.file.txt')
spec = Spec(build_dir=mkdtemp(self))
toolchain = Toolchain()
with open(srcfile, 'w') as fd:
fd.write('hello world')
reg = LoaderPluginRegistry('calmjs.webpack.loaders')
text = loaderplugin.WebpackLoaderHandler(reg, 'text')
modpaths, targets, export_module_names = text(toolchain, spec,
'text!some.file.txt',
srcfile, tgtfile,
'text!some.file.txt')
self.assertTrue(exists(join(spec['build_dir'], 'dir',
'some.file.txt')))
self.assertEqual({'text!some.file.txt': 'text!some.file.txt'},
modpaths)
self.assertEqual(
{
'some.file.txt': tgtfile,
'./some.file.txt': tgtfile,
}, targets)
self.assertEqual(['text!some.file.txt'], export_module_names)
def test_simply_externals(self):
# same case as above, but in externals
self.assertTrue(
toolchain.check_name_declared(
alias={},
loaders={},
externals={'text!some/file.txt'},
loader_registry=LoaderPluginRegistry(
'missing', _working_set=mocks.WorkingSet({})),
name='text!some/file.txt',
))
def test_missing_plugin(self):
with pretty_logging(stream=mocks.StringIO()) as s:
self.assertFalse(
toolchain.check_name_declared(
alias={'some/file.txt': 'some/file.txt'},
loaders={'text': 'text-loader/index.js'},
externals={},
loader_registry=LoaderPluginRegistry(
'missing', _working_set=mocks.WorkingSet({})),
name='text!some/file.txt',
))
self.assertIn(
"check_name_declared cannot resolve handler for "
"'text!some/file.txt'", s.getvalue())
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_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_prepare_compile_assemble_verify_loaders_external(self):
working_dir = utils.mkdtemp(self)
mock_text_loader(working_dir)
src_dir = utils.mkdtemp(self)
index_file = join(src_dir, 'index.js')
with open(index_file, 'w') as fd:
fd.write('var hello = require("text!hello/world.txt");\n')
webpack = toolchain.WebpackToolchain()
spec = Spec(
**{
'build_dir':
self.build_dir,
'export_target':
join(working_dir, 'export.js'),
webpack.webpack_bin_key:
join(self.build_dir, 'webpack'),
LOADERPLUGIN_SOURCEPATH_MAPS: {},
'transpile_sourcepath': {
'index': index_file,
},
'working_dir':
working_dir,
'verify_imports':
True,
'webpack_externals': {
'text!hello/world.txt': {
'amd':
['__calmjs__', 'modules', 'text!hello/world.txt']
}
},
'calmjs_loaderplugin_registry':
LoaderPluginRegistry('dummy',
_working_set=mocks.WorkingSet({})),
})
with pretty_logging(stream=mocks.StringIO()) as s:
webpack.prepare(spec)
webpack.compile(spec)
webpack.assemble(spec)
self.assertNotIn("not in modules: %s" % (['text!hello/world.txt'], ),
s.getvalue())
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_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())
