Issue 5383 - Add tests for the Chrome and Firefox packagers

tests/test_packagerChrome.py

 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 import re
 import json
 import zipfile
 
 from xml.etree import ElementTree
-from itertools import product
 
 import pytest
 
 from buildtools import packager, packagerChrome
+from buildtools.tests.tools import copy_metadata
 
 ICON_SIZES = [32, 48, 64, 256, 53]
 
-TR_FA = [True, False]

[Vasily Kuznetsov, 2017/08/03 16:52:29]

Not sure having this constant is worth it. TR_FA is a bit of a confusing name
and if you call it TRUE_FALSE, then it's kind of pointless to have the constant.

[tlucas, 2017/08/03 21:26:01]

This will be gotten rid of by proper parametrization anyway: Acknowledged.

[tlucas, 2017/08/04 14:51:57]

Done.

-
-MINIMUM_MANIFEST_JSON = [

[Vasily Kuznetsov, 2017/08/03 16:52:29]

Isn't this name a bit confusing given that the content of this constant is not
JSON but a list? Maybe just call it MINIMUM_MANIFEST?

[tlucas, 2017/08/03 21:26:01]

Acknowledged.

[tlucas, 2017/08/04 14:51:57]

Done.

-        ('manifest_version', 2),

[Vasily Kuznetsov, 2017/08/03 16:52:28]

For consistency with other code, it would be better to indent this list as
follows:

FOO = [
    'bar',
    'baz',
]

[tlucas, 2017/08/03 21:26:00]

Acknowledged.

[tlucas, 2017/08/04 14:51:57]

Done.

-        ('author', 'Eyeo GmbH'),
-        ('permissions', ['tabs', '<all_urls>', 'contextMenus', 'webRequest',
-                         'webRequestBlocking', 'webNavigation', 'storage',
-                         'unlimitedStorage', 'notifications']),
-        ('minimum_chrome_version', '49.0'),
-        ('minimum_opera_version', '36.0'),
-        ('devtools_page', 'devtools.html'),
-        ('description', '__MSG_description__'),
-        ('default_locale', 'en_US'),
-        ('short_name', '__MSG_name__'),
-        ('storage', {'managed_schema': 'managed-storage-schema.json'}),
-        ('options_ui', {'open_in_tab': True, 'page': 'options.html'}),
-    ]
+MINIMUM_MANIFEST = [
+    ('manifest_version', 2),
+    ('author', 'Eyeo GmbH'),
+    ('permissions', [
+        'tabs',
+        '<all_urls>',
+        'contextMenus',
+        'webRequest',
+        'webRequestBlocking',
+        'webNavigation',
+        'storage',
+        'unlimitedStorage',
+        'notifications',
+    ]),
+    ('minimum_chrome_version', '49.0'),
+    ('minimum_opera_version', '36.0'),
+    ('devtools_page', 'devtools.html'),
+    ('description', '__MSG_description__'),
+    ('default_locale', 'en_US'),
+    ('short_name', '__MSG_name__'),
+    ('storage', {'managed_schema': 'managed-storage-schema.json'}),
+    ('options_ui', {'open_in_tab': True, 'page': 'options.html'}),
+]
+
+
+@pytest.fixture
+def chrome_metadata(tmpdir):
+    filename = 'metadata.chrome'
+    copy_metadata(filename, tmpdir)
+
+    return packager.readMetadata(str(tmpdir), 'chrome')
+
+
+@pytest.fixture
+def gecko_webext_metadata(tmpdir, chrome_metadata):
+    filename = 'metadata.gecko-webext'
+    copy_metadata(filename, tmpdir)
+
+    # gecko-webext metadata inherits from chrome metadata, assure existence
+    assert chrome_metadata is not None
+
+    return packager.readMetadata(str(tmpdir), 'gecko-webext')
 
 
 @pytest.fixture
 def icons(tmpdir):
     """Valid .png files for testing make_icons"""
-    try:

[Vasily Kuznetsov, 2017/08/03 16:52:31]

Since this runs in tests, we probably know which branch of this try/except will
actually work. Or do we not know it?

[tlucas, 2017/08/03 21:26:01]

We actually do, i just added this try/except before adding pillow to the
tox.ini. Acknowledged

