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 test_convert_directory_manifests_in_place(self):
"""
keep the manifests in place
"""
stub = self.create_stub()
try:
ManifestParser.populate_directory_manifests([stub], filename="manifest.ini")
self.assertEqual(
sorted(os.listdir(stub)),
["bar", "fleem", "foo", "manifest.ini", "subdir"],
)
parser = ManifestParser()
parser.read(os.path.join(stub, "manifest.ini"))
self.assertEqual(
[i["name"] for i in parser.tests], ["subfile", "bar", "fleem", "foo"]
)
parser = ManifestParser()
parser.read(os.path.join(stub, "subdir", "manifest.ini"))
self.assertEqual(len(parser.tests), 1)
self.assertEqual(parser.tests[0]["name"], "subfile")
except BaseException:
raise
finally:
shutil.rmtree(stub)
def test_include_manifest_defaults(self):
"""
Test that manifest_defaults and manifests() are correctly populated
when includes are used.
"""
include_example = os.path.join(here, 'include-example.ini')
noinclude_example = os.path.join(here, 'just-defaults.ini')
bar_path = os.path.join(here, 'include', 'bar.ini')
foo_path = os.path.join(here, 'include', 'foo.ini')
parser = ManifestParser(manifests=(include_example, noinclude_example))
# Standalone manifests must be appear as-is.
self.assertTrue(include_example in parser.manifest_defaults)
self.assertTrue(noinclude_example in parser.manifest_defaults)
# Included manifests must only appear together with the parent manifest
# that included the manifest.
self.assertFalse(bar_path in parser.manifest_defaults)
self.assertFalse(foo_path in parser.manifest_defaults)
self.assertTrue((include_example,
bar_path) in parser.manifest_defaults)
self.assertTrue((include_example,
foo_path) in parser.manifest_defaults)
# manifests() must only return file paths (strings).
manifests = parser.manifests()
self.assertEqual(len(manifests), 4)
self.assertIn(foo_path, manifests)
self.assertIn(bar_path, manifests)
self.assertIn(include_example, manifests)
self.assertIn(noinclude_example, manifests)
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 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 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 test_recursion_symlinks(self):
workspace = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, workspace)
# create two dirs
os.makedirs(os.path.join(workspace, 'dir1'))
os.makedirs(os.path.join(workspace, 'dir2'))
# create cyclical symlinks
os.symlink(os.path.join('..', 'dir1'),
os.path.join(workspace, 'dir2', 'ldir1'))
os.symlink(os.path.join('..', 'dir2'),
os.path.join(workspace, 'dir1', 'ldir2'))
# create one file in each dir
open(os.path.join(workspace, 'dir1', 'f1.txt'), 'a').close()
open(os.path.join(workspace, 'dir1', 'ldir2', 'f2.txt'), 'a').close()
data = []
def callback(rootdirectory, directory, subdirs, files):
for f in files:
data.append(f)
ManifestParser._walk_directories([workspace], callback)
self.assertEqual(sorted(data), ['f1.txt', 'f2.txt'])
def create_gallery_generator(command_line_arguments, css_directory):
"""
Given command line arguments, wire up the application and return
it to the main function. This requires creating most of the objects
described in the other files from this directory.
Args:
command_line_arguments the command line arguments with the program
name removed.
css_directory the directory containing the CSS files.
"""
input_data = parse_command_line_arguments(command_line_arguments)
# First parse the manifest file
with open(input_data['manifest_file'], 'r') as manifest_file:
parser = ManifestParser(manifest_file)
lookup_table = parser.get_json_data()
factory = GalleryItemFactory(lookup_table, input_data['should_prompt'])
template_exporter = exporter.create_photo_directory_exporter()
template_writer = \
templatewriter.create_template_writer(input_data['output_directory'])
return GalleryGenerator(gallery_item_factory=factory,
input_directory=input_data['input_directory'],
output_directory=input_data['output_directory'],
static_files_directory=css_directory,
exporter=template_exporter,
template_writer=template_writer)
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_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_recursion_symlinks(self):
workspace = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, workspace)
# create two dirs
os.makedirs(os.path.join(workspace, 'dir1'))
os.makedirs(os.path.join(workspace, 'dir2'))
# create cyclical symlinks
os.symlink(os.path.join('..', 'dir1'),
os.path.join(workspace, 'dir2', 'ldir1'))
os.symlink(os.path.join('..', 'dir2'),
os.path.join(workspace, 'dir1', 'ldir2'))
# create one file in each dir
open(os.path.join(workspace, 'dir1', 'f1.txt'), 'a').close()
open(os.path.join(workspace, 'dir1', 'ldir2', 'f2.txt'), 'a').close()
data = []
def callback(rootdirectory, directory, subdirs, files):
for f in files:
data.append(f)
ManifestParser._walk_directories([workspace], callback)
self.assertEqual(sorted(data), ['f1.txt', 'f2.txt'])
def test_just_defaults(self):
"""Ensure a manifest with just a DEFAULT section exposes that data."""
parser = ManifestParser()
manifest = os.path.join(here, 'just-defaults.ini')
parser.read(manifest)
self.assertEqual(len(parser.tests), 0)
self.assertTrue(manifest in parser.manifest_defaults)
self.assertEquals(parser.manifest_defaults[manifest]['foo'], 'bar')
def test_just_defaults(self):
"""Ensure a manifest with just a DEFAULT section exposes that data."""
parser = ManifestParser()
manifest = os.path.join(here, 'just-defaults.ini')
parser.read(manifest)
self.assertEqual(len(parser.tests), 0)
self.assertTrue(manifest in parser.manifest_defaults)
self.assertEquals(parser.manifest_defaults[manifest]['foo'], 'bar')
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_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_verifyDirectory(self):
directory = os.path.join(here, 'verifyDirectory')
# correct manifest
manifest_path = os.path.join(directory, 'verifyDirectory.ini')
manifest = ManifestParser(manifests=(manifest_path, ))
missing = manifest.verifyDirectory(directory, extensions=('.js', ))
self.assertEqual(missing, (set(), set()))
# manifest is missing test_1.js
test_1 = os.path.join(directory, 'test_1.js')
manifest_path = os.path.join(directory,
'verifyDirectory_incomplete.ini')
manifest = ManifestParser(manifests=(manifest_path, ))
missing = manifest.verifyDirectory(directory, extensions=('.js', ))
self.assertEqual(missing, (set(), set([test_1])))
# filesystem is missing test_notappearinginthisfilm.js
missing_test = os.path.join(directory,
'test_notappearinginthisfilm.js')
manifest_path = os.path.join(directory,
'verifyDirectory_toocomplete.ini')
manifest = ManifestParser(manifests=(manifest_path, ))
missing = manifest.verifyDirectory(directory, extensions=('.js', ))
self.assertEqual(missing, (set([missing_test]), set()))
def test_manifest_list(self):
"""
Ensure a manifest with just a DEFAULT section still returns
itself from the manifests() method.
"""
parser = ManifestParser()
manifest = os.path.join(here, 'no-tests.ini')
parser.read(manifest)
self.assertEqual(len(parser.tests), 0)
self.assertTrue(len(parser.manifests()) == 1)
def test_manifest_list(self):
"""
Ensure a manifest with just a DEFAULT section still returns
itself from the manifests() method.
"""
parser = ManifestParser()
manifest = os.path.join(here, 'no-tests.ini')
parser.read(manifest)
self.assertEqual(len(parser.tests), 0)
self.assertTrue(len(parser.manifests()) == 1)
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_manifest_ignore(self):
"""test manifest `ignore` parameter for ignoring directories"""
stub = self.create_stub()
try:
ManifestParser.populate_directory_manifests([stub], filename="manifest.ini", ignore=("subdir",))
parser = ManifestParser()
parser.read(os.path.join(stub, "manifest.ini"))
self.assertEqual([i["name"] for i in parser.tests], ["bar", "fleem", "foo"])
self.assertFalse(os.path.exists(os.path.join(stub, "subdir", "manifest.ini")))
except:
raise
finally:
shutil.rmtree(stub)
def test_manifest_ignore(self):
"""test manifest `ignore` parameter for ignoring directories"""
stub = self.create_stub()
try:
ManifestParser.populate_directory_manifests([stub], filename='manifest.ini', ignore=('subdir',))
parser = ManifestParser()
parser.read(os.path.join(stub, 'manifest.ini'))
self.assertEqual([i['name'] for i in parser.tests],
['bar', 'fleem', 'foo'])
self.assertFalse(os.path.exists(os.path.join(stub, 'subdir', 'manifest.ini')))
except:
raise
finally:
shutil.rmtree(stub)
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_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_include_handle_defaults_False(self):
"""
Test that manifest_defaults and manifests() are correct even when
handle_defaults is set to False.
"""
manifest = os.path.join(here, 'include-example.ini')
foo_path = os.path.join(here, 'include', 'foo.ini')
parser = ManifestParser(manifests=(manifest,), handle_defaults=False,
rootdir=here)
ancestor_ini = os.path.relpath(manifest, parser.rootdir)
self.assertIn(manifest, parser.manifest_defaults)
self.assertNotIn(foo_path, parser.manifest_defaults)
self.assertIn((ancestor_ini, foo_path), parser.manifest_defaults)
self.assertEqual(parser.manifest_defaults[manifest],
{
'foo': 'bar',
'here': here,
})
self.assertEqual(parser.manifest_defaults[(ancestor_ini, foo_path)],
{
'here': os.path.join(here, 'include'),
'red': 'roses',
'blue': 'ocean',
'yellow': 'daffodils',
})
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_include_handle_defaults_False(self):
"""
Test that manifest_defaults and manifests() are correct even when
handle_defaults is set to False.
"""
manifest = os.path.join(here, "include-example.ini")
foo_path = os.path.join(here, "include", "foo.ini")
parser = ManifestParser(manifests=(manifest, ),
handle_defaults=False,
rootdir=here)
ancestor_ini = os.path.relpath(manifest, parser.rootdir)
self.assertIn(manifest, parser.manifest_defaults)
self.assertNotIn(foo_path, parser.manifest_defaults)
self.assertIn((ancestor_ini, foo_path), parser.manifest_defaults)
self.assertEqual(
parser.manifest_defaults[manifest],
{
"foo": "bar",
"here": here,
},
)
self.assertEqual(
parser.manifest_defaults[(ancestor_ini, foo_path)],
{
"here": os.path.join(here, "include"),
"red": "roses",
"blue": "ocean",
"yellow": "daffodils",
},
)
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_path_override(self):
"""You can override the path in the section too.
This shows that you can use a relative path"""
path_example = os.path.join(here, 'path-example.ini')
manifest = ManifestParser(manifests=(path_example, ))
self.assertEqual(manifest.tests[0]['path'],
os.path.join(here, 'fleem'))
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_path_from_fd(self):
"""
Test paths are left untouched when manifest is a file-like object.
"""
fp = StringIO("[section]\npath=fleem")
manifest = ManifestParser(manifests=(fp, ))
self.assertEqual(manifest.tests[0]['path'], 'fleem')
self.assertEqual(manifest.tests[0]['relpath'], 'fleem')
self.assertEqual(manifest.tests[0]['manifest'], None)
def test_comments(self):
"""
ensure comments work, see
https://bugzilla.mozilla.org/show_bug.cgi?id=813674
"""
comment_example = os.path.join(here, 'comment-example.ini')
manifest = ManifestParser(manifests=(comment_example,))
self.assertEqual(len(manifest.tests), 8)
names = [i['name'] for i in manifest.tests]
self.assertFalse('test_0202_app_launch_apply_update_dirlocked.js' in names)
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_defaults(self):
default = os.path.join(here, "default-suppfiles.ini")
parser = ManifestParser(manifests=(default, ))
expected_supp_files = {
"test7": "foo.js",
"test8": "foo.js bar.js",
"test9": "foo.js",
}
for test in parser.tests:
expected = expected_supp_files[test["name"]]
self.assertEqual(test["support-files"], expected)
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_relative_path(self):
"""
Relative test paths are correctly calculated.
"""
relative_path = os.path.join(here, 'relative-path.ini')
manifest = ManifestParser(manifests=(relative_path, ))
self.assertEqual(manifest.tests[0]['path'],
os.path.join(os.path.dirname(here), 'fleem'))
self.assertEqual(manifest.tests[0]['relpath'],
os.path.join('..', 'fleem'))
self.assertEqual(manifest.tests[1]['relpath'],
os.path.join('..', 'testsSIBLING', 'example'))
def test_defaults(self):
default = os.path.join(here, 'default-suppfiles.ini')
parser = ManifestParser(manifests=(default,))
expected_supp_files = {
'test1': 'foo.js # a comment',
'test2': 'foo.js bar.js ',
'test3': 'foo.js # a comment',
}
for test in parser.tests:
expected = expected_supp_files[test['name']]
self.assertEqual(test['support-files'], expected)
def test_relative_path(self):
"""
Relative test paths are correctly calculated.
"""
relative_path = os.path.join(here, "relative-path.ini")
manifest = ManifestParser(manifests=(relative_path, ))
self.assertEqual(manifest.tests[0]["path"],
os.path.join(os.path.dirname(here), "fleem"))
self.assertEqual(manifest.tests[0]["relpath"],
os.path.join("..", "fleem"))
self.assertEqual(manifest.tests[1]["relpath"],
os.path.join("..", "testsSIBLING", "example"))
def test_subsuite_defaults(self):
manifest = os.path.join(here, 'default-subsuite.ini')
parser = ManifestParser(manifests=(manifest,), handle_defaults=False)
expected_subsuites = {
'test1': 'baz',
'test2': 'foo',
}
defaults = parser.manifest_defaults[manifest]
for test in parser.tests:
value = combine_fields(defaults, test)
self.assertEqual(expected_subsuites[value['name']],
value['subsuite'])
def test_subsuite_defaults(self):
manifest = os.path.join(here, "default-subsuite.ini")
parser = ManifestParser(manifests=(manifest, ), handle_defaults=False)
expected_subsuites = {
"test1": "baz",
"test2": "foo",
}
defaults = parser.manifest_defaults[manifest]
for test in parser.tests:
value = combine_fields(defaults, test)
self.assertEqual(expected_subsuites[value["name"]],
value["subsuite"])
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_convert_directory_manifests_in_place(self):
"""
keep the manifests in place
"""
stub = self.create_stub()
try:
ManifestParser.populate_directory_manifests([stub], filename='manifest.ini')
self.assertEqual(sorted(os.listdir(stub)),
['bar', 'fleem', 'foo', 'manifest.ini', 'subdir'])
parser = ManifestParser()
parser.read(os.path.join(stub, 'manifest.ini'))
self.assertEqual([i['name'] for i in parser.tests],
['subfile', 'bar', 'fleem', 'foo'])
parser = ManifestParser()
parser.read(os.path.join(stub, 'subdir', 'manifest.ini'))
self.assertEqual(len(parser.tests), 1)
self.assertEqual(parser.tests[0]['name'], 'subfile')
except:
raise
finally:
shutil.rmtree(stub)
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_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 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_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_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_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_convert_directory_manifests_in_place(self):
"""
keep the manifests in place
"""
stub = self.create_stub()
try:
ManifestParser.populate_directory_manifests([stub], filename="manifest.ini")
self.assertEqual(sorted(os.listdir(stub)), ["bar", "fleem", "foo", "manifest.ini", "subdir"])
parser = ManifestParser()
parser.read(os.path.join(stub, "manifest.ini"))
self.assertEqual([i["name"] for i in parser.tests], ["subfile", "bar", "fleem", "foo"])
parser = ManifestParser()
parser.read(os.path.join(stub, "subdir", "manifest.ini"))
self.assertEqual(len(parser.tests), 1)
self.assertEqual(parser.tests[0]["name"], "subfile")
except:
raise
finally:
shutil.rmtree(stub)
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_convert_directory_manifests_in_place(self):
"""
keep the manifests in place
"""
stub = self.create_stub()
try:
ManifestParser.populate_directory_manifests([stub], filename='manifest.ini')
self.assertEqual(sorted(os.listdir(stub)),
['bar', 'fleem', 'foo', 'manifest.ini', 'subdir'])
parser = ManifestParser()
parser.read(os.path.join(stub, 'manifest.ini'))
self.assertEqual([i['name'] for i in parser.tests],
['subfile', 'bar', 'fleem', 'foo'])
parser = ManifestParser()
parser.read(os.path.join(stub, 'subdir', 'manifest.ini'))
self.assertEqual(len(parser.tests), 1)
self.assertEqual(parser.tests[0]['name'], 'subfile')
except:
raise
finally:
shutil.rmtree(stub)
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_directory_to_manifest(self):
"""
Test our ability to convert a static directory structure to a
manifest.
"""
# First, stub out a directory with files in it::
def create_stub():
directory = tempfile.mkdtemp()
for i in 'foo', 'bar', 'fleem':
file(os.path.join(directory, i), 'w').write(i)
subdir = os.path.join(directory, 'subdir')
os.mkdir(subdir)
file(os.path.join(subdir, 'subfile'), 'w').write('baz')
return directory
stub = create_stub()
self.assertTrue(os.path.exists(stub) and os.path.isdir(stub))
# Make a manifest for it:
self.assertEqual(convert([stub]),
"""[bar]
[fleem]
[foo]
[subdir/subfile]""")
shutil.rmtree(stub) # cleanup
# Now do the same thing but keep the manifests in place:
stub = create_stub()
convert([stub], write='manifest.ini')
self.assertEqual(sorted(os.listdir(stub)),
['bar', 'fleem', 'foo', 'manifest.ini', 'subdir'])
parser = ManifestParser()
parser.read(os.path.join(stub, 'manifest.ini'))
self.assertEqual([i['name'] for i in parser.tests],
['subfile', 'bar', 'fleem', 'foo'])
parser = ManifestParser()
parser.read(os.path.join(stub, 'subdir', 'manifest.ini'))
self.assertEqual(len(parser.tests), 1)
self.assertEqual(parser.tests[0]['name'], 'subfile')
shutil.rmtree(stub)
def test_verifyDirectory(self):
directory = os.path.join(here, 'verifyDirectory')
# correct manifest
manifest_path = os.path.join(directory, 'verifyDirectory.ini')
manifest = ManifestParser(manifests=(manifest_path,))
missing = manifest.verifyDirectory(directory, extensions=('.js',))
self.assertEqual(missing, (set(), set()))
# manifest is missing test_1.js
test_1 = os.path.join(directory, 'test_1.js')
manifest_path = os.path.join(directory, 'verifyDirectory_incomplete.ini')
manifest = ManifestParser(manifests=(manifest_path,))
missing = manifest.verifyDirectory(directory, extensions=('.js',))
self.assertEqual(missing, (set(), set([test_1])))
# filesystem is missing test_notappearinginthisfilm.js
missing_test = os.path.join(directory, 'test_notappearinginthisfilm.js')
manifest_path = os.path.join(directory, 'verifyDirectory_toocomplete.ini')
manifest = ManifestParser(manifests=(manifest_path,))
missing = manifest.verifyDirectory(directory, extensions=('.js',))
self.assertEqual(missing, (set([missing_test]), set()))
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')
