def test_deprecation(self): import warnings argparser = ArgumentParser(prog='prog', add_help=False) argparser.add_argument('-n', '--normal', action='store') argparser.add_argument( '-d', '--deprecated', action='store', deprecation=True) argparser.add_argument( '--bye', action=StoreDelimitedListBase, deprecation='bye') with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') # test that they store stuff args = argparser.parse_args(['-n', 'hello']) self.assertEqual(args.normal, 'hello') args = argparser.parse_args(['-d', 'hello']) self.assertEqual(args.deprecated, 'hello') args = argparser.parse_args(['--deprecated', 'hello']) self.assertEqual(args.deprecated, 'hello') args = argparser.parse_args(['--bye', 'hello,goodbye']) self.assertEqual(args.bye, ['hello', 'goodbye']) # and the warnings are triggered self.assertEqual( "option '-d' is deprecated", str(w[0].message)) self.assertEqual( "option '--deprecated' is deprecated", str(w[1].message)) self.assertEqual( "option '--bye' is deprecated: bye", str(w[2].message)) stream = StringIO() argparser.print_help(file=stream) # deprecated options are not visible on help self.assertNotIn("--deprecated", stream.getvalue()) self.assertNotIn("--bye", stream.getvalue()) self.assertIn("--normal", stream.getvalue())
def test_plugin_package_chained_loaders_initial_simple(self): working_dir = mkdtemp(self) reg, base, extra, base_dir, extra_dir = self.create_base_extra_plugins( working_dir) simple = reg.records['simple'] = LoaderPluginHandler(reg, 'simple') toolchain = NullToolchain() spec = Spec(working_dir=working_dir) with pretty_logging(stream=StringIO()) as stream: self.assertEqual( {}, simple.generate_handler_sourcepath(toolchain, spec, { 'simple!fun.file': 'fun.file', }), ) with pretty_logging(stream=StringIO()) as stream: self.assertEqual({ 'extra': join(extra_dir, 'extra.js'), }, simple.generate_handler_sourcepath(toolchain, spec, { 'simple!extra!fun.file': 'fun.file', }), ) self.assertIn("for loader plugin 'extra'", stream.getvalue())
def test_export_config_mode_versions(self): config = configuration.WebpackConfig(mode='none', ) self.assertIn('"mode": "none"', str(config)) # downgrade webpack version config['__webpack_target__'] = (2, 6, 1) with pretty_logging(stream=StringIO()) as fd: # default mode value should not be seralized config_str = str(config) self.assertNotIn('"mode": "none"', config_str) self.assertIn("var webpackConfig = {", config_str) self.assertIn( 'INFO calmjs.webpack.configuration unsupported property with ' 'default value removed for webpack 2.6.1: {"mode": "none"}', fd.getvalue()) # change mode to a non-default value config['mode'] = 'production' with pretty_logging(stream=StringIO()) as fd: # default mode value should not be seralized config_str = str(config) self.assertNotIn('"mode": "production"', config_str) self.assertIn("var webpackConfig = {", config_str) self.assertIn( 'WARNING calmjs.webpack.configuration unsupported property with ' 'non-default value removed for webpack 2.6.1: ' '{"mode": "production"}', fd.getvalue())
def test_dump(self): stream = StringIO() json_dump({'a': 'b', 'c': 'd'}, stream) self.assertEqual( stream.getvalue(), '{\n "a": "b",\n "c": "d"\n}' )
def test_get_modpath_pkg_resources_invalid(self): with pretty_logging(stream=StringIO()) as fd: self.assertEqual([], indexer.modpath_pkg_resources(None)) self.assertIn("None does not appear to be a valid module", fd.getvalue()) with pretty_logging(stream=StringIO()) as fd: module = ModuleType('nothing') self.assertEqual([], indexer.modpath_pkg_resources(module)) # module repr differs between python versions. self.assertIn("module 'nothing'", fd.getvalue()) self.assertIn("could not be located", fd.getvalue())
def test_sorted_standard(self): parser = argparse.ArgumentParser(formatter_class=SortedHelpFormatter, add_help=False) parser.add_argument('-z', '--zebra', help='make zebras') parser.add_argument('-a', '--alpaca', help='make alpacas') parser.add_argument('-s', '--sheep', help='make sheep') parser.add_argument('-g', '--goat', help='make goats') stream = StringIO() parser.print_help(file=stream) options = [ line.split()[0] for line in stream.getvalue().splitlines() if '--' in line ] self.assertEqual(options, ['-a', '-g', '-s', '-z'])
def test_sorted_standard(self): parser = argparse.ArgumentParser( formatter_class=SortedHelpFormatter, add_help=False) parser.add_argument('-z', '--zebra', help='make zebras') parser.add_argument('-a', '--alpaca', help='make alpacas') parser.add_argument('-s', '--sheep', help='make sheep') parser.add_argument('-g', '--goat', help='make goats') stream = StringIO() parser.print_help(file=stream) options = [ line.split()[0] for line in stream.getvalue().splitlines() if '--' in line ] self.assertEqual(options, ['-a', '-g', '-s', '-z'])
def test_export_config_optimization(self): config = configuration.WebpackConfig(optimization={"minimize": True}, ) # standard optimization setting is kept for latest webpack with pretty_logging(logger='calmjs.webpack', stream=StringIO()) as fd: config_s = str(config) self.assertIn('"optimization": {', config_s) self.assertIn('"minimize": true', config_s) self.assertEqual('', fd.getvalue()) # downgrade webpack version config['__webpack_target__'] = (2, 6, 1) with pretty_logging(logger='calmjs.webpack', stream=StringIO()) as fd: config_s = str(config) self.assertNotIn('"optimization": {', config_s) self.assertNotIn('"minimize": true', config_s) self.assertIn('new webpack.optimize.UglifyJsPlugin({})', config_s) self.assertIn( "converting unsupported property to a plugin for " "webpack 2.6.1: {", fd.getvalue()) self.assertIn('"minimize": true', fd.getvalue()) # set minimize to false config['optimization']["minimize"] = False with pretty_logging(logger='calmjs.webpack', stream=StringIO()) as fd: config_s = str(config) self.assertNotIn('"optimization": {', config_s) self.assertNotIn('"minimize": true', config_s) self.assertNotIn('new webpack.optimize.UglifyJsPlugin({})', config_s) self.assertIn("dropping unsupported property for webpack 2.6.1: {", fd.getvalue()) self.assertIn('"minimize": false', fd.getvalue()) # set minimize to an unsupported value config['optimization']["minimize"] = {} with pretty_logging(logger='calmjs.webpack', stream=StringIO()) as fd: config_s = str(config) self.assertNotIn('"optimization": {', config_s) self.assertNotIn('"minimize": true', config_s) self.assertNotIn('new webpack.optimize.UglifyJsPlugin({})', config_s) self.assertIn("dropping unsupported property for webpack 2.6.1: {", fd.getvalue()) self.assertIn('"minimize": {}', fd.getvalue())
def test_modname_target_to_config_paths_warning(self): f = plugin.TextPlugin(None).modname_target_to_config_paths # There are cases where if the python style namespace separator # is used for the generated path, and the final fragment has no # further '.' characters, WILL result in a complete mismatch of # the key to the expected target. That said, this particular # type of mapping doesn't seem to be supported at all by the # requirejs-text plugin. with pretty_logging('calmjs.rjs.plugin', stream=StringIO()) as stream: self.assertEqual( f('text!some.target/file', '/src/some/target/file'), {'some.target/file': '/src/some/target/file'}, # Do nothing as this type of conversion/mapping doesn't # work no matter what, because requirejs and/or the text # loader plugin fails at tracking directories if it has # a '.' somewhere, so the loader gets confused and just # don't see the mapping entry. # To mitigate, ensure the provided files or paths # provided have a filename extension and does not end # with a ``.`` character. ) # ensure that is logged err = stream.getvalue() self.assertIn('WARNING', err) self.assertIn('no possible workaround', err)
def test_process_test_files_assorted(self): from calmjs.webpack.cli import default_toolchain as toolchain # the bare minimum spec spec = Spec( build_dir=mkdtemp(self), test_module_paths_map={ # the values are normally absolute paths. 'example/tests/test_main': 'test_main.js', 'example/tests/data.json': 'data.json', 'text!example/tests/data.txt': 'data.txt', }, karma_config={ 'webpack': { 'resolve': { 'alias': {}, }, }, 'preprocessors': {}, }) with pretty_logging(stream=StringIO()) as s: test_files, loaderspath = dev._process_test_files(toolchain, spec) self.assertEqual({'test_main.js'}, test_files) self.assertEqual({'text!example/tests/data.txt': 'data.txt'}, loaderspath) self.assertIn( "only aliasing modpath 'example/tests/data.json' to target " "'data.json'", s.getvalue())
def test_process_path_error(self): build_dir = mkdtemp(self) source1 = join(build_dir, 'source1.js') source2 = join(build_dir, 'source2.js') source3 = join(build_dir, 'source3.js') with open(source1, 'w') as fd: fd.write("define('source1/mod1', ['require','exports','module']," "function (require, exports, module) {});\n" "define('source1/mod2', ['require','exports','module']," "function (require, exports, module) {});\n") with open(source2, 'w') as fd: fd.write("define('source2/mod1', ['require','exports','module']" "function (require, exports, module) {});\n") with open(source3, 'w') as fd: fd.write("define('source3/mod1', ['require','exports','module']," "function (require, exports, module) {});\n") with pretty_logging(stream=StringIO()) as s: result = process_artifacts([source1, source2, source3]) self.assertEqual(sorted(result), ['source1/mod1', 'source1/mod2', 'source3/mod1']) self.assertIn('syntax error in', s.getvalue()) self.assertIn(source2, s.getvalue())
def test_extract_defines_amd_artifact3_missing(self): with pretty_logging(stream=StringIO()) as stream: result = requirejs.extract_defines_with_deps(artifact_multiple3) self.assertEqual(['lib4', 'lib2', 'lib1'], result) s = stream.getvalue() self.assertIn("module 'missing' required but seems to be missing", s) self.assertIn("WARNING", s)
def test_karma_setup_not_webpack_artifact(self): karma_config = karma.build_base_config() src_dir = mkdtemp(self) fake_artifact = join(src_dir, 'fake_artifact.js') with open(fake_artifact, 'w') as fd: fd.write('(function(root, factory) { factory() })') fd.write('(this, function() {});') build_dir = mkdtemp(self) spec = Spec( karma_config=karma_config, build_dir=build_dir, test_module_paths_map={ 'some/package/tests/test_module': '/src/some/package/tests/test_module.js' }, artifact_paths=[fake_artifact], toolchain_bin_path=self.setup_fake_webpack(), ) with pretty_logging(stream=StringIO()) as s: karma_webpack(spec) log = s.getvalue() self.assertIn("unable to extract calmjs related exports from", log) self.assertIn(fake_artifact, log)
def test_rjs_core_compiled_failure_bad_template(self): remember_cwd(self) chdir(self._env_root) build_dir = mkdtemp(self) src_dir = mkdtemp(self) src_template = join(src_dir, 'template.nja') with open(src_template, 'w') as fd: fd.write('<p>Hello {%World%}</p>') spec = Spec( build_dir=build_dir, plugin_sourcepath={ 'text!mold/dummy/template.nja': src_template, }, bundle_sourcepath={}, ) build_dir = mkdtemp(self) rjs(spec, ()) with pretty_logging('nunja', stream=StringIO()) as stream: spec.handle(BEFORE_COMPILE) err = stream.getvalue() self.assertIn('ERROR', err) self.assertIn('failed to precompile', err) self.assertIn('Template render error: (mold/dummy/template.nja)', err)
def test_get_modpath_all_empty(self): module = ModuleType('nothing') with pretty_logging(stream=StringIO()) as fd: self.assertEqual(indexer.modpath_all(module), []) self.assertIn( "module 'nothing' does not appear to be a namespace module", fd.getvalue())
def test_non_working_workaround(self): """ A test to show non-working workaround The annoyances just keeps on giving. """ with pretty_logging(stream=StringIO()) as stream: result = self.registry.modname_source_mapping_to_config_paths({ 'foo/bar': '/src/foo/bar.js', 'text!foo/bar.txt': '/alt/src/foo/bar.txt', }) err = stream.getvalue() self.assertEqual( { 'foo/bar': '/src/foo/bar.js?', 'foo/bar.txt': '/alt/src/foo/bar.txt', }, result['paths']) self.assertIn('WARNING', err) self.assertIn( "the value of paths['foo/bar'] is being rewritten from " "'/alt/src/foo/bar' to '/src/foo/bar.js?'; " "configuration may be in an invalid state.", err)
def test_yarn_no_path(self): tmpdir = mkdtemp(self) os.chdir(tmpdir) os.environ['PATH'] = '' with pretty_logging(stream=StringIO()) as stderr: self.assertIsNone(yarn.get_yarn_version()) self.assertIn("failed to execute 'yarn'", stderr.getvalue())
def test_modname_target_to_config_paths_mismatch_dir_ext_file_noext(self): f = plugin.TextPlugin(None).modname_target_to_config_paths with pretty_logging('calmjs.rjs.plugin', stream=StringIO()) as stream: self.assertEqual( { 'file': 'some.dotted/dir/file', 'file.ns': 'some.dotted/dir/file.ns', 'file.ns/html': 'some.dotted/dir/file.ns/html', }, f('text!file.ns/html', 'text!some.dotted/dir/file.ns/html'), ) # this one provides both the dot stripped and the underlying # directory, to cover both case (unless this screws up some # other thing). err = stream.getvalue() # though since this should work, better to warn about this. self.assertIn('WARNING', err) self.assertIn( "warning triggered by mapping config.paths from " "modpath 'text!file.ns/html' to " "target 'text!some.dotted/dir/file.ns/html'", err) self.assertIn("unsupported values provided", err) self.assertIn("potentially working mitigations applied", err) self.assertIn('text!file.ns/html', err) self.assertIn('text!some.dotted/dir/file.ns/html', err)
def test_fun_edge_case(self): """ A very (un)fun edge case. Since the base module isn't so strict, there are situations where the workaround is still valid. """ with pretty_logging(stream=StringIO()) as stream: result = self.registry.modname_source_mapping_to_config_paths({ 'foo/bar': '/src/foo/bar.js', 'text!foo/bar.txt': '/src/foo/bar.txt', }) err = stream.getvalue() # The mapping created by the plugin is compatible so no warnings # are issued. self.assertNotIn('WARNING', err) self.assertEqual( { 'foo/bar': '/src/foo/bar', # the exact text mapping is also present. 'foo/bar.txt': '/src/foo/bar.txt', }, result['paths'])
def test_nested(self): # the target is 'namespace/text_file.txt' build_dir = mkdtemp(self) srcdir = join(mkdtemp(self), 'namespace') mkdir(srcdir) spec = {'build_dir': build_dir} source = join(srcdir, 'text_file.txt') with open(source, 'w') as fd: fd.write('a text file\n') toolchain = None # this one is not necessary for text. modname = 'text!namespace/text_file.txt' target = 'text!namespace/text_file.txt' modpath = 'text!namespace/text_file.txt' with pretty_logging('calmjs.rjs.plugin', stream=StringIO()) as stream: result = plugin.TextPlugin(None)(toolchain, spec, modname, source, target, modpath) self.assertEqual(stream.getvalue(), '') self.assertTrue(exists(join(build_dir, 'namespace', 'text_file.txt'))) bundled_modpaths, bundled_targets, module_name = result self.assertEqual( bundled_modpaths, { 'text!namespace/text_file.txt': 'text!namespace/text_file.txt', }) self.assertEqual( bundled_targets, { 'namespace/text_file': 'namespace/text_file', 'namespace/text_file.txt': 'namespace/text_file.txt', }) self.assertEqual(module_name, ['text!namespace/text_file.txt'])
def test_requirejs_is_pretty_much_completely_broken(self): """ Showing how requirejs and/or requirejs-text is basically broken I mean, I covered how it basically can't deal with filename extensions correctly, so no amount of workaround can really fix the underlying brokenness. """ with pretty_logging(stream=StringIO()) as stream: result = self.registry.modname_target_mapping_to_config_paths({ 'text!foo/bar.txt': 'text!/src/foo/bar.txt', 'text!foo/bar.html': 'text!/alt/src/foo/bar.html', }) err = stream.getvalue() # html comes before txt, since the mapping is pre-sorted in # alphabetical order, so txt will end up overwriting html's base # directory. self.assertEqual( { 'foo/bar': '/src/foo/bar', 'foo/bar.txt': '/src/foo/bar.txt', 'foo/bar.html': '/alt/src/foo/bar.html', }, result['paths']) self.assertIn('WARNING', err) self.assertIn("value of paths['foo/bar'] is being rewritten", err) self.assertIn("configuration may be in an invalid state", err) self.assertIn( "the value of paths['foo/bar'] is being rewritten from " "'/alt/src/foo/bar' to '/src/foo/bar'; " "configuration may be in an invalid state.", err)
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_missing_distribution(self): d_egg_root = join(mkdtemp(self), 'dummyns') make_dummy_dist(self, ( ( 'namespace_packages.txt', 'not_ns\n', ), ( 'entry_points.txt', '[dummyns]\n' 'dummyns = dummyns:attr\n', ), ), 'dummyns', '2.0', working_dir=d_egg_root) working_set = pkg_resources.WorkingSet([ d_egg_root, self.ds_egg_root, ]) dummyns_ep = next(working_set.iter_entry_points('dummyns')) with pretty_logging(stream=StringIO()) as fd: p = indexer.resource_filename_mod_entry_point( 'dummyns', dummyns_ep) # not stubbed working_set, so this is derived using fallback # value from the sys.modules['dummyns'] location self.assertEqual(normcase(p), normcase(self.dummyns_path)) self.assertIn("distribution 'dummyns 2.0' not found", fd.getvalue())
def test_get_modpath_pkg_resources_missing_path(self): with pretty_logging(stream=StringIO()) as fd: self.assertEqual([], indexer.modpath_pkg_resources(None, calmjs_ep)) self.assertIn("None does not appear to be a valid module", fd.getvalue()) with pretty_logging(stream=StringIO()) as fd: module = ModuleType('nothing') self.assertEqual([], indexer.modpath_pkg_resources(module, calmjs_ep)) err = fd.getvalue() self.assertIn("module 'nothing' and entry_point 'demo = demo'", err) # the input is fetched using a working entry_point, after all self.assertIn("path found at '" + calmjs_dist_dir, err) self.assertIn("it does not exist", fd.getvalue())
def test_webpack_core_compiled_raw(self): remember_cwd(self) chdir(self._env_root) build_dir = mkdtemp(self) src_dir = mkdtemp(self) src_template = join(src_dir, 'template.nja') with open(src_template, 'w') as fd: fd.write('<p>Hello, {name}</p>') spec = Spec( build_dir=build_dir, loaderplugin_sourcepath={ 'text!some/mold/template.nja': src_template, }, bundle_sourcepath={ 'nunjucks': join('node_modules', 'nunjucks', 'nunjucks.js'), }, ) with pretty_logging('nunja', stream=StringIO()) as stream: webpack(spec, ('raw')) # now trigger the advice spec.handle(BEFORE_COMPILE) # template remains in plugins self.assertEqual(spec['loaderplugin_sourcepath'], { 'text!some/mold/template.nja': src_template, }) # will not be applied in raw. self.assertIn('__nunja__/some/mold', spec['bundle_sourcepath']) self.assertIn( 'nunja cannot skip precompilation for webpack toolchain', stream.getvalue(), )
def test_karma_test_files_located(self): karma_config = karma.build_base_config() karma_config['files'] = ['example/package/lib.js'] spec = Spec( karma_config=karma_config, build_dir=mkdtemp(self), rjs_loader_plugin_registry=get(RJS_LOADER_PLUGIN_REGISTRY_NAME), export_module_names=['preexported'], test_module_paths_map={ 'example/package/tests/test_some_module': '/src/example/package/tests/test_some_module.js', 'example/package/tests/some_test_data': '/src/example/package/tests/some_test_data.js', }, ) with pretty_logging(stream=StringIO()): karma_requirejs(spec) with open(spec['karma_requirejs_test_script']) as fd: script = parse(fd.read()) # this is the node for the json in the build file deps = json.loads( script.children()[0].children()[0].initializer.to_ecma()) tests = json.loads( script.children()[1].children()[0].initializer.to_ecma()) self.assertEqual(['example/package/tests/test_some_module'], tests) self.assertEqual( ['preexported', 'example/package/tests/some_test_data'], deps)
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 test_export_config_rules(self): config = configuration.WebpackConfig(module={ "rules": [], }, ) # the disabling rule gets injected with pretty_logging(stream=StringIO()) as fd: self.assertIn('type: "javascript/auto"', str(config)) self.assertIn( 'INFO calmjs.webpack.configuration disabling default json ' 'loader module rule for webpack 4.0.0', fd.getvalue()) # downgrade webpack version config['__webpack_target__'] = (2, 6, 1) with pretty_logging(logger='calmjs.webpack', stream=StringIO()) as fd: self.assertNotIn('type: "javascript/auto"', str(config)) self.assertEqual('', fd.getvalue())
def test_sorted_case_insensitivity(self): parser = argparse.ArgumentParser(formatter_class=SortedHelpFormatter, add_help=False) parser.add_argument('-z', '--zebra', help='make zebras') parser.add_argument('-a', '--alpaca', help='make alpacas') parser.add_argument('-A', '--anteater', help='make anteater') parser.add_argument('-S', '--SNAKE', help='make snake') parser.add_argument('-s', '--sheep', help='make sheep') parser.add_argument('-g', '--goat', help='make goats') stream = StringIO() parser.print_help(file=stream) options = [ line.split()[0] for line in stream.getvalue().splitlines() if '--' in line ] # the case is unspecified due to in-place sorting self.assertEqual(options, ['-a', '-A', '-g', '-S', '-s', '-z'])
def test_empty_modname_target_to_config_paths(self): f = plugin.TextPlugin(None).modname_target_to_config_paths with pretty_logging('calmjs.rjs.plugin', stream=StringIO()) as stream: self.assertEqual( f('text!', 'text!'), {'': ''}, # we are following our own rules... ) self.assertEqual(stream.getvalue(), '')
def test_get_modpath_pkg_resources_invalid(self): # fake both module and entry point, which will trigger an import # error exception internally that gets logged. module = ModuleType('nothing') ep = pkg_resources.EntryPoint.parse('nothing = nothing') with pretty_logging(stream=StringIO()) as fd: self.assertEqual([], indexer.modpath_pkg_resources(module, ep)) self.assertIn("module 'nothing' could not be imported", fd.getvalue())
def test_dict_key_update_overwrite_check_no_update(self): a = {} a['base_key'] = {'k1': 'v1'} mapping = {'k1': 'v1'} with pretty_logging(logger='calmjs.rjs', stream=StringIO()) as s: utils.dict_key_update_overwrite_check(a, 'base_key', mapping) self.assertEqual(s.getvalue(), '') self.assertEqual(a['base_key'], {'k1': 'v1'})
def test_sorted_case_insensitivity(self): parser = argparse.ArgumentParser( formatter_class=SortedHelpFormatter, add_help=False) parser.add_argument('-z', '--zebra', help='make zebras') parser.add_argument('-a', '--alpaca', help='make alpacas') parser.add_argument('-A', '--anteater', help='make anteater') parser.add_argument('-S', '--SNAKE', help='make snake') parser.add_argument('-s', '--sheep', help='make sheep') parser.add_argument('-g', '--goat', help='make goats') stream = StringIO() parser.print_help(file=stream) options = [ line.split()[0] for line in stream.getvalue().splitlines() if '--' in line ] # the case is unspecified due to in-place sorting self.assertEqual(options, ['-a', '-A', '-g', '-S', '-s', '-z'])