[tlucas, 2017/08/04 14:51:58]

Done.

-        from PIL import Image
-    except:
-        import Image
+    from PIL import Image
 
     paths = []
     icon_dir = tmpdir.mkdir('tmp_icons')
 
     for size in ICON_SIZES:
+        img_path = str(icon_dir.join('abp-{}.png'.format(size)))
         img = Image.new('1', (size, size if size != 53 else size + 1), 0)
-        paths += [str(icon_dir.join('abp-{}.png'.format(size)))]

[Vasily Kuznetsov, 2017/08/03 16:52:31]

What do you think about rewriting this as follows?

        img_path = icon_dir.join(...).strpath
        img.save(img_path)
        paths.append(img_path)

Seems like it would be a bit more readable.

Also, using `some_pypath.strpath` is preferable to `str(some_pythonpath)` since
it's a more specific code that uses py.path API and it's also consistent with
how we're doing it in most other tests.

[tlucas, 2017/08/03 21:26:00]

I agree, this would be a lot more readable.

Regarding the str-comment:
the str(some_pypath) was inspired by the original test_packagerEdge.py content -
which style should i follow here?

Also: Afaik the __str__ method simply returns self.strpath for now and imho the
explicit conversion is more readable - but i wouldn't mind changing that (and
maybe adjust the respective code in test_packagerEdge as well?)

[tlucas, 2017/08/04 14:51:57]

Done / as discussed, not changing the str()-thing

-        img.save(paths[-1])
+        img.save(img_path)
+        paths.append(img_path)
 
     return paths
 
 
 @pytest.fixture
 def keyfile(tmpdir):
     """Test-privatekey for signing files"""
 
     content = """-----BEGIN RSA PRIVATE KEY-----
 MIIEowIBAAKCAQEA0P06DVxOWZ97cvBZWz7DV0DYTFF7Cdrxnu/sCxnHp8IEq+sM
@@ skipping 24 matching lines @@
 -----END RSA PRIVATE KEY-----"""
 
     keyfile_path = str(tmpdir.mkdir('rsakey').join('keyfile'))
 
     with open(keyfile_path, 'wb') as key_fp:
         key_fp.write(content)
 
     return keyfile_path
 
 
