def test_parent_inheritance(self): """ Test parent manifest variable inheritance Specifically tests that inherited variables from parent includes properly propagate downstream """ parent_example = os.path.join(here, 'parent', 'level_1', 'level_2', 'level_3', 'level_3.ini') parser = ManifestParser(manifests=(parent_example,)) # Parent manifest test should not be included self.assertEqual(parser.get('name'), ['test_3']) self.assertEqual([(test['name'], os.path.basename(test['manifest'])) for test in parser.tests], [('test_3', 'level_3.ini')]) # DEFAULT values should be the ones from level 1 self.assertEqual(parser.get('name', x='level_1'), ['test_3']) # Write the output to a manifest: buffer = StringIO() parser.write(fp=buffer, global_kwargs={'x': 'level_1'}) self.assertEqual(buffer.getvalue().strip(), '[DEFAULT]\nx = level_1\n\n[test_3]\nsubsuite =')
def test_sanity(self): """Ensure basic parser is sane""" parser = ManifestParser() mozmill_example = os.path.join(here, 'mozmill-example.ini') parser.read(mozmill_example) tests = parser.tests self.assertEqual( len(tests), len(file(mozmill_example).read().strip().splitlines())) # Ensure that capitalization and order aren't an issue: lines = ['[%s]' % test['name'] for test in tests] self.assertEqual(lines, file(mozmill_example).read().strip().splitlines()) # Show how you select subsets of tests: mozmill_restart_example = os.path.join(here, 'mozmill-restart-example.ini') parser.read(mozmill_restart_example) restart_tests = parser.get(type='restart') self.assertTrue(len(restart_tests) < len(parser.tests)) self.assertEqual(len(restart_tests), len(parser.get(manifest=mozmill_restart_example))) self.assertFalse([ test for test in restart_tests if test['manifest'] != os.path.join( here, 'mozmill-restart-example.ini') ]) self.assertEqual(parser.get('name', tags=['foo']), [ 'restartTests/testExtensionInstallUninstall/test2.js', 'restartTests/testExtensionInstallUninstall/test1.js' ]) self.assertEqual( parser.get('name', foo='bar'), ['restartTests/testExtensionInstallUninstall/test2.js'])
def test_sanity(self): """Ensure basic parser is sane""" parser = ManifestParser() mozmill_example = os.path.join(here, 'mozmill-example.ini') parser.read(mozmill_example) tests = parser.tests self.assertEqual(len(tests), len(file(mozmill_example).read().strip().splitlines())) # Ensure that capitalization and order aren't an issue: lines = ['[%s]' % test['name'] for test in tests] self.assertEqual(lines, file(mozmill_example).read().strip().splitlines()) # Show how you select subsets of tests: mozmill_restart_example = os.path.join(here, 'mozmill-restart-example.ini') parser.read(mozmill_restart_example) restart_tests = parser.get(type='restart') self.assertTrue(len(restart_tests) < len(parser.tests)) self.assertEqual(len(restart_tests), len(parser.get(manifest=mozmill_restart_example))) self.assertFalse([test for test in restart_tests if test['manifest'] != os.path.join(here, 'mozmill-restart-example.ini')]) self.assertEqual(parser.get('name', tags=['foo']), ['restartTests/testExtensionInstallUninstall/test2.js', 'restartTests/testExtensionInstallUninstall/test1.js']) self.assertEqual(parser.get('name', foo='bar'), ['restartTests/testExtensionInstallUninstall/test2.js'])
def test_sanity(self): """Ensure basic parser is sane""" parser = ManifestParser() mozmill_example = os.path.join(here, "mozmill-example.ini") parser.read(mozmill_example) tests = parser.tests self.assertEqual(len(tests), len(file(mozmill_example).read().strip().splitlines())) # Ensure that capitalization and order aren't an issue: lines = ["[%s]" % test["name"] for test in tests] self.assertEqual(lines, file(mozmill_example).read().strip().splitlines()) # Show how you select subsets of tests: mozmill_restart_example = os.path.join(here, "mozmill-restart-example.ini") parser.read(mozmill_restart_example) restart_tests = parser.get(type="restart") self.assertTrue(len(restart_tests) < len(parser.tests)) self.assertEqual(len(restart_tests), len(parser.get(manifest=mozmill_restart_example))) self.assertFalse( [test for test in restart_tests if test["manifest"] != os.path.join(here, "mozmill-restart-example.ini")] ) self.assertEqual( parser.get("name", tags=["foo"]), [ "restartTests/testExtensionInstallUninstall/test2.js", "restartTests/testExtensionInstallUninstall/test1.js", ], ) self.assertEqual(parser.get("name", foo="bar"), ["restartTests/testExtensionInstallUninstall/test2.js"])
def test_include_repeated(self): """ Test that repeatedly included manifests are independent of each other. """ include_example = os.path.join(here, 'include-example.ini') included_foo = os.path.join(here, 'include', 'foo.ini') # In the expected output, blue and yellow have the values from foo.ini # (ocean, submarine) instead of the ones from include-example.ini # (violets, daffodils), because the defaults in the included file take # precedence over the values from the parent. include_output = """[include/crash-handling] foo = fleem [fleem] foo = bar [include/flowers] blue = ocean foo = bar red = roses yellow = submarine """ included_output = """[include/flowers] blue = ocean yellow = submarine """ parser = ManifestParser(manifests=(include_example, included_foo), rootdir=here) self.assertEqual(parser.get('name'), ['crash-handling', 'fleem', 'flowers', 'flowers']) self.assertEqual([(test['name'], os.path.basename(test['manifest'])) for test in parser.tests], [('crash-handling', 'bar.ini'), ('fleem', 'include-example.ini'), ('flowers', 'foo.ini'), ('flowers', 'foo.ini')]) self.check_included_repeat(parser, parser.tests[3], parser.tests[2], "%s%s" % (include_output, included_output)) # Same tests, but with the load order of the manifests swapped. parser = ManifestParser(manifests=(included_foo, include_example), rootdir=here) self.assertEqual(parser.get('name'), ['flowers', 'crash-handling', 'fleem', 'flowers']) self.assertEqual([(test['name'], os.path.basename(test['manifest'])) for test in parser.tests], [('flowers', 'foo.ini'), ('crash-handling', 'bar.ini'), ('fleem', 'include-example.ini'), ('flowers', 'foo.ini')]) self.check_included_repeat(parser, parser.tests[0], parser.tests[3], "%s%s" % (included_output, include_output))
def test_parent_defaults_include(self): parent_example = os.path.join(here, "parent", "include", "manifest.ini") parser = ManifestParser(manifests=(parent_example,)) # global defaults should inherit all includes self.assertEqual(parser.get("name", top="data"), ["testFirst.js", "testSecond.js"]) # include specific defaults should only inherit the actual include self.assertEqual(parser.get("name", disabled="YES"), ["testFirst.js"]) self.assertEqual(parser.get("name", disabled="NO"), ["testSecond.js"])
def test_parent_defaults_include(self): parent_example = os.path.join(here, 'parent', 'include', 'manifest.ini') parser = ManifestParser(manifests=(parent_example, )) # global defaults should inherit all includes self.assertEqual(parser.get('name', top='data'), ['testFirst.js', 'testSecond.js']) # include specific defaults should only inherit the actual include self.assertEqual(parser.get('name', disabled='YES'), ['testFirst.js']) self.assertEqual(parser.get('name', disabled='NO'), ['testSecond.js'])
def test_parent_defaults_include(self): parent_example = os.path.join(here, 'parent', 'include', 'manifest.ini') parser = ManifestParser(manifests=(parent_example,)) # global defaults should inherit all includes self.assertEqual(parser.get('name', top='data'), ['testFirst.js', 'testSecond.js']) # include specific defaults should only inherit the actual include self.assertEqual(parser.get('name', disabled='YES'), ['testFirst.js']) self.assertEqual(parser.get('name', disabled='NO'), ['testSecond.js'])
def test_copy(self): """Test our ability to copy a set of manifests""" tempdir = tempfile.mkdtemp() include_example = os.path.join(here, 'include-example.ini') manifest = ManifestParser(manifests=(include_example,)) manifest.copy(tempdir) self.assertEqual(sorted(os.listdir(tempdir)), ['fleem', 'include', 'include-example.ini']) self.assertEqual(sorted(os.listdir(os.path.join(tempdir, 'include'))), ['bar.ini', 'crash-handling', 'flowers', 'foo.ini']) from_manifest = ManifestParser(manifests=(include_example,)) to_manifest = os.path.join(tempdir, 'include-example.ini') to_manifest = ManifestParser(manifests=(to_manifest,)) self.assertEqual(to_manifest.get('name'), from_manifest.get('name')) shutil.rmtree(tempdir)
def test_copy(self): """Test our ability to copy a set of manifests""" tempdir = tempfile.mkdtemp() include_example = os.path.join(here, "include-example.ini") manifest = ManifestParser(manifests=(include_example,)) manifest.copy(tempdir) self.assertEqual(sorted(os.listdir(tempdir)), ["fleem", "include", "include-example.ini"]) self.assertEqual( sorted(os.listdir(os.path.join(tempdir, "include"))), ["bar.ini", "crash-handling", "flowers", "foo.ini"] ) from_manifest = ManifestParser(manifests=(include_example,)) to_manifest = os.path.join(tempdir, "include-example.ini") to_manifest = ManifestParser(manifests=(to_manifest,)) self.assertEqual(to_manifest.get("name"), from_manifest.get("name")) shutil.rmtree(tempdir)
def test_server_root(self): """ Test server_root properly expands as an absolute path """ server_example = os.path.join(here, "parent", "level_1", "level_2", "level_3", "level_3_server-root.ini") parser = ManifestParser(manifests=(server_example,)) # A regular variable will inherit its value directly self.assertEqual(parser.get("name", **{"other-root": "../root"}), ["test_3"]) # server-root will expand its value as an absolute path # we will not find anything for the original value self.assertEqual(parser.get("name", **{"server-root": "../root"}), []) # check that the path has expanded self.assertEqual(parser.get("server-root")[0], os.path.join(here, "parent", "root"))
def test_copy(self): """Test our ability to copy a set of manifests""" tempdir = tempfile.mkdtemp() include_example = os.path.join(here, 'include-example.ini') manifest = ManifestParser(manifests=(include_example, )) manifest.copy(tempdir) self.assertEqual(sorted(os.listdir(tempdir)), ['fleem', 'include', 'include-example.ini']) self.assertEqual(sorted(os.listdir(os.path.join(tempdir, 'include'))), ['bar.ini', 'crash-handling', 'flowers', 'foo.ini']) from_manifest = ManifestParser(manifests=(include_example, )) to_manifest = os.path.join(tempdir, 'include-example.ini') to_manifest = ManifestParser(manifests=(to_manifest, )) self.assertEqual(to_manifest.get('name'), from_manifest.get('name')) shutil.rmtree(tempdir)
def install_from_manifest(self, filepath): """ Installs addons from a manifest :param filepath: path to the manifest of addons to install """ try: from manifestparser import ManifestParser except ImportError: module_logger.critical( "Installing addons from manifest requires the" " manifestparser package to be installed.") raise manifest = ManifestParser() manifest.read(filepath) addons = manifest.get() for addon in addons: if '://' in addon['path'] or os.path.exists(addon['path']): self.install_from_path(addon['path']) continue # No path specified, try to grab it off AMO locale = addon.get('amo_locale', 'en_US') query = 'https://services.addons.mozilla.org/' + locale + '/firefox/api/' + AMO_API_VERSION + '/' if 'amo_id' in addon: query += 'addon/' + addon[ 'amo_id'] # this query grabs information on the addon base on its id else: query += 'search/' + addon[ 'name'] + '/default/1' # this query grabs information on the first addon returned from a search install_path = AddonManager.get_amo_install_path(query) self.install_from_path(install_path) self.installed_manifests.append(filepath)
def install_from_manifest(self, filepath): """ Installs addons from a manifest :param filepath: path to the manifest of addons to install """ manifest = ManifestParser() manifest.read(filepath) addons = manifest.get() for addon in addons: if '://' in addon['path'] or os.path.exists(addon['path']): self.install_from_path(addon['path']) continue # No path specified, try to grab it off AMO locale = addon.get('amo_locale', 'en_US') query = 'https://services.addons.mozilla.org/' + locale + '/firefox/api/' + AMO_API_VERSION + '/' if 'amo_id' in addon: query += 'addon/' + addon['amo_id'] # this query grabs information on the addon base on its id else: query += 'search/' + addon['name'] + '/default/1' # this query grabs information on the first addon returned from a search install_path = AddonManager.get_amo_install_path(query) self.install_from_path(install_path) self.installed_manifests.append(filepath)
def install_from_manifest(self, filepath): """ Installs addons from a manifest :param filepath: path to the manifest of addons to install """ manifest = ManifestParser() manifest.read(filepath) addons = manifest.get() for addon in addons: if "://" in addon["path"] or os.path.exists(addon["path"]): self.install_from_path(addon["path"]) continue # No path specified, try to grab it off AMO locale = addon.get("amo_locale", "en_US") query = "https://services.addons.mozilla.org/" + locale + "/firefox/api/" + AMO_API_VERSION + "/" if "amo_id" in addon: query += "addon/" + addon["amo_id"] # this query grabs information on the addon base on its id else: query += ( "search/" + addon["name"] + "/default/1" ) # this query grabs information on the first addon returned from a search install_path = AddonManager.get_amo_install_path(query) self.install_from_path(install_path) self.installed_manifests.append(filepath)
def install_from_manifest(self, filepath): """ Installs addons from a manifest filepath - path to the manifest of addons to install """ manifest = ManifestParser() manifest.read(filepath) addons = manifest.get() for addon in addons: if '://' in addon['path'] or os.path.exists(addon['path']): self.install_from_path(addon['path']) continue # No path specified, try to grab it off AMO locale = addon.get('amo_locale', 'en_US') query = 'https://services.addons.mozilla.org/' + locale + '/firefox/api/' + AMO_API_VERSION + '/' if 'amo_id' in addon: query += 'addon/' + addon[ 'amo_id'] # this query grabs information on the addon base on its id else: query += 'search/' + addon[ 'name'] + '/default/1' # this query grabs information on the first addon returned from a search install_path = AddonManager.get_amo_install_path(query) self.install_from_path(install_path)
def test_include(self): """Illustrate how include works""" include_example = os.path.join(here, 'include-example.ini') parser = ManifestParser(manifests=(include_example,)) # All of the tests should be included, in order: self.assertEqual(parser.get('name'), ['crash-handling', 'fleem', 'flowers']) self.assertEqual([(test['name'], os.path.basename(test['manifest'])) for test in parser.tests], [('crash-handling', 'bar.ini'), ('fleem', 'include-example.ini'), ('flowers', 'foo.ini')]) # The manifests should be there too: self.assertEqual(len(parser.manifests()), 3) # We already have the root directory: self.assertEqual(here, parser.rootdir) # DEFAULT values should persist across includes, unless they're # overwritten. In this example, include-example.ini sets foo=bar, but # it's overridden to fleem in bar.ini self.assertEqual(parser.get('name', foo='bar'), ['fleem', 'flowers']) self.assertEqual(parser.get('name', foo='fleem'), ['crash-handling']) # Passing parameters in the include section allows defining variables in #the submodule scope: self.assertEqual(parser.get('name', tags=['red']), ['flowers']) # However, this should be overridable from the DEFAULT section in the # included file and that overridable via the key directly connected to # the test: self.assertEqual(parser.get(name='flowers')[0]['blue'], 'ocean') self.assertEqual(parser.get(name='flowers')[0]['yellow'], 'submarine') # You can query multiple times if you need to: flowers = parser.get(foo='bar') self.assertEqual(len(flowers), 2) # Using the inverse flag should invert the set of tests returned: self.assertEqual(parser.get('name', inverse=True, tags=['red']), ['crash-handling', 'fleem']) # All of the included tests actually exist: self.assertEqual([i['name'] for i in parser.missing()], []) # Write the output to a manifest: buffer = StringIO() parser.write(fp=buffer, global_kwargs={'foo': 'bar'}) self.assertEqual(buffer.getvalue().strip(), '[DEFAULT]\nfoo = bar\n\n[fleem]\n\n[include/flowers]\nblue = ocean\nred = roses\nyellow = submarine')
def test_include(self): """Illustrate how include works""" include_example = os.path.join(here, 'include-example.ini') parser = ManifestParser(manifests=(include_example,)) # All of the tests should be included, in order: self.assertEqual(parser.get('name'), ['crash-handling', 'fleem', 'flowers']) self.assertEqual([(test['name'], os.path.basename(test['manifest'])) for test in parser.tests], [('crash-handling', 'bar.ini'), ('fleem', 'include-example.ini'), ('flowers', 'foo.ini')]) # The manifests should be there too: self.assertEqual(len(parser.manifests()), 3) # We already have the root directory: self.assertEqual(here, parser.rootdir) # DEFAULT values should persist across includes, unless they're # overwritten. In this example, include-example.ini sets foo=bar, but # it's overridden to fleem in bar.ini self.assertEqual(parser.get('name', foo='bar'), ['fleem', 'flowers']) self.assertEqual(parser.get('name', foo='fleem'), ['crash-handling']) # Passing parameters in the include section allows defining variables in #the submodule scope: self.assertEqual(parser.get('name', tags=['red']), ['flowers']) # However, this should be overridable from the DEFAULT section in the # included file and that overridable via the key directly connected to # the test: self.assertEqual(parser.get(name='flowers')[0]['blue'], 'ocean') self.assertEqual(parser.get(name='flowers')[0]['yellow'], 'submarine') # You can query multiple times if you need to: flowers = parser.get(foo='bar') self.assertEqual(len(flowers), 2) # Using the inverse flag should invert the set of tests returned: self.assertEqual(parser.get('name', inverse=True, tags=['red']), ['crash-handling', 'fleem']) # All of the included tests actually exist: self.assertEqual([i['name'] for i in parser.missing()], []) # Write the output to a manifest: buffer = StringIO() parser.write(fp=buffer, global_kwargs={'foo': 'bar'}) self.assertEqual(buffer.getvalue().strip(), '[DEFAULT]\nfoo = bar\n\n[fleem]\nsubsuite = \n\n[include/flowers]\nblue = ocean\nred = roses\nsubsuite = \nyellow = submarine')
def test_copy(self): """Test our ability to copy a set of manifests""" tempdir = tempfile.mkdtemp() include_example = os.path.join(here, "include-example.ini") manifest = ManifestParser(manifests=(include_example, )) manifest.copy(tempdir) self.assertEqual(sorted(os.listdir(tempdir)), ["fleem", "include", "include-example.ini"]) self.assertEqual( sorted(os.listdir(os.path.join(tempdir, "include"))), ["bar.ini", "crash-handling", "flowers", "foo.ini"], ) from_manifest = ManifestParser(manifests=(include_example, )) to_manifest = os.path.join(tempdir, "include-example.ini") to_manifest = ManifestParser(manifests=(to_manifest, )) self.assertEqual(to_manifest.get("name"), from_manifest.get("name")) shutil.rmtree(tempdir)
def test_server_root(self): """ Test server_root properly expands as an absolute path """ server_example = os.path.join(here, 'parent', 'level_1', 'level_2', 'level_3', 'level_3_server-root.ini') parser = ManifestParser(manifests=(server_example, )) # A regular variable will inherit its value directly self.assertEqual(parser.get('name', **{'other-root': '../root'}), ['test_3']) # server-root will expand its value as an absolute path # we will not find anything for the original value self.assertEqual(parser.get('name', **{'server-root': '../root'}), []) # check that the path has expanded self.assertEqual( parser.get('server-root')[0], os.path.join(here, 'parent', 'root'))
def test_server_root(self): """ Test server_root properly expands as an absolute path """ server_example = os.path.join(here, 'parent', 'level_1', 'level_2', 'level_3', 'level_3_server-root.ini') parser = ManifestParser(manifests=(server_example,)) # A regular variable will inherit its value directly self.assertEqual(parser.get('name', **{'other-root': '../root'}), ['test_3']) # server-root will expand its value as an absolute path # we will not find anything for the original value self.assertEqual(parser.get('name', **{'server-root': '../root'}), []) # check that the path has expanded self.assertEqual(parser.get('server-root')[0], os.path.join(here, 'parent', 'root'))
def test_update(self): """ Test our ability to update tests from a manifest and a directory of files """ # boilerplate tempdir = tempfile.mkdtemp() for i in range(10): file(os.path.join(tempdir, str(i)), 'w').write(str(i)) # First, make a manifest: manifest = convert([tempdir]) newtempdir = tempfile.mkdtemp() manifest_file = os.path.join(newtempdir, 'manifest.ini') file(manifest_file,'w').write(manifest) manifest = ManifestParser(manifests=(manifest_file,)) self.assertEqual(manifest.get('name'), [str(i) for i in range(10)]) # All of the tests are initially missing: self.assertEqual([i['name'] for i in manifest.missing()], [str(i) for i in range(10)]) # But then we copy one over: self.assertEqual(manifest.get('name', name='1'), ['1']) manifest.update(tempdir, name='1') self.assertEqual(sorted(os.listdir(newtempdir)), ['1', 'manifest.ini']) # Update that one file and copy all the "tests": file(os.path.join(tempdir, '1'), 'w').write('secret door') manifest.update(tempdir) self.assertEqual(sorted(os.listdir(newtempdir)), ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'manifest.ini']) self.assertEqual(file(os.path.join(newtempdir, '1')).read().strip(), 'secret door') # clean up: shutil.rmtree(tempdir) shutil.rmtree(newtempdir)
def test_parent_defaults(self): """ Test downstream variables should overwrite upstream variables """ parent_example = os.path.join(here, "parent", "level_1", "level_2", "level_3", "level_3_default.ini") parser = ManifestParser(manifests=(parent_example,)) # Parent manifest test should not be included self.assertEqual(parser.get("name"), ["test_3"]) self.assertEqual( [(test["name"], os.path.basename(test["manifest"])) for test in parser.tests], [("test_3", "level_3_default.ini")], ) # DEFAULT values should be the ones from level 3 self.assertEqual(parser.get("name", x="level_3"), ["test_3"]) # Write the output to a manifest: buffer = StringIO() parser.write(fp=buffer, global_kwargs={"x": "level_3"}) self.assertEqual(buffer.getvalue().strip(), "[DEFAULT]\nx = level_3\n\n[test_3]")
def test_update(self): """ Test our ability to update tests from a manifest and a directory of files """ # boilerplate tempdir = tempfile.mkdtemp() for i in range(10): file(os.path.join(tempdir, str(i)), 'w').write(str(i)) # First, make a manifest: manifest = convert([tempdir]) newtempdir = tempfile.mkdtemp() manifest_file = os.path.join(newtempdir, 'manifest.ini') file(manifest_file, 'w').write(manifest) manifest = ManifestParser(manifests=(manifest_file, )) self.assertEqual(manifest.get('name'), [str(i) for i in range(10)]) # All of the tests are initially missing: self.assertEqual([i['name'] for i in manifest.missing()], [str(i) for i in range(10)]) # But then we copy one over: self.assertEqual(manifest.get('name', name='1'), ['1']) manifest.update(tempdir, name='1') self.assertEqual(sorted(os.listdir(newtempdir)), ['1', 'manifest.ini']) # Update that one file and copy all the "tests": file(os.path.join(tempdir, '1'), 'w').write('secret door') manifest.update(tempdir) self.assertEqual( sorted(os.listdir(newtempdir)), ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'manifest.ini']) self.assertEqual( file(os.path.join(newtempdir, '1')).read().strip(), 'secret door') # clean up: shutil.rmtree(tempdir) shutil.rmtree(newtempdir)
def test_parent_inheritance(self): """ Test parent manifest variable inheritance Specifically tests that inherited variables from parent includes properly propagate downstream """ parent_example = os.path.join(here, "parent", "level_1", "level_2", "level_3", "level_3.ini") parser = ManifestParser(manifests=(parent_example,)) # Parent manifest test should not be included self.assertEqual(parser.get("name"), ["test_3"]) self.assertEqual( [(test["name"], os.path.basename(test["manifest"])) for test in parser.tests], [("test_3", "level_3.ini")] ) # DEFAULT values should be the ones from level 1 self.assertEqual(parser.get("name", x="level_1"), ["test_3"]) # Write the output to a manifest: buffer = StringIO() parser.write(fp=buffer, global_kwargs={"x": "level_1"}) self.assertEqual(buffer.getvalue().strip(), "[DEFAULT]\nx = level_1\n\n[test_3]")
def test_parent_defaults(self): """ Test downstream variables should overwrite upstream variables """ parent_example = os.path.join(here, 'parent', 'level_1', 'level_2', 'level_3', 'level_3_default.ini') parser = ManifestParser(manifests=(parent_example, )) # Parent manifest test should not be included self.assertEqual(parser.get('name'), ['test_3']) self.assertEqual([(test['name'], os.path.basename(test['manifest'])) for test in parser.tests], [('test_3', 'level_3_default.ini')]) # DEFAULT values should be the ones from level 3 self.assertEqual(parser.get('name', x='level_3'), ['test_3']) # Write the output to a manifest: buffer = StringIO() parser.write(fp=buffer, global_kwargs={'x': 'level_3'}) self.assertEqual(buffer.getvalue().strip(), '[DEFAULT]\nx = level_3\n\n[test_3]')
def test_sanity(self): """Ensure basic parser is sane""" parser = ManifestParser() mozmill_example = os.path.join(here, "mozmill-example.ini") parser.read(mozmill_example) tests = parser.tests self.assertEqual( len(tests), len(open(mozmill_example).read().strip().splitlines())) # Ensure that capitalization and order aren't an issue: lines = ["[%s]" % test["name"] for test in tests] self.assertEqual(lines, open(mozmill_example).read().strip().splitlines()) # Show how you select subsets of tests: mozmill_restart_example = os.path.join(here, "mozmill-restart-example.ini") parser.read(mozmill_restart_example) restart_tests = parser.get(type="restart") self.assertTrue(len(restart_tests) < len(parser.tests)) self.assertEqual(len(restart_tests), len(parser.get(manifest=mozmill_restart_example))) self.assertFalse([ test for test in restart_tests if test["manifest"] != os.path.join( here, "mozmill-restart-example.ini") ]) self.assertEqual( parser.get("name", tags=["foo"]), [ "restartTests/testExtensionInstallUninstall/test2.js", "restartTests/testExtensionInstallUninstall/test1.js", ], ) self.assertEqual( parser.get("name", foo="bar"), ["restartTests/testExtensionInstallUninstall/test2.js"], )
def test_parent_defaults(self): """ Test downstream variables should overwrite upstream variables """ parent_example = os.path.join(here, 'parent', 'level_1', 'level_2', 'level_3', 'level_3_default.ini') parser = ManifestParser(manifests=(parent_example,)) # Parent manifest test should not be included self.assertEqual(parser.get('name'), ['test_3']) self.assertEqual([(test['name'], os.path.basename(test['manifest'])) for test in parser.tests], [('test_3', 'level_3_default.ini')]) # DEFAULT values should be the ones from level 3 self.assertEqual(parser.get('name', x='level_3'), ['test_3']) # Write the output to a manifest: buffer = StringIO() parser.write(fp=buffer, global_kwargs={'x': 'level_3'}) self.assertEqual(buffer.getvalue().strip(), '[DEFAULT]\nx = level_3\n\n[test_3]\nsubsuite =')
def test_install_from_manifest(self): temp_manifest = addon_stubs.generate_manifest() m = ManifestParser() m.read(temp_manifest) addons = m.get() # Obtain details of addons to install from the manifest addons_to_install = [self.am.addon_details(x['path'])['id'] for x in addons] self.am.install_from_manifest(temp_manifest) # Generate a list of addons installed in the profile addons_installed = [unicode(x[:-len('.xpi')]) for x in os.listdir(os.path.join( self.profile.profile, 'extensions', 'staged'))] self.assertEqual(addons_installed.sort(), addons_to_install.sort()) # Cleanup the temporary addon and manifest directories mozfile.rmtree(os.path.dirname(temp_manifest))
def test_update(self): """ Test our ability to update tests from a manifest and a directory of files """ # boilerplate tempdir = create_realpath_tempdir() for i in range(10): open(os.path.join(tempdir, str(i)), "w").write(str(i)) # otherwise empty directory with a manifest file newtempdir = create_realpath_tempdir() manifest_file = os.path.join(newtempdir, "manifest.ini") manifest_contents = str(convert([tempdir], relative_to=tempdir)) with open(manifest_file, "w") as f: f.write(manifest_contents) # get the manifest manifest = ManifestParser(manifests=(manifest_file,)) # All of the tests are initially missing: paths = [str(i) for i in range(10)] self.assertEqual([i["name"] for i in manifest.missing()], paths) # But then we copy one over: self.assertEqual(manifest.get("name", name="1"), ["1"]) manifest.update(tempdir, name="1") self.assertEqual(sorted(os.listdir(newtempdir)), ["1", "manifest.ini"]) # Update that one file and copy all the "tests": open(os.path.join(tempdir, "1"), "w").write("secret door") manifest.update(tempdir) self.assertEqual( sorted(os.listdir(newtempdir)), ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "manifest.ini"], ) self.assertEqual( open(os.path.join(newtempdir, "1")).read().strip(), "secret door" ) # clean up: shutil.rmtree(tempdir) shutil.rmtree(newtempdir)
def test_update(self): """ Test our ability to update tests from a manifest and a directory of files """ # boilerplate tempdir = create_realpath_tempdir() for i in range(10): file(os.path.join(tempdir, str(i)), 'w').write(str(i)) # otherwise empty directory with a manifest file newtempdir = create_realpath_tempdir() manifest_file = os.path.join(newtempdir, 'manifest.ini') manifest_contents = str(convert([tempdir], relative_to=tempdir)) with file(manifest_file, 'w') as f: f.write(manifest_contents) # get the manifest manifest = ManifestParser(manifests=(manifest_file,)) # All of the tests are initially missing: paths = [str(i) for i in range(10)] self.assertEqual([i['name'] for i in manifest.missing()], paths) # But then we copy one over: self.assertEqual(manifest.get('name', name='1'), ['1']) manifest.update(tempdir, name='1') self.assertEqual(sorted(os.listdir(newtempdir)), ['1', 'manifest.ini']) # Update that one file and copy all the "tests": file(os.path.join(tempdir, '1'), 'w').write('secret door') manifest.update(tempdir) self.assertEqual(sorted(os.listdir(newtempdir)), ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'manifest.ini']) self.assertEqual(file(os.path.join(newtempdir, '1')).read().strip(), 'secret door') # clean up: shutil.rmtree(tempdir) shutil.rmtree(newtempdir)
def test_update(self): """ Test our ability to update tests from a manifest and a directory of files """ # boilerplate tempdir = create_realpath_tempdir() for i in range(10): file(os.path.join(tempdir, str(i)), "w").write(str(i)) # otherwise empty directory with a manifest file newtempdir = create_realpath_tempdir() manifest_file = os.path.join(newtempdir, "manifest.ini") manifest_contents = str(convert([tempdir], relative_to=tempdir)) with file(manifest_file, "w") as f: f.write(manifest_contents) # get the manifest manifest = ManifestParser(manifests=(manifest_file,)) # All of the tests are initially missing: paths = [str(i) for i in range(10)] self.assertEqual([i["name"] for i in manifest.missing()], paths) # But then we copy one over: self.assertEqual(manifest.get("name", name="1"), ["1"]) manifest.update(tempdir, name="1") self.assertEqual(sorted(os.listdir(newtempdir)), ["1", "manifest.ini"]) # Update that one file and copy all the "tests": file(os.path.join(tempdir, "1"), "w").write("secret door") manifest.update(tempdir) self.assertEqual( sorted(os.listdir(newtempdir)), ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "manifest.ini"] ) self.assertEqual(file(os.path.join(newtempdir, "1")).read().strip(), "secret door") # clean up: shutil.rmtree(tempdir) shutil.rmtree(newtempdir)
def install_from_manifest(self, filepath): """ Installs addons from a manifest :param filepath: path to the manifest of addons to install """ try: from manifestparser import ManifestParser except ImportError: module_logger.critical( "Installing addons from manifest requires the" " manifestparser package to be installed.") raise manifest = ManifestParser() manifest.read(filepath) addons = manifest.get() for addon in addons: if '://' in addon['path'] or os.path.exists(addon['path']): self.install_from_path(addon['path']) continue # No path specified, try to grab it off AMO locale = addon.get('amo_locale', 'en_US') query = 'https://services.addons.mozilla.org/' + locale + '/firefox/api/' \ + AMO_API_VERSION + '/' if 'amo_id' in addon: # this query grabs information on the addon base on its id query += 'addon/' + addon['amo_id'] else: # this query grabs information on the first addon returned from a search query += 'search/' + addon['name'] + '/default/1' install_path = AddonManager.get_amo_install_path(query) self.install_from_path(install_path) self.installed_manifests.append(filepath)
def test_include(self): """Illustrate how include works""" include_example = os.path.join(here, "include-example.ini") parser = ManifestParser(manifests=(include_example,)) # All of the tests should be included, in order: self.assertEqual(parser.get("name"), ["crash-handling", "fleem", "flowers"]) self.assertEqual( [(test["name"], os.path.basename(test["manifest"])) for test in parser.tests], [("crash-handling", "bar.ini"), ("fleem", "include-example.ini"), ("flowers", "foo.ini")], ) # The including manifest is always reported as a part of the generated test object. self.assertTrue(all([t["ancestor-manifest"] == include_example for t in parser.tests if t["name"] != "fleem"])) # The manifests should be there too: self.assertEqual(len(parser.manifests()), 3) # We already have the root directory: self.assertEqual(here, parser.rootdir) # DEFAULT values should persist across includes, unless they're # overwritten. In this example, include-example.ini sets foo=bar, but # it's overridden to fleem in bar.ini self.assertEqual(parser.get("name", foo="bar"), ["fleem", "flowers"]) self.assertEqual(parser.get("name", foo="fleem"), ["crash-handling"]) # Passing parameters in the include section allows defining variables in # the submodule scope: self.assertEqual(parser.get("name", tags=["red"]), ["flowers"]) # However, this should be overridable from the DEFAULT section in the # included file and that overridable via the key directly connected to # the test: self.assertEqual(parser.get(name="flowers")[0]["blue"], "ocean") self.assertEqual(parser.get(name="flowers")[0]["yellow"], "submarine") # You can query multiple times if you need to: flowers = parser.get(foo="bar") self.assertEqual(len(flowers), 2) # Using the inverse flag should invert the set of tests returned: self.assertEqual(parser.get("name", inverse=True, tags=["red"]), ["crash-handling", "fleem"]) # All of the included tests actually exist: self.assertEqual([i["name"] for i in parser.missing()], []) # Write the output to a manifest: buffer = StringIO() parser.write(fp=buffer, global_kwargs={"foo": "bar"}) expected_output = """[DEFAULT] foo = bar [fleem] [include/flowers] blue = ocean red = roses yellow = submarine""" # noqa self.assertEqual(buffer.getvalue().strip(), expected_output)
def test_include(self): """Illustrate how include works""" include_example = os.path.join(here, "include-example.ini") parser = ManifestParser(manifests=(include_example, )) # All of the tests should be included, in order: self.assertEqual(parser.get("name"), ["crash-handling", "fleem", "flowers"]) self.assertEqual( [(test["name"], os.path.basename(test["manifest"])) for test in parser.tests], [ ("crash-handling", "bar.ini"), ("fleem", "include-example.ini"), ("flowers", "foo.ini"), ], ) # The including manifest is always reported as a part of the generated test object. self.assertTrue( all([ t["ancestor_manifest"] == "include-example.ini" for t in parser.tests if t["name"] != "fleem" ])) # The manifests should be there too: self.assertEqual(len(parser.manifests()), 3) # We already have the root directory: self.assertEqual(here, parser.rootdir) # DEFAULT values should persist across includes, unless they're # overwritten. In this example, include-example.ini sets foo=bar, but # it's overridden to fleem in bar.ini self.assertEqual(parser.get("name", foo="bar"), ["fleem", "flowers"]) self.assertEqual(parser.get("name", foo="fleem"), ["crash-handling"]) # Passing parameters in the include section allows defining variables in # the submodule scope: self.assertEqual(parser.get("name", tags=["red"]), ["flowers"]) # However, this should be overridable from the DEFAULT section in the # included file and that overridable via the key directly connected to # the test: self.assertEqual(parser.get(name="flowers")[0]["blue"], "ocean") self.assertEqual(parser.get(name="flowers")[0]["yellow"], "submarine") # You can query multiple times if you need to: flowers = parser.get(foo="bar") self.assertEqual(len(flowers), 2) # Using the inverse flag should invert the set of tests returned: self.assertEqual(parser.get("name", inverse=True, tags=["red"]), ["crash-handling", "fleem"]) # All of the included tests actually exist: self.assertEqual([i["name"] for i in parser.missing()], []) # Write the output to a manifest: buffer = StringIO() parser.write(fp=buffer, global_kwargs={"foo": "bar"}) expected_output = """[DEFAULT] foo = bar [fleem] [include/flowers] blue = ocean red = roses yellow = submarine""" # noqa self.assertEqual(buffer.getvalue().strip(), expected_output)