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())