-@pytest.mark.parametrize(

[Vasily Kuznetsov, 2017/08/03 16:52:28]

What do you think about creating 3 fixtures instead: `gecko_metadata`,
`chrome_metadata` and `edge_metadata`? Then the tests could depend on those
fixtures directly instead of having to copy these `mark.parametrize` and
`mark.usefixtures` everywhere.

[tlucas, 2017/08/03 21:26:00]

This would also reduce the amount of readMetadata-calls. Acknowledged.

[tlucas, 2017/08/04 14:51:58]

Done.

-    'metadata_files',
-    [['metadata.chrome', 'metadata.gecko-webext']],
-    indirect=True)
-@pytest.mark.usefixtures('metadata_files')
-def test_create_manifest(srcdir, files):
-    for release, devenv, ext_type in product(
-            TR_FA, TR_FA, ['chrome', 'gecko-webext']):
-
-        metadata = packagerChrome.readMetadata(str(srcdir), ext_type)
-
-        version = packager.getBuildVersion(str(srcdir), metadata, release)
-        params = {
-            'type': ext_type,
-            'baseDir': str(srcdir),
-            'releaseBuild': release,
-            'version': version,
-            'devenv': devenv,
-            'metadata': metadata,
-        }
-        manifest = json.loads(packagerChrome.createManifest(params, files))
-
-        expected_values = MINIMUM_MANIFEST_JSON + [
-            ('name', '__MSG_name_' + ('devbuild__' if not release else '_')),
-            ('version', '1.2.3' + ('.0' if not release else '')),
+@pytest.mark.parametrize('release', [True, False])
+@pytest.mark.parametrize('devenv', [True, False])
+@pytest.mark.parametrize('ext_type', ['chrome', 'gecko-webext'])
+def test_create_manifest(srcdir, files, release, devenv, ext_type,
+                         chrome_metadata, gecko_webext_metadata):
+
+    if ext_type == 'chrome':

[Vasily Kuznetsov, 2017/08/10 19:48:28]

Instead of this you could do:

@pytest.mark.parametrize('ext_type,metadata', [
    ('chrome', chrome_metadata),
    ('gecko-webext', gecko_webext_metadata),
])

this would be a bit cleaner.

[tlucas, 2017/08/11 12:17:09]

I thought about that too and i definitely agree with you, but according to ->
https://github.com/pytest-dev/pytest/issues/349
parametrizing with a fixture is a not yet implemented proposal. I could call the
xxx_metadata()-functions in the decorator, but iirc that would call them for
every permutation of the parameters, which we don't want.

if you don't mind i'll leave this as is.

[Vasily Kuznetsov, 2017/08/11 16:46:00]

Yes, you're right.

+        metadata = chrome_metadata
+    else:
+        metadata = gecko_webext_metadata
+
+    version = packager.getBuildVersion(str(srcdir), metadata, release)
+    params = {
+        'type': ext_type,
+        'baseDir': str(srcdir),
+        'releaseBuild': release,
+        'version': version,
+        'devenv': devenv,
+        'metadata': metadata,
+    }
+    manifest = json.loads(packagerChrome.createManifest(params, files))
+
+    expected_values = MINIMUM_MANIFEST + [
+        ('name', '__MSG_name_' + ('devbuild__' if not release else '_')),
+        ('version', '1.2.3' + ('.0' if not release else '')),
+    ]
+
+    if ext_type == 'gecko-webext':
+        expected_values += [
+            ('applications', {
+                'gecko': {
+                    'id': '{d10d0bf8-f5b5-c8b4-a8b2-2b9879e08c5d}',
+                    'strict_min_version': '50.0',
+                    }
+                })
         ]
-
-        if ext_type == 'gecko-webext':
-            expected_values += [
-                ('applications', {
-                    'gecko': {
-                        'id': '{d10d0bf8-f5b5-c8b4-a8b2-2b9879e08c5d}',
-                        'strict_min_version': '50.0',
-                        }
-                    })
-            ]
-            if not release:
-                expected_values[-1][1]['gecko'].update({
-                        'update_url': ''.join((
-                            'https://downloads.adblockplus.org/devbuilds/',
-                            'adblockplusfirefox/updates.json'))
-                    })
-
-        for key, value in expected_values:
-            assert manifest.get(key, None) == value
+        if not release:
+            expected_values[-1][1]['gecko'].update({
+                    'update_url': ''.join((
+                        'https://downloads.adblockplus.org/devbuilds/',
+                        'adblockplusfirefox/updates.json'))
+                })
+
+    for key, value in expected_values:
+        assert manifest.get(key, None) == value
 
 
 def test_sign_binary(files, keyfile):
     from Crypto.Hash import SHA
     from Crypto.PublicKey import RSA
     from Crypto.Signature import PKCS1_v1_5
 
     digest = SHA.new()
 
     signature = packagerChrome.signBinary(files.zipToString(), keyfile)
 
     with open(keyfile, 'r') as fp:
         rsa_key = RSA.importKey(fp.read())
 
     signer = PKCS1_v1_5.new(rsa_key)
 
     digest.update(files.zipToString())
     assert signer.verify(digest, signature)
 
 
 def test_get_public_key(keyfile):
-    expected = ''.join((

[Vasily Kuznetsov, 2017/08/03 16:52:31]

You can actually write this as follows:

    expected = (
        '3495802348590234850934850234509'
        '4909324063490682390462820934680'
        ...
    )

When a bunch of string literals are written one after another like this, Python
will just concatenate them into one big constant.

[tlucas, 2017/08/03 21:26:02]

Acknowledged.

[tlucas, 2017/08/04 14:51:57]

Done.

-        '30820122300d06092a864886f70d01010105000382010f003082010a0282010100d0',
-        'fd3a0d5c4e599f7b72f0595b3ec35740d84c517b09daf19eefec0b19c7a7c204abeb',
-        '0caeaa1da768bc793b1d767b614e703ddf08858855f3ebff658902ab481b68804186',
-        'dad9ab4fbde3cb999d39e866ee1ea6523cbac0bb99422b98fd1589eb8e77ff41f76c',
-        'a080f08948754f0f9249f90c9587f988a24940f4d54e5930b9fc9bff8e0ffafd08bb',
-        '205a8255e15097cb3308b5c73c86545b8927bfdc342664e3db17405dd49bfa94d038',
-        '446d14f2803aab9b35e70de7fff16334eade568732c6059658693f6b09642667b5c6',
-        '7df2077ca1ef86f9d451ecafdbe18938dcb3e40d3b5052f5f03fa1abf30ceb354387',
-        'cb9d36ca9fa2658393808d6b62ab8be3490203010001'))
+    expected = (
+        '30820122300d06092a864886f70d01010105000382010f003082010a0282010100d0'
+        'fd3a0d5c4e599f7b72f0595b3ec35740d84c517b09daf19eefec0b19c7a7c204abeb'
+        '0caeaa1da768bc793b1d767b614e703ddf08858855f3ebff658902ab481b68804186'
+        'dad9ab4fbde3cb999d39e866ee1ea6523cbac0bb99422b98fd1589eb8e77ff41f76c'
+        'a080f08948754f0f9249f90c9587f988a24940f4d54e5930b9fc9bff8e0ffafd08bb'
+        '205a8255e15097cb3308b5c73c86545b8927bfdc342664e3db17405dd49bfa94d038'
+        '446d14f2803aab9b35e70de7fff16334eade568732c6059658693f6b09642667b5c6'
+        '7df2077ca1ef86f9d451ecafdbe18938dcb3e40d3b5052f5f03fa1abf30ceb354387'
+        'cb9d36ca9fa2658393808d6b62ab8be3490203010001')
 
     publickey = packagerChrome.getPublicKey(keyfile)
     assert publickey.encode('hex') == expected
 
 
-@pytest.mark.parametrize('metadata_files', ['metadata.chrome'], indirect=True)
-@pytest.mark.usefixtures('metadata_files')
-def test_get_package_files(srcdir):
-    extensions = ['html', 'js', 'json', 'xml']

[Vasily Kuznetsov, 2017/08/03 16:52:31]

What do you think about replacing this with:

    files = ['foo.html', 'foo.js', 'foo.json', 'foo.xml']

Then you wouldn't need to prepend 'foo.' to each extension twice in the
following code and it would become simpler and more readable.

[tlucas, 2017/08/03 21:26:00]

Acknowledged.

[tlucas, 2017/08/04 14:51:58]

Done.

-    for extension in extensions:
-        srcdir.join(''.join(('foo.', extension))).write('', ensure=True)
-
-    for devenv in [True, False]:

[Vasily Kuznetsov, 2017/08/03 16:52:31]

What do you think about making devenv a parameter to the test:

@pytest.mark.parametrize('devenv', [True, False])
def test_get_package_files(srcdir, devenv):
    ...

This would convert this test into two test items that might pass or fail
independently thus producing better granularity of the reporting. And it seems
like semantically this `devenv` thing is a parameter to the test, so it's a bit
cleaner if it is explicitly declared as such.

[tlucas, 2017/08/03 21:26:00]

Acknowledged.

[tlucas, 2017/08/04 14:51:59]

Done.

-        params = {
-            'baseDir': str(srcdir),
-            'devenv': devenv,
-        }
-
-        files = packagerChrome.getPackageFiles(params)
-
-        assert devenv == ('qunit' in files)

[Vasily Kuznetsov, 2017/08/03 16:52:31]

This is clever and compact, but I'm wondering if it would be more readable to
write:

    if devenv:
        assert 'qunit' in files
    else:
        assert 'qunit' not in files

This seems to express intent better. I don't feel very strong about this one, so
if you don't like using 4 lines instead of one, may I suggest changing the order
in your version:

    assert ('qunit' in files) == devenv

This reads a bit better I think.

P.S. Another one-liner version, that seems a bit more readable to me is this:

    assert 'qunit' in files if devenv else 'qunit' not in files

I'm happy to let you choose which one you prefer ;)

[tlucas, 2017/08/03 21:26:01]

In this case i'll choose your reordered approach - it follows the somehow more
natural-seeming order of "primary-thing-to-check vs thing-to-check-against" 

[tlucas, 2017/08/04 14:51:58]

Done.

-
-        for expected in ['icons', 'ui', 'skin', 'ext', '_locales', 'lib',
-                         'jquery-ui'] + ['foo.' + ext for ext in extensions]:
-            assert expected in files
+@pytest.mark.usefixtures('chrome_metadata')
+@pytest.mark.parametrize('devenv', [True, False])
+def test_get_package_files(srcdir, devenv):
+    filenames = [
+        'foo.html',
+        'foo.js',
+        'foo.json',
+        'foo.xml',
+    ]
+
+    for filename in filenames:
+        srcdir.join(filename).write('', ensure=True)
+
+    params = {
+        'baseDir': str(srcdir),
+        'devenv': devenv,
+    }
+
+    files = packagerChrome.getPackageFiles(params)
+
+    assert ('qunit' in files) == devenv
+
+    for expected in ['icons', 'ui', 'skin', 'ext', '_locales', 'lib',
+                     'jquery-ui'] + [name for name in filenames]:
+        assert expected in files
 
 
 def test_make_icons(icons, capsys):
     files = packager.Files(set(), set())
     for path in icons:
         files[path] = open(path, 'r').read()
     result = packagerChrome.makeIcons(files, icons)
 
     out, err = capsys.readouterr()
 
     assert 'should be square' in err
-    assert not any(size not in result for size in ICON_SIZES)

[Vasily Kuznetsov, 2017/08/03 16:52:28]

Is this the same as `assert all(size in result for size in ICON_SIZES)`?

Also, what do you think about `assert set(result) >= set(ICON_SIZES)`?

[tlucas, 2017/08/03 21:26:02]

The result would be the same - but all(..) is more readable, yes - and get's rid
of 2 nots. Changing it.


Comparing the sets would be even more readable, but why greater-than-equal? From
what i see / thought of, we should expect the exact same values on both sides

[tlucas, 2017/08/04 14:51:57]

Done.

-
-
-@pytest.mark.parametrize('metadata_files', ['metadata.chrome'], indirect=True)
-@pytest.mark.usefixtures('metadata_files')
-def test_create_script_page(srcdir):
-    metadata = packagerChrome.readMetadata(str(srcdir), 'chrome')
-    params = {'metadata': metadata}
+    assert set(result) == set(ICON_SIZES)
+
+
+def test_create_script_page(srcdir, chrome_metadata):
+    params = {'metadata': chrome_metadata}
 
     template = packagerChrome.createScriptPage(

[Vasily Kuznetsov, 2017/08/03 16:52:29]

Could you please reformat this as follows:

    template = packagerChrome.createScriptPage(
        params, ...
    )

I know this is not mentioned in the style guide but we've been trying to stick
to this style as it's considered more readable by some and equally readable by
others. The rule will probably make it to the style guide at some point :D

[tlucas, 2017/08/03 21:26:01]

Acknowledged.

[tlucas, 2017/08/04 14:51:59]

Done.

-        params, 'testIndex.html.tmpl', ('general', 'testScripts'))
-
-    template_scripts = [elem.attrib['src'] for elem in

[Vasily Kuznetsov, 2017/08/03 16:52:31]

Not that it matters for performance, but to improve clarity, since we're only
doing `foo in template_scripts` checks on this, maybe it should be a set
comprehension?

[tlucas, 2017/08/03 21:26:01]

Acknowledged.

[tlucas, 2017/08/04 14:51:58]

Done.

-                        ElementTree.fromstring(template).iter('script')]
-
-    for src in metadata.get('general', 'testScripts').split():
+        params, 'testIndex.html.tmpl', ('general', 'testScripts')
+    )
+
+    template_scripts = {elem.attrib['src'] for elem in
+                        ElementTree.fromstring(template).iter('script')}
+
+    for src in chrome_metadata.get('general', 'testScripts').split():
         assert src in template_scripts
 
 
