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