-@pytest.mark.parametrize('metadata_files', ['metadata.chrome'], indirect=True)
-@pytest.mark.usefixtures('metadata_files')
-def test_convert_js(srcdir, files):
-    metadata = packagerChrome.readMetadata(str(srcdir), 'chrome')
+def test_convert_js(srcdir, files, chrome_metadata):
     params = {
         'type': 'chrome',
-        'metadata': metadata,
+        'metadata': chrome_metadata,
     }
 
     packagerChrome.convertJS(params, files)
     source = files['lib/foo.js']
 
     assert 'var foo;' in source
     assert 'var bar;' in source
 
 
 def test_to_json():
     data = {'bar': ['foo', 'foobar', 1, True]}
     data_json = packagerChrome.toJson(data)
 
-    assert data_json[-1] == '\n'

[Vasily Kuznetsov, 2017/08/03 16:52:31]

Maybe `data_json.endswith('\n')`?

[tlucas, 2017/08/03 21:26:01]

Acknowledged.

[tlucas, 2017/08/04 14:51:57]

Done.

+    assert data_json.endswith('\n')
     json.loads(data_json)
 
 
-@pytest.mark.parametrize('metadata_files', ['metadata.chrome'], indirect=True)
-@pytest.mark.usefixtures('metadata_files')
-def test_import_gecko_locales(tmp_dir, srcdir, files):
-    metadata = packagerChrome.readMetadata(str(srcdir), 'chrome')
-    version = packager.getBuildVersion(str(srcdir), metadata, False)

[Vasily Kuznetsov, 2017/08/03 16:52:28]

Here and in other places: it's better to do it this way: `srcdir.strpath`.

[tlucas, 2017/08/03 21:26:01]

Please see comment above

[tlucas, 2017/08/04 14:51:58]

As discussed

+def test_import_gecko_locales(tmpdir, srcdir, files, chrome_metadata):
+    version = packager.getBuildVersion(str(srcdir), chrome_metadata, False)
     params = {
         'type': 'chrome',
         'baseDir': str(srcdir),
         'releaseBuild': False,
         'version': version,
         'devenv': False,
-        'metadata': metadata,
+        'metadata': chrome_metadata,
     }
 
     data = {'name': 'foo', 'name_devbuild': 'bar'}
 
-    t_dir = tmp_dir.mkdir('_trans').mkdir('en-US')
+    t_dir = tmpdir.mkdir('_trans').mkdir('en-US')
     t_dir.join('test.properties').write(
         '\n'.join(

[Vasily Kuznetsov, 2017/08/10 19:48:28]

The following line would fit on this line too. Not a big deal, just would be a
bit easier to read.

[tlucas, 2017/08/11 12:17:09]

Done.

-            '='.join((k, v)) for k, v in data.iteritems()))

[Vasily Kuznetsov, 2017/08/03 16:52:31]

What do you think about

    '{}={}'.format(k, v)

instead? Seems a bit more clear to me. Also `.iteritems()` is a performance
optimization that's not compatible with Python 3, so it's probably better to use
`.items()` here.

[tlucas, 2017/08/03 21:26:00]

Acknowledged.

[tlucas, 2017/08/04 14:51:59]

Done.

+            '{}={}'.format(k, v) for k, v in data.items()))
 
     packagerChrome.importGeckoLocales(params, files)
     trans_data = json.loads(files['_locales/en_US/messages.json'])
 
-    for key, value in data.iteritems():
-        assert trans_data.get('test_{}'.format(key), {})\

[Vasily Kuznetsov, 2017/08/03 16:52:28]

Flake8 should have told you that `'test_' + key` is better in this case. This
will also make the whole assert statement fit in 80 lines and you won't need to
split the line with "\" -- a practice that PEP8 frowns upon.

[tlucas, 2017/08/03 21:26:00]

Acknowledged, although flake8 / tox did not inform / complain about this. Will
look into it.

[tlucas, 2017/08/04 14:51:59]

Done. No idea why flake8 didn't bother though

-               .get('message', '') == value
+    for key, value in data.items():
+        assert trans_data.get('test_' + key, {}).get('message', '') == value
 
 
 def test_fix_translations_for_cws(files):
     files['_locales/de/messages.json'] = packagerChrome.toJson({})
     files['manifest.json'] = packagerChrome.toJson(

[Vasily Kuznetsov, 2017/08/10 19:48:28]

Here the following line would also fit into this line, I think.

[tlucas, 2017/08/11 12:17:08]

Done.

-        {k: v for k, v in MINIMUM_MANIFEST_JSON})

[Vasily Kuznetsov, 2017/08/03 16:52:30]

You can just use `dict(MINIMUM_MANIFEST_JUST)` here for the same effect.

[tlucas, 2017/08/03 21:26:00]

Acknowledged.

[tlucas, 2017/08/04 14:51:59]

Done.

+        dict(MINIMUM_MANIFEST))
     packagerChrome.fixTranslationsForCWS(files)
 
     ger_messages = json.loads(files['_locales/de/messages.json'])
     eng_messages = json.loads(files['_locales/en_US/messages.json'])
+
+    # Check for inserted translations, none were present in 'de' beforehand
     for match in re.finditer(r'__MSG_(\S+)__', files['manifest.json']):
         name = match.group(1)
         assert ger_messages[name]['message'] == eng_messages[name]['message']
 
+    # CWS enforces max-lengths on string
     assert len(ger_messages['description']['message']) <= 132

[Vasily Kuznetsov, 2017/08/03 16:52:28]

This is a curious assertion. What exactly are we checking here? Maybe a comment
would be useful?

[tlucas, 2017/08/03 21:26:02]

ChromeWebStore enforces a max-length to be applied on translated strings used in
names / descriptions - but i agree on the comment-comment

[tlucas, 2017/08/04 14:51:58]

Done.

     assert len(ger_messages['name']['message']) <= 12
 
 
-@pytest.mark.parametrize(
-    'metadata_files',
-    [['metadata.chrome', 'metadata.gecko-webext']],
-    indirect=True)
-@pytest.mark.usefixtures('metadata_files', 'files')
-def test_create_build(srcdir, keyfile, tmp_dir):
+@pytest.mark.usefixtures('files', 'gecko_webext_metadata', 'chrome_metadata')
+@pytest.mark.parametrize('release', [True, False])
+@pytest.mark.parametrize('devenv', [True, False])
+@pytest.mark.parametrize('ext_type', ['chrome', 'gecko-webext'])
+@pytest.mark.parametrize('key', [True, False])
+def test_create_build(srcdir, tmpdir, release, devenv, ext_type,
+                      key, keyfile):
 
     basefiles = [
         'manifest.json',
         'lib/foo.js',
         'foo/logo_50.png',
         '_locales/en_US/messages.json',
         '_locales/en-US/test.properties',
         'logo_44.png',
-        'qunit/index.html',
         'icons/logo_150.png',
     ]
 
-    for release, devenv, ext_type, key in product(

[Vasily Kuznetsov, 2017/08/03 16:52:31]

Perhaps it would be better to make this a parametrization as well. Seems a bit
cleaner and we would see individual passes / failures for each parameter
combination in the report, which might be more useful. What do you think?

[tlucas, 2017/08/03 21:26:01]

Totally agreed!

[tlucas, 2017/08/04 14:51:57]

Done.

-            TR_FA, TR_FA, ['chrome', 'gecko-webext'], [None, keyfile]):
-
-        out_file = str(tmp_dir.join('out'))
-
-        packagerChrome.createBuild(
-            outFile=out_file,
-            baseDir=str(srcdir),
-            type=ext_type,
-            releaseBuild=release,
-            keyFile=key,
-            devenv=devenv)
-
-        with zipfile.ZipFile(out_file, 'r') as zipfp:
-            zipfp.testzip()
-
-            filenames = [zipinfo.filename for zipinfo in zipfp.infolist()]
-            for filename in basefiles if not devenv else basefiles + [
-                        'devenvPoller__.js',
-                        'devenvVersion__',
-                    ]:
-                assert filename in filenames
+    out_file = str(tmpdir.join('out'))
+
+    packagerChrome.createBuild(
+        outFile=out_file,
+        baseDir=str(srcdir),
+        type=ext_type,
+        releaseBuild=release,
+        keyFile=keyfile if key else None,
+        devenv=devenv)
+
+    with zipfile.ZipFile(out_file, 'r') as zipfp:
+        zipfp.testzip()
+
+        filenames = [zipinfo.filename for zipinfo in zipfp.infolist()]
+        for filename in basefiles if not devenv else basefiles + [
+                    'devenvPoller__.js',
+                    'devenvVersion__',
+                    'qunit/index.html',
+                ]:
+            assert filename in filenames