def test_is_compat():
"""Test that we know when we're running a compatibility test."""
out = validate(path="tests/resources/junk.xpi", format=None, compat_test=False)
assert not out.get_resource("is_compat_test")
out = validate(path="tests/resources/junk.xpi", format=None, compat_test=True)
assert out.get_resource("is_compat_test")
def test_app_versions_dict():
"""
Test that `approved_applications` can be provided as a pre-parsed dict
of versions.
"""
with open('tests/resources/test_app_versions.json') as f:
apps = json.load(f)
validate(path='tests/resources/junk.xpi', approved_applications=apps)
assert constants.APPROVED_APPLICATIONS['1']['name'] == 'Foo App'
def test_app_versions_dict():
"""
Test that `approved_applications` can be provided as a pre-parsed dict
of versions.
"""
with open('tests/resources/test_app_versions.json') as f:
apps = json.load(f)
validate(path='tests/resources/junk.xpi', approved_applications=apps)
assert constants.APPROVED_APPLICATIONS['1']['name'] == 'Foo App'
def test_is_compat():
"""Test that we know when we're running a compatibility test."""
out = validate(path='tests/resources/junk.xpi', format=None,
compat_test=False)
assert not out.get_resource('is_compat_test')
out = validate(path='tests/resources/junk.xpi', format=None,
compat_test=True)
assert out.get_resource('is_compat_test')
def test_app_versions_dict():
"""
Test that `approved_applications` can be provided as a pre-parsed dict
of versions.
"""
with open("tests/resources/test_app_versions.json") as f:
apps = json.load(f)
validate(path="tests/resources/junk.xpi", approved_applications=apps)
print constants.APPROVED_APPLICATIONS
assert constants.APPROVED_APPLICATIONS["1"]["name"] == "Foo App"
def test_app_versions_dict():
"""
Test that `approved_applications` can be provided as a pre-parsed dict
of versions.
"""
with open("tests/resources/test_app_versions.json") as f:
apps = json.load(f)
validate(path="tests/resources/junk.xpi", approved_applications=apps)
print constants.APPROVED_APPLICATIONS
assert constants.APPROVED_APPLICATIONS["1"]["name"] == "Foo App"
def test_mrkt_urls():
"""
Tests that Marketplace URLs are correctly added to the MRKT_URLS constant.
"""
# Keep a copy so we don't permanently overwrite.
MRKT_URLS = constants.DEFAULT_WEBAPP_MRKT_URLS[:]
validate(path="tests/resources/junk.xpi",
market_urls=["foobar"])
print constants.DEFAULT_WEBAPP_MRKT_URLS
assert "foobar" in constants.DEFAULT_WEBAPP_MRKT_URLS
# Clean up!
constants.DEFAULT_WEBAPP_MRKT_URLS = MRKT_URLS
def test_validate_embedded_webextension_xpi():
"""Integration test for the expected notice message on 'embedded
webextension' add-ons."""
err_bundle = validate(
path='tests/resources/validate/hybrid_extension.xpi', format=None)
assert err_bundle.get_resource('has_embedded_webextension') is True
result = validate(path='tests/resources/validate/hybrid_extension.xpi')
data = json.loads(result)
assert data['success'] is True
assert data['errors'] == 0
assert data['notices'] == 1
assert data['warnings'] == 0
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert len(data['messages']) == 1
assert data['messages'][0]['file'] == u'install.rdf'
assert data['messages'][0]['message'] == (
u'This add-on contains an embedded webextension')
expected_embedded_webext_desc = (
'The embedded webextension is in the folder "webextension"')
expected_embedded_webext_doc_url = (
'https://developer.mozilla.org/en-US/Add-ons/WebExtensions/'
'Embedded_WebExtensions')
messages = data['messages']
assert expected_embedded_webext_desc in messages[0]['description']
assert expected_embedded_webext_doc_url in messages[0]['description']
assert data['message_tree']
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'name_value'
assert data['metadata']['version'] == u'1.2.3.4'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'*****@*****.**'
assert data['metadata'].get('strict_compatibility') is None
assert data['metadata']['is_extension'] is True
def test_validate_embedded_webextension_xpi():
"""Integration test for the expected notice message on 'embedded
webextension' add-ons."""
err_bundle = validate(
path='tests/resources/validate/hybrid_extension.xpi', format=None)
assert err_bundle.get_resource('has_embedded_webextension') is True
result = validate(path='tests/resources/validate/hybrid_extension.xpi')
data = json.loads(result)
assert data['success'] is True
assert data['errors'] == 0
assert data['notices'] == 1
assert data['warnings'] == 0
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert len(data['messages']) == 1
assert data['messages'][0]['file'] == u'install.rdf'
assert data['messages'][0]['message'] == (
u'This add-on contains an embedded webextension')
expected_embedded_webext_desc = (
'The embedded webextension is in the folder "webextension"')
expected_embedded_webext_doc_url = (
'https://developer.mozilla.org/en-US/Add-ons/WebExtensions/'
'Embedded_WebExtensions')
messages = data['messages']
assert expected_embedded_webext_desc in messages[0]['description']
assert expected_embedded_webext_doc_url in messages[0]['description']
assert data['message_tree']
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'name_value'
assert data['metadata']['version'] == u'1.2.3.4'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'*****@*****.**'
assert data['metadata'].get('strict_compatibility') is None
assert data['metadata']['is_extension'] is True
def _test_validate_jpm_multiprocess_compatible(compat_test):
"""Integration test for a multiprocess compatible jpm-style extension xpi,
without mocks."""
result = validate(path='tests/resources/validate/jpm_multiprocess.xpi',
compat_test=compat_test)
data = json.loads(result)
assert data['success'] is True
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 0
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert data['messages'] == []
assert data['message_tree'] == {}
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'My Jetpack Addon'
assert data['metadata']['version'] == u'0.0.3'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'@test-addon'
assert data['metadata'].get('strict_compatibility') is None
assert data['metadata']['is_extension'] is True
def test_validate_old_xpi_thunderbird_only():
"""Integration test for a thunderbird-only old-style extension xpi
without mocks."""
result = validate(
path='tests/resources/validate/thunderbird_extension.xpi')
data = json.loads(result)
assert data['success'] is True
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 0
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert data['messages'] == []
assert data['message_tree'] == {}
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'name_value'
assert data['metadata']['version'] == u'1.2.3.4'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'*****@*****.**'
assert data['metadata'].get('strict_compatibility') is None
assert data['metadata']['is_extension'] is True
def _test_validate_jpm(compat_test):
"""Integration test for a basic jpm-style extension xpi, without mocks."""
result = validate(path='tests/resources/validate/jpm.xpi',
compat_test=compat_test)
data = json.loads(result)
assert data['success'] is False
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 1
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert len(data['messages']) == 1
assert data['messages'][0]['id'] == [
u'submain', u'test_inner_package', u'not_multiprocess_compatible']
assert data['message_tree']
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'My Jetpack Addon'
assert data['metadata']['version'] == u'0.0.3'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'@test-addon'
assert data['metadata'].get('strict_compatibility') is None
assert data['metadata']['is_extension'] is True
def _test_validate_jpm_multiprocess_compatible(compat_test):
"""Integration test for a multiprocess compatible jpm-style extension xpi,
without mocks."""
result = validate(path='tests/resources/validate/jpm_multiprocess.xpi', compat_test=compat_test)
data = json.loads(result)
assert data['success'] is True
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 0
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert data['messages'] == []
assert data['message_tree'] == {}
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'My Jetpack Addon'
assert data['metadata']['version'] == u'0.0.3'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'@test-addon'
def _test_validate_old_xpi_multiprocess_compatible(compat_test):
"""Integration test for a multiprocess compatible old-style extension xpi,
without mocks."""
result = validate(
path='tests/resources/validate/extension_multiprocess.xpi', compat_test=compat_test)
data = json.loads(result)
assert data['success'] is True
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 0
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert data['messages'] == []
assert data['message_tree'] == {}
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'name_value'
assert data['metadata']['version'] == u'1.2.3.4'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'*****@*****.**'
def test_validate_old_xpi_with_jar_in_it():
"""Integration test for a basic old-style extension xpi that contains a
.jar file, without mocks."""
result = validate(path='tests/resources/validate/extension_with_jar.xpi')
data = json.loads(result)
assert data['success'] is False
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 1
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert len(data['messages']) == 1
assert data['messages'][0]['id'] == [
u'submain', u'test_inner_package', u'not_multiprocess_compatible']
assert data['message_tree']
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'xpi name'
assert data['metadata']['version'] == u'0.2'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'guid@xpi'
def test_validate_dictionnary_no_multiprocess_compatible_warning():
"""Integration test for a dictionnary xpi, without mocks."""
result = validate(path='tests/resources/validate/dictionary.xpi')
data = json.loads(result)
assert data['success'] is True
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 0
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'dictionary'
assert data['messages'] == []
assert data['message_tree'] == {}
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'My Fake Dictionary'
assert data['metadata']['version'] == u'1.0.0'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'my@dict'
assert data['metadata'].get('strict_compatibility') is None
assert data['metadata']['is_extension'] is False
def test_validate_jpm():
"""Integration test for a basic jpm-style extension xpi, without mocks."""
result = validate(path='tests/resources/validate/jpm.xpi')
data = json.loads(result)
assert data['success'] is False
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 1
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert len(data['messages']) == 1
assert data['messages'][0]['id'] == [
u'submain', u'test_inner_package', u'not_multiprocess_compatible'
]
assert data['message_tree']
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'My Jetpack Addon'
assert data['metadata']['version'] == u'0.0.3'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'@test-addon'
def test_validate_old_xpi_thunderbird_only():
"""Integration test for a thunderbird-only old-style extension xpi
without mocks."""
result = validate(
path='tests/resources/validate/thunderbird_extension.xpi')
data = json.loads(result)
assert data['success'] is True
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 0
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert data['messages'] == []
assert data['message_tree'] == {}
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'name_value'
assert data['metadata']['version'] == u'1.2.3.4'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'*****@*****.**'
def test_validate_old_xpi():
"""Integration test for a basic old-style extension xpi, without mocks."""
result = validate(path='tests/resources/validate/extension.xpi')
data = json.loads(result)
assert data['success'] is False
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 1
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert len(data['messages']) == 1
assert data['messages'][0]['id'] == [
u'submain', u'test_inner_package', u'not_multiprocess_compatible'
]
assert data['message_tree']
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'name_value'
assert data['metadata']['version'] == u'1.2.3.4'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'*****@*****.**'
def test_validate_webextension():
"""Integration test for a basic webextension, without mocks.
We're not supposed to use amo-validator for webextensions anymore now that
we have addons-linter, but let's make sure that we don't completely
blow up anyway."""
result = validate(path='tests/resources/validate/webextension.xpi')
data = json.loads(result)
assert data['success'] is True
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 0
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert data['messages'] == []
assert data['message_tree'] == {}
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata'].get('strict_compatibility') is None
assert data['metadata']['is_extension'] is True
def test_validate_old_xpi_with_jar_in_it():
"""Integration test for a basic old-style extension xpi that contains a
.jar file, without mocks."""
result = validate(path='tests/resources/validate/extension_with_jar.xpi')
data = json.loads(result)
assert data['success'] is False
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 1
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert len(data['messages']) == 1
assert data['messages'][0]['id'] == [
u'submain', u'test_inner_package', u'not_multiprocess_compatible']
assert data['message_tree']
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'xpi name'
assert data['metadata']['version'] == u'0.2'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'guid@xpi'
assert data['metadata'].get('strict_compatibility') is None
assert data['metadata']['is_extension'] is True
def _test_validate_old_xpi_multiprocess_compatible(compat_test):
"""Integration test for a multiprocess compatible old-style extension xpi,
without mocks."""
result = validate(
path='tests/resources/validate/extension_multiprocess.xpi',
compat_test=compat_test)
data = json.loads(result)
assert data['success'] is True
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 0
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert data['messages'] == []
assert data['message_tree'] == {}
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'name_value'
assert data['metadata']['version'] == u'1.2.3.4'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'*****@*****.**'
assert data['metadata'].get('strict_compatibility') is None
assert data['metadata']['is_extension'] is True
def _validator(file_path):
# TODO(Kumar) This is currently copied from Zamboni because
# it's really hard to import from zamboni outside of itself.
# TODO(Kumar) remove this when validator is fixed, see bug 620503
from validator.testcases import scripting
import validator.constants
js = os.environ.get('SPIDERMONKEY_INSTALLATION', 'js')
scripting.SPIDERMONKEY_INSTALLATION = js
validator.constants.SPIDERMONKEY_INSTALLATION = js
apps = os.path.join(os.path.dirname(__file__), 'apps.json')
orig = sys.stderr
sys.stderr = StringIO()
try:
result = validate(file_path, format='json',
# Test all tiers at once. This will make sure we see
# all error messages.
determined=True,
approved_applications=apps,
spidermonkey=js)
sys.stdout.write(sys.stderr.getvalue())
if 'Traceback' in sys.stderr.getvalue():
# the validator catches and ignores certain errors in an attempt
# to remain versatile. There should not be any exceptions
# while testing.
raise RuntimeError(
"An exception was raised during validation. Check stderr")
finally:
sys.stderr = orig
return result
def test_validate_webextension():
"""Integration test for a basic webextension, without mocks.
We're not supposed to use amo-validator for webextensions anymore now that
we have addons-linter, but let's make sure that we don't completely
blow up anyway."""
result = validate(path='tests/resources/validate/webextension.xpi')
data = json.loads(result)
assert data['success'] is False
assert data['errors'] == 1
assert data['notices'] == 0
assert data['warnings'] == 0
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert len(data['messages']) == 1
assert data['messages'][0]['id'] == [
u'submain', u'test_inner_package', u'webextension']
assert data['messages'][0]['message'] == (
'This tool only works with legacy add-ons. See '
'https://developer.mozilla.org/docs/Mozilla/Add-ons/WebExtensions '
'for more information about WebExtension APIs.')
assert data['messages'][0]['tier'] == 1
assert data['messages'][0]['type'] == 'error'
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['is_extension'] is True
def _validator(file_path, for_appversions=None, overrides=None):
from validator.testcases import scripting
import validator
import validator.constants
js = os.environ.get('SPIDERMONKEY_INSTALLATION', 'js')
scripting.SPIDERMONKEY_INSTALLATION = js
validator.constants.SPIDERMONKEY_INSTALLATION = js
apps = os.path.join(os.path.dirname(validator.__file__),
'app_versions.json')
if not os.path.exists(apps):
raise EnvironmentError('Could not locate app_versions.json in git '
'repo for validator. Tried: %s' % apps)
orig = sys.stderr
sys.stderr = StringIO()
try:
result = validate(file_path, format='json',
# Test all tiers at once. This will make sure we see
# all error messages.
determined=True,
approved_applications=apps,
spidermonkey=js,
for_appversions=for_appversions,
timeout=60 * 3, # seconds
overrides=overrides)
sys.stdout.write(sys.stderr.getvalue())
if 'Traceback' in sys.stderr.getvalue():
# the validator catches and ignores certain errors in an attempt
# to remain versatile. There should not be any exceptions
# while testing.
raise RuntimeError(
"An exception was raised during validation. Check stderr")
finally:
sys.stderr = orig
return result
def validate_and_submit(addon, file_, channel, use_autograph=False):
return validate(file_,
listed=(channel == amo.RELEASE_CHANNEL_LISTED),
subtask=submit_file.si(addon.pk,
file_.pk,
channel,
use_autograph=use_autograph))
def test_validate_dictionnary_no_multiprocess_compatible_warning():
"""Integration test for a dictionnary xpi, without mocks."""
result = validate(path='tests/resources/validate/dictionary.xpi')
data = json.loads(result)
assert data['success'] is True
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 0
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'dictionary'
assert data['messages'] == []
assert data['message_tree'] == {}
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'My Fake Dictionary'
assert data['metadata']['version'] == u'1.0.0'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'my@dict'
assert data['metadata'].get('strict_compatibility') is None
assert data['metadata']['is_extension'] is False
def _validator(file_path, for_appversions=None, overrides=None):
from validator.testcases import scripting
import validator
import validator.constants
js = os.environ.get('SPIDERMONKEY_INSTALLATION', 'js')
apps = os.path.join(os.path.dirname(validator.__file__),
'app_versions.json')
if not os.path.exists(apps):
raise EnvironmentError('Could not locate app_versions.json in git '
'repo for validator. Tried: %s' % apps)
orig = sys.stderr
sys.stderr = StringIO()
try:
result = validate(
file_path,
format='json',
# Test all tiers at once. This will make
# sure we see all error messages.
determined=True,
approved_applications=apps,
spidermonkey=js,
for_appversions=for_appversions,
timeout=60 * 3, # seconds
overrides=overrides)
sys.stdout.write(sys.stderr.getvalue())
if 'Traceback' in sys.stderr.getvalue():
# the validator catches and ignores certain errors in an attempt
# to remain versatile. There should not be any exceptions
# while testing.
raise RuntimeError(
"An exception was raised during validation. Check stderr")
finally:
sys.stderr = orig
return result
def run_validator(file_path, for_appversions=None, test_all_tiers=False, overrides=None):
"""A pre-configured wrapper around the addon validator.
*file_path*
Path to addon / extension file to validate.
*for_appversions=None*
An optional dict of application versions to validate this addon
for. The key is an application GUID and its value is a list of
versions.
*test_all_tiers=False*
When False (default) the validator will not continue if it
encounters fatal errors. When True, all tests in all tiers are run.
See bug 615426 for discussion on this default.
*overrides=None*
Normally the validator gets info from install.rdf but there are a
few things we need to override. See validator for supported overrides.
Example: {'targetapp_maxVersion': {'<app guid>': '<version>'}}
To validate the addon for compatibility with Firefox 5 and 6,
you'd pass in::
for_appversions={amo.FIREFOX.guid: ['5.0.*', '6.0.*']}
Not all application versions will have a set of registered
compatibility tests.
"""
from validator.validate import validate
# TODO(Kumar) remove this when validator is fixed, see bug 620503
from validator.testcases import scripting
scripting.SPIDERMONKEY_INSTALLATION = settings.SPIDERMONKEY
import validator.constants
validator.constants.SPIDERMONKEY_INSTALLATION = settings.SPIDERMONKEY
apps = dump_apps.Command.JSON_PATH
if not os.path.exists(apps):
call_command("dump_apps")
with statsd.timer("devhub.validator"):
return validate(
file_path,
for_appversions=for_appversions,
format="json",
# When False, this flag says to stop testing after one
# tier fails.
determined=test_all_tiers,
approved_applications=apps,
spidermonkey=settings.SPIDERMONKEY,
overrides=overrides,
timeout=settings.VALIDATOR_TIMEOUT,
)
def run_validator(file_path,
for_appversions=None,
test_all_tiers=False,
overrides=None):
"""A pre-configured wrapper around the addon validator.
*file_path*
Path to addon / extension file to validate.
*for_appversions=None*
An optional dict of application versions to validate this addon
for. The key is an application GUID and its value is a list of
versions.
*test_all_tiers=False*
When False (default) the validator will not continue if it
encounters fatal errors. When True, all tests in all tiers are run.
See bug 615426 for discussion on this default.
*overrides=None*
Normally the validator gets info from install.rdf but there are a
few things we need to override. See validator for supported overrides.
Example: {'targetapp_maxVersion': {'<app guid>': '<version>'}}
To validate the addon for compatibility with Firefox 5 and 6,
you'd pass in::
for_appversions={amo.FIREFOX.guid: ['5.0.*', '6.0.*']}
Not all application versions will have a set of registered
compatibility tests.
"""
from validator.validate import validate
# TODO(Kumar) remove this when validator is fixed, see bug 620503
from validator.testcases import scripting
scripting.SPIDERMONKEY_INSTALLATION = settings.SPIDERMONKEY
import validator.constants
validator.constants.SPIDERMONKEY_INSTALLATION = settings.SPIDERMONKEY
apps = dump_apps.Command.JSON_PATH
if not os.path.exists(apps):
call_command('dump_apps')
with statsd.timer('devhub.validator'):
return validate(
file_path,
for_appversions=for_appversions,
format='json',
# When False, this flag says to stop testing after one
# tier fails.
determined=test_all_tiers,
approved_applications=apps,
spidermonkey=settings.SPIDERMONKEY,
overrides=overrides,
timeout=settings.VALIDATOR_TIMEOUT)
def test_validate():
output = validate(path="tests/resources/packagelayout/theme.jar")
j = json.loads(output)
print j
assert j["metadata"]["name"] == "name_value"
output = validate(path="tests/resources/packagelayout/theme.jar",
format=None)
assert isinstance(output, ErrorBundle)
assert output.metadata["name"] == "name_value"
assert output.get_resource("SPIDERMONKEY") == False
output = validate(path="tests/resources/packagelayout/theme.jar",
spidermonkey="foospidermonkey",
format=None)
assert output.get_resource("SPIDERMONKEY") == "foospidermonkey"
assert output.determined
assert output.get_resource("listed")
output = validate(path="tests/resources/packagelayout/theme.jar",
determined=False,
format=None)
assert not output.determined
assert output.get_resource("listed")
output = validate(path="tests/resources/packagelayout/theme.jar",
listed=False,
format=None)
assert output.determined
assert not output.get_resource("listed")
output = validate(path="tests/resources/packagelayout/theme.jar",
overrides="foo",
format=None)
assert output.overrides == "foo"
def _validator(file_path):
from validator.validate import validate
# TODO(Kumar) remove this when validator is fixed, see bug 620503
from validator.testcases import scripting
scripting.SPIDERMONKEY_INSTALLATION = settings.SPIDERMONKEY
import validator.constants
validator.constants.SPIDERMONKEY_INSTALLATION = settings.SPIDERMONKEY
apps = dump_apps.Command.JSON_PATH
if not os.path.exists(apps):
call_command('dump_apps')
return validate(file_path, format='json',
# This flag says to stop testing after one tier fails.
# bug 615426
determined=False,
approved_applications=apps,
spidermonkey=settings.SPIDERMONKEY)
def _validator(file_path, compatibility=None):
# TODO(Kumar) This is currently copied from Zamboni because
# it's really hard to import from zamboni outside of itself.
# TODO(Kumar) remove this when validator is fixed, see bug 620503
from validator.testcases import scripting
import validator
import validator.constants
js = os.environ.get('SPIDERMONKEY_INSTALLATION', 'js')
scripting.SPIDERMONKEY_INSTALLATION = js
validator.constants.SPIDERMONKEY_INSTALLATION = js
apps = os.path.join(os.path.dirname(validator.__file__),
'app_versions.json')
if not os.path.exists(apps):
raise EnvironmentError('Could not locate app_versions.json in git '
'repo for validator. Tried: %s' % apps)
orig = sys.stderr
sys.stderr = StringIO()
try:
result = validate(file_path, format='json',
# Test all tiers at once. This will make sure we see
# all error messages.
determined=True,
approved_applications=apps,
spidermonkey=js,
# Commented out because we want to let the tests
# choose whether to run or not. This step is
# unnecessary.
#for_appversions=compatibility,
overrides={"targetapp_maxVersion": compatibility or {}})
sys.stdout.write(sys.stderr.getvalue())
if 'Traceback' in sys.stderr.getvalue():
# the validator catches and ignores certain errors in an attempt
# to remain versatile. There should not be any exceptions
# while testing.
raise RuntimeError(
"An exception was raised during validation. Check stderr")
finally:
sys.stderr = orig
return result
def _validator(file_path, for_appversions=None, overrides=None):
# TODO(Kumar) This is currently copied from Zamboni because
# it's really hard to import from zamboni outside of itself.
# TODO(Kumar) remove this when validator is fixed, see bug 620503
from validator.testcases import scripting
import validator
import validator.constants
js = os.environ.get("SPIDERMONKEY_INSTALLATION", "js")
scripting.SPIDERMONKEY_INSTALLATION = js
validator.constants.SPIDERMONKEY_INSTALLATION = js
apps = os.path.join(os.path.dirname(validator.__file__), "app_versions.json")
if not os.path.exists(apps):
raise EnvironmentError("Could not locate app_versions.json in git " "repo for validator. Tried: %s" % apps)
orig = sys.stderr
sys.stderr = StringIO()
try:
result = validate(
file_path,
format="json",
# Test all tiers at once. This will make sure we see
# all error messages.
determined=True,
approved_applications=apps,
spidermonkey=js,
for_appversions=for_appversions,
timeout=60 * 3, # seconds
overrides=overrides,
)
sys.stdout.write(sys.stderr.getvalue())
if "Traceback" in sys.stderr.getvalue():
# the validator catches and ignores certain errors in an attempt
# to remain versatile. There should not be any exceptions
# while testing.
raise RuntimeError("An exception was raised during validation. Check stderr")
finally:
sys.stderr = orig
return result
def _test_validate_old_xpi(compat_test):
"""Integration test for a basic old-style extension xpi, without mocks."""
result = validate(path='tests/resources/validate/extension.xpi',
compat_test=compat_test)
data = json.loads(result)
assert data['success'] is False
assert data['errors'] == 0
assert data['notices'] == 0
assert data['warnings'] == 1
assert data['compatibility_summary']
assert data['compatibility_summary']['errors'] == 0
assert data['compatibility_summary']['notices'] == 0
assert data['compatibility_summary']['warnings'] == 0
assert data['detected_type'] == 'extension'
assert len(data['messages']) == 1
assert data['messages'][0]['id'] == [
u'submain', u'test_inner_package', u'not_multiprocess_compatible']
assert data['message_tree']
assert data['signing_summary']['high'] == 0
assert data['signing_summary']['medium'] == 0
assert data['signing_summary']['low'] == 0
assert data['signing_summary']['trivial'] == 0
assert data['metadata']
assert data['metadata']['name'] == u'name_value'
assert data['metadata']['version'] == u'1.2.3.4'
assert data['metadata']['listed'] is True
assert data['metadata']['id'] == u'*****@*****.**'
assert data['metadata']['strict_compatibility'] is True
assert data['metadata']['applications']
assert data['metadata']['applications']['firefox'] == {
'min': '3.6', 'max': '3.6.*'
}
assert data['metadata']['applications']['mozilla'] == {
'min': '1.0', 'max': '1.8+'
}
assert data['metadata']['is_extension'] is True
import sys from validator.validate import validate print validate(sys.argv[1], format="json")
def test_app_versions():
"Tests that the validate function properly loads app_versions.json"
validate(path="tests/resources/junk.xpi",
approved_applications="tests/resources/test_app_versions.json")
print constants.APPROVED_APPLICATIONS
assert constants.APPROVED_APPLICATIONS["1"]["name"] == "Foo App"
def run(self, path, **kwargs):
self.output = validate(path=path, **kwargs)
def test_validate_language_pack():
result = validate(path='tests/resources/validate/langpack.xpi')
data = json.loads(result)
assert data['metadata']['is_extension'] is False
def validate_and_submit(addon, file_, listed=None,
disallow_preliminary_review=False):
return validate(
file_, listed=listed, subtask=submit_file.si(
addon.pk, file_.pk,
disallow_preliminary_review=disallow_preliminary_review))
def test_app_versions():
"Tests that the validate function properly loads app_versions.json"
validate(path="tests/resources/junk.xpi",
approved_applications="tests/resources/test_app_versions.json")
print constants.APPROVED_APPLICATIONS
assert constants.APPROVED_APPLICATIONS["1"]["name"] == "Foo App"
def test_app_versions():
'Tests that the validate function properly loads app_versions.json'
validate(path='tests/resources/junk.xpi',
approved_applications='tests/resources/test_app_versions.json')
assert constants.APPROVED_APPLICATIONS['1']['name'] == 'Foo App'
def test_validate_search():
result = validate(path='tests/resources/validate/search.xml')
data = json.loads(result)
assert data['metadata']['is_extension'] is False
def run_validator(path, for_appversions=None, test_all_tiers=False,
overrides=None, compat=False, listed=True):
"""A pre-configured wrapper around the addon validator.
*file_path*
Path to addon / extension file to validate.
*for_appversions=None*
An optional dict of application versions to validate this addon
for. The key is an application GUID and its value is a list of
versions.
*test_all_tiers=False*
When False (default) the validator will not continue if it
encounters fatal errors. When True, all tests in all tiers are run.
See bug 615426 for discussion on this default.
*overrides=None*
Normally the validator gets info from install.rdf but there are a
few things we need to override. See validator for supported overrides.
Example: {'targetapp_maxVersion': {'<app guid>': '<version>'}}
*compat=False*
Set this to `True` when performing a bulk validation. This allows the
validator to ignore certain tests that should not be run during bulk
validation (see bug 735841).
*listed=True*
If the addon is unlisted, treat it as if it was a self hosted one
(don't fail on the presence of an updateURL).
To validate the addon for compatibility with Firefox 5 and 6,
you'd pass in::
for_appversions={amo.FIREFOX.guid: ['5.0.*', '6.0.*']}
Not all application versions will have a set of registered
compatibility tests.
"""
if not settings.VALIDATE_ADDONS:
# This should only ever be set on development instances.
# Don't run the validator, just return a skeleton passing result set.
results = deepcopy(amo.VALIDATOR_SKELETON_RESULTS)
results['metadata']['listed'] = listed
return json.dumps(results)
from validator.validate import validate
apps = dump_apps.Command.JSON_PATH
if not os.path.exists(apps):
call_command('dump_apps')
with NamedTemporaryFile(suffix='_' + os.path.basename(path)) as temp:
if path and not os.path.exists(path) and storage.exists(path):
# This file doesn't exist locally. Write it to our
# currently-open temp file and switch to that path.
copyfileobj(storage.open(path), temp.file)
path = temp.name
with statsd.timer('devhub.validator'):
json_result = validate(
path,
for_appversions=for_appversions,
format='json',
# When False, this flag says to stop testing after one
# tier fails.
determined=test_all_tiers,
approved_applications=apps,
spidermonkey=settings.SPIDERMONKEY,
overrides=overrides,
compat_test=compat,
listed=listed
)
track_validation_stats(json_result)
return json_result
def test_webapp():
"""Test that webapps can be validated traditionally."""
out = validate(path="tests/resources/testwebapp.webapp",
expectation=PACKAGE_WEBAPP)
j = json.loads(out)
assert j["success"], "Expected not to fail"
def run_validator(path,
for_appversions=None,
test_all_tiers=False,
overrides=None,
compat=False,
listed=True):
"""A pre-configured wrapper around the addon validator.
*file_path*
Path to addon / extension file to validate.
*for_appversions=None*
An optional dict of application versions to validate this addon
for. The key is an application GUID and its value is a list of
versions.
*test_all_tiers=False*
When False (default) the validator will not continue if it
encounters fatal errors. When True, all tests in all tiers are run.
See bug 615426 for discussion on this default.
*overrides=None*
Normally the validator gets info from the manifest but there are a
few things we need to override. See validator for supported overrides.
Example: {'targetapp_maxVersion': {'<app guid>': '<version>'}}
*compat=False*
Set this to `True` when performing a bulk validation. This allows the
validator to ignore certain tests that should not be run during bulk
validation (see bug 735841).
*listed=True*
If the addon is unlisted, treat it as if it was a self hosted one
(don't fail on the presence of an updateURL).
To validate the addon for compatibility with Firefox 5 and 6,
you'd pass in::
for_appversions={amo.FIREFOX.guid: ['5.0.*', '6.0.*']}
Not all application versions will have a set of registered
compatibility tests.
"""
from validator.validate import validate
apps = dump_apps.Command.get_json_path()
if not os.path.exists(apps):
call_command('dump_apps')
suffix = '_' + os.path.basename(path)
with NamedTemporaryFile(suffix=suffix, dir=settings.TMP_PATH) as temp:
if path and not os.path.exists(path) and storage.exists(path):
# This file doesn't exist locally. Write it to our
# currently-open temp file and switch to that path.
shutil.copyfileobj(storage.open(path), temp.file)
path = temp.name
with statsd.timer('devhub.validator'):
json_result = validate(
path,
for_appversions=for_appversions,
format='json',
# When False, this flag says to stop testing after one
# tier fails.
determined=test_all_tiers,
approved_applications=apps,
overrides=overrides,
compat_test=compat,
listed=listed)
track_validation_stats(json_result)
return json_result
def validate_and_submit(addon, file_, listed=None):
return validate(file_, listed=listed,
subtask=submit_file.si(addon.pk, file_.pk))
def validate_and_submit(addon, file_, listed):
channel = (amo.RELEASE_CHANNEL_LISTED if listed else
amo.RELEASE_CHANNEL_UNLISTED)
return validate(
file_, listed=listed,
subtask=submit_file.si(addon.pk, file_.pk, channel))
def main():
"Main function. Handles delegation to other functions."
expectations = {"any": PACKAGE_ANY,
"extension": PACKAGE_EXTENSION,
"theme": PACKAGE_THEME,
"dictionary": PACKAGE_DICTIONARY,
"languagepack": PACKAGE_LANGPACK,
"search": PACKAGE_SEARCHPROV,
"multi": PACKAGE_MULTI}
# Parse the arguments that
parser = argparse.ArgumentParser(
description="Run tests on a Mozilla-type addon.")
parser.add_argument("package",
help="The path of the package you're testing")
parser.add_argument("-t",
"--type",
default="any",
choices=expectations.keys(),
help="Type of addon you assume you're testing",
required=False)
parser.add_argument("-o",
"--output",
default="text",
choices=("text", "json"),
help="The output format that you expect",
required=False)
parser.add_argument("-v",
"--verbose",
action="store_const",
const=True,
help="""If the output format supports it, makes
the analysis summary include extra info.""")
parser.add_argument("--boring",
action="store_const",
const=True,
help="""Activating this flag will remove color
support from the terminal.""")
parser.add_argument("--determined",
action="store_const",
const=True,
help="""This flag will continue running tests in
successive tests even if a lower tier fails.""")
parser.add_argument("--selfhosted",
action="store_const",
const=True,
help="""Indicates that the addon will not be
hosted on addons.mozilla.org. This allows the
<em:updateURL> element to be set.""")
parser.add_argument("--approved_applications",
default="validator/app_versions.json",
help="""A JSON file containing acceptable applications
and their versions""")
parser.add_argument("--target-maxversion",
help="""JSON string to override the package's
targetapp_maxVersion for validation. The JSON object
should be a dict of versions keyed by application
GUID. For example, setting a package's max Firefox
version to 5.*:
{"{ec8030f7-c20a-464f-9b0e-13a3a9e97384}": "5.*"}
""")
parser.add_argument("--target-minversion",
help="""JSON string to override the package's
targetapp_minVersion for validation. The JSON object
should be a dict of versions keyed by application
GUID. For example, setting a package's min Firefox
version to 5.*:
{"{ec8030f7-c20a-464f-9b0e-13a3a9e97384}": "5.*"}
""")
parser.add_argument("--for-appversions",
help="""JSON string to run validation tests for
compatibility with a specific app/version. The JSON
object should be a dict of version lists keyed by
application GUID. For example, running Firefox 6.*
compatibility tests:
{"{ec8030f7-c20a-464f-9b0e-13a3a9e97384}": ["6.*"]}
""")
args = parser.parse_args()
# We want to make sure that the output is expected. Parse out the expected
# type for the add-on and pass it in for validation.
if args.type not in expectations:
# Fail if the user provided invalid input.
print "Given expectation (%s) not valid. See --help for details" % \
args.type
sys.exit(1)
overrides = {}
if args.target_minversion:
overrides['targetapp_minVersion'] = json.loads(args.target_minversion)
if args.target_maxversion:
overrides['targetapp_maxVersion'] = json.loads(args.target_maxversion)
for_appversions = None
if args.for_appversions:
for_appversions = json.loads(args.for_appversions)
expectation = expectations[args.type]
error_bundle = validate(args.package,
format=None,
approved_applications=args.approved_applications,
determined=args.determined,
listed=not args.selfhosted,
overrides=overrides,
for_appversions=for_appversions)
# Print the output of the tests based on the requested format.
if args.output == "text":
print error_bundle.print_summary(verbose=args.verbose,
no_color=args.boring).encode("utf-8")
elif args.output == "json":
sys.stdout.write(error_bundle.render_json())
if error_bundle.failed():
sys.exit(1)
else:
sys.exit(0)
def run(self, path, **kwargs):
self.output = validate(path=path, **kwargs)
def main():
'Main function. Handles delegation to other functions.'
logging.basicConfig()
type_choices = {
'any': constants.PACKAGE_ANY,
'extension': constants.PACKAGE_EXTENSION,
'theme': constants.PACKAGE_THEME,
'dictionary': constants.PACKAGE_DICTIONARY,
'languagepack': constants.PACKAGE_LANGPACK,
'search': constants.PACKAGE_SEARCHPROV,
'multi': constants.PACKAGE_MULTI
}
# Parse the arguments that
parser = argparse.ArgumentParser(
description='Run tests on a Mozilla-type addon.')
parser.add_argument('package',
help="The path of the package you're testing")
parser.add_argument('-t',
'--type',
default='any',
choices=type_choices.keys(),
help="Type of addon you assume you're testing",
required=False)
parser.add_argument('-o',
'--output',
default='text',
choices=('text', 'json'),
help='The output format that you expect',
required=False)
parser.add_argument('-v',
'--verbose',
action='store_const',
const=True,
help="""If the output format supports it, makes
the analysis summary include extra info.""")
parser.add_argument('--boring',
action='store_const',
const=True,
help="""Activating this flag will remove color
support from the terminal.""")
parser.add_argument('--determined',
action='store_const',
const=True,
help="""This flag will continue running tests in
successive tests even if a lower tier fails.""")
parser.add_argument('--selfhosted',
action='store_const',
const=True,
help="""Indicates that the addon will not be
hosted on addons.mozilla.org. This allows the
<em:updateURL> element to be set.""")
parser.add_argument('--approved_applications',
help="""A JSON file containing acceptable applications
and their versions""",
required=False)
parser.add_argument('--target-maxversion',
help="""JSON string to override the package's
targetapp_maxVersion for validation. The JSON object
should be a dict of versions keyed by application
GUID. For example, setting a package's max Firefox
version to 5.*:
{"{ec8030f7-c20a-464f-9b0e-13a3a9e97384}": "5.*"}
""")
parser.add_argument('--target-minversion',
help="""JSON string to override the package's
targetapp_minVersion for validation. The JSON object
should be a dict of versions keyed by application
GUID. For example, setting a package's min Firefox
version to 5.*:
{"{ec8030f7-c20a-464f-9b0e-13a3a9e97384}": "5.*"}
""")
parser.add_argument('--for-appversions',
help="""JSON string to run validation tests for
compatibility with a specific app/version. The JSON
object should be a dict of version lists keyed by
application GUID. For example, running Firefox 6.*
compatibility tests:
{"{ec8030f7-c20a-464f-9b0e-13a3a9e97384}": ["6.*"]}
""")
parser.add_argument('--timeout',
help='The amount of time before validation is '
'terminated with a timeout exception.',
default='60')
args = parser.parse_args()
# We want to make sure that the output is expected. Parse out the expected
# type for the add-on and pass it in for validation.
if args.type not in type_choices:
# Fail if the user provided invalid input.
print 'Given expectation (%s) not valid. See --help for details' % \
args.type
sys.exit(1)
overrides = {}
if args.target_minversion:
overrides['targetapp_minVersion'] = json.loads(args.target_minversion)
if args.target_maxversion:
overrides['targetapp_maxVersion'] = json.loads(args.target_maxversion)
for_appversions = None
if args.for_appversions:
for_appversions = json.loads(args.for_appversions)
try:
timeout = int(args.timeout)
except ValueError:
print 'Invalid timeout. Integer expected.'
sys.exit(1)
expectation = type_choices[args.type]
error_bundle = validate(args.package,
format=None,
approved_applications=args.approved_applications,
determined=args.determined,
listed=not args.selfhosted,
overrides=overrides,
for_appversions=for_appversions,
expectation=expectation,
timeout=timeout)
# Print the output of the tests based on the requested format.
if args.output == 'text':
print error_bundle.print_summary(verbose=args.verbose,
no_color=args.boring).encode('utf-8')
elif args.output == 'json':
sys.stdout.write(error_bundle.render_json())
if error_bundle.failed():
sys.exit(1)
else:
sys.exit(0)
def main():
'Main function. Handles delegation to other functions.'
logging.basicConfig()
type_choices = {'any': constants.PACKAGE_ANY,
'extension': constants.PACKAGE_EXTENSION,
'theme': constants.PACKAGE_THEME,
'dictionary': constants.PACKAGE_DICTIONARY,
'languagepack': constants.PACKAGE_LANGPACK,
'search': constants.PACKAGE_SEARCHPROV,
'multi': constants.PACKAGE_MULTI}
# Parse the arguments that
parser = argparse.ArgumentParser(
description='Run tests on a Mozilla-type addon.')
parser.add_argument('package',
help="The path of the package you're testing")
parser.add_argument('-t',
'--type',
default='any',
choices=type_choices.keys(),
help="Type of addon you assume you're testing",
required=False)
parser.add_argument('-o',
'--output',
default='text',
choices=('text', 'json'),
help='The output format that you expect',
required=False)
parser.add_argument('-v',
'--verbose',
action='store_const',
const=True,
help="""If the output format supports it, makes
the analysis summary include extra info.""")
parser.add_argument('--boring',
action='store_const',
const=True,
help="""Activating this flag will remove color
support from the terminal.""")
parser.add_argument('--determined',
action='store_const',
const=True,
help="""This flag will continue running tests in
successive tests even if a lower tier fails.""")
parser.add_argument('--selfhosted',
action='store_const',
const=True,
help="""Indicates that the addon will not be
hosted on addons.mozilla.org. This allows the
<em:updateURL> element to be set.""")
parser.add_argument('--approved_applications',
help="""A JSON file containing acceptable applications
and their versions""",
required=False)
parser.add_argument('--target-maxversion',
help="""JSON string to override the package's
targetapp_maxVersion for validation. The JSON object
should be a dict of versions keyed by application
GUID. For example, setting a package's max Firefox
version to 5.*:
{"{ec8030f7-c20a-464f-9b0e-13a3a9e97384}": "5.*"}
""")
parser.add_argument('--target-minversion',
help="""JSON string to override the package's
targetapp_minVersion for validation. The JSON object
should be a dict of versions keyed by application
GUID. For example, setting a package's min Firefox
version to 5.*:
{"{ec8030f7-c20a-464f-9b0e-13a3a9e97384}": "5.*"}
""")
parser.add_argument('--for-appversions',
help="""JSON string to run validation tests for
compatibility with a specific app/version. The JSON
object should be a dict of version lists keyed by
application GUID. For example, running Firefox 6.*
compatibility tests:
{"{ec8030f7-c20a-464f-9b0e-13a3a9e97384}": ["6.*"]}
""")
parser.add_argument('--timeout',
help='The amount of time before validation is '
'terminated with a timeout exception.',
default='60')
args = parser.parse_args()
# We want to make sure that the output is expected. Parse out the expected
# type for the add-on and pass it in for validation.
if args.type not in type_choices:
# Fail if the user provided invalid input.
print 'Given expectation (%s) not valid. See --help for details' % \
args.type
sys.exit(1)
overrides = {}
if args.target_minversion:
overrides['targetapp_minVersion'] = json.loads(args.target_minversion)
if args.target_maxversion:
overrides['targetapp_maxVersion'] = json.loads(args.target_maxversion)
for_appversions = None
if args.for_appversions:
for_appversions = json.loads(args.for_appversions)
try:
timeout = int(args.timeout)
except ValueError:
print 'Invalid timeout. Integer expected.'
sys.exit(1)
expectation = type_choices[args.type]
error_bundle = validate(args.package,
format=None,
approved_applications=args.approved_applications,
determined=args.determined,
listed=not args.selfhosted,
overrides=overrides,
for_appversions=for_appversions,
expectation=expectation,
timeout=timeout)
# Print the output of the tests based on the requested format.
if args.output == 'text':
print error_bundle.print_summary(verbose=args.verbose,
no_color=args.boring).encode('utf-8')
elif args.output == 'json':
sys.stdout.write(error_bundle.render_json())
if error_bundle.failed():
sys.exit(1)
else:
sys.exit(0)
def validate_and_submit(addon, file_, listed=None):
return validate(file_, listed=listed,
subtask=submit_file.si(addon.pk, file_.pk))
def test_validate_theme():
result = validate(path='tests/resources/validate/theme.xpi')
data = json.loads(result)
assert data['metadata']['is_extension'] is False
def run_validator(file_path,
for_appversions=None,
test_all_tiers=False,
overrides=None,
compat=False):
"""A pre-configured wrapper around the addon validator.
*file_path*
Path to addon / extension file to validate.
*for_appversions=None*
An optional dict of application versions to validate this addon
for. The key is an application GUID and its value is a list of
versions.
*test_all_tiers=False*
When False (default) the validator will not continue if it
encounters fatal errors. When True, all tests in all tiers are run.
See bug 615426 for discussion on this default.
*overrides=None*
Normally the validator gets info from install.rdf but there are a
few things we need to override. See validator for supported overrides.
Example: {'targetapp_maxVersion': {'<app guid>': '<version>'}}
*compat=False*
Set this to `True` when performing a bulk validation. This allows the
validator to ignore certain tests that should not be run during bulk
validation (see bug 735841).
To validate the addon for compatibility with Firefox 5 and 6,
you'd pass in::
for_appversions={amo.FIREFOX.guid: ['5.0.*', '6.0.*']}
Not all application versions will have a set of registered
compatibility tests.
"""
from validator.validate import validate
apps = dump_apps.Command.JSON_PATH
if not os.path.exists(apps):
call_command('dump_apps')
path = file_path
if path and not os.path.exists(path) and storage.exists(path):
path = tempfile.mktemp(suffix='_' + os.path.basename(file_path))
with open(path, 'wb') as f:
copyfileobj(storage.open(file_path), f)
temp = True
else:
temp = False
try:
with statsd.timer('devhub.validator'):
return validate(
path,
for_appversions=for_appversions,
format='json',
# When False, this flag says to stop testing after
# one tier fails.
determined=test_all_tiers,
approved_applications=apps,
spidermonkey=settings.SPIDERMONKEY,
overrides=overrides,
timeout=settings.VALIDATOR_TIMEOUT,
compat_test=compat)
finally:
if temp:
os.remove(path)
def validate_and_submit(addon, file_, channel):
return validate(
file_, listed=(channel == amo.RELEASE_CHANNEL_LISTED),
subtask=submit_file.si(addon.pk, file_.pk, channel))
def run_validator(file_path, for_appversions=None, test_all_tiers=False,
overrides=None, compat=False, listed=True):
"""A pre-configured wrapper around the addon validator.
*file_path*
Path to addon / extension file to validate.
*for_appversions=None*
An optional dict of application versions to validate this addon
for. The key is an application GUID and its value is a list of
versions.
*test_all_tiers=False*
When False (default) the validator will not continue if it
encounters fatal errors. When True, all tests in all tiers are run.
See bug 615426 for discussion on this default.
*overrides=None*
Normally the validator gets info from install.rdf but there are a
few things we need to override. See validator for supported overrides.
Example: {'targetapp_maxVersion': {'<app guid>': '<version>'}}
*compat=False*
Set this to `True` when performing a bulk validation. This allows the
validator to ignore certain tests that should not be run during bulk
validation (see bug 735841).
*listed=True*
If the addon is unlisted, treat it as if it was a self hosted one
(don't fail on the presence of an updateURL).
To validate the addon for compatibility with Firefox 5 and 6,
you'd pass in::
for_appversions={amo.FIREFOX.guid: ['5.0.*', '6.0.*']}
Not all application versions will have a set of registered
compatibility tests.
"""
from validator.validate import validate
apps = dump_apps.Command.JSON_PATH
if not os.path.exists(apps):
call_command('dump_apps')
path = file_path
if path and not os.path.exists(path) and storage.exists(path):
path = tempfile.mktemp(suffix='_' + os.path.basename(file_path))
with open(path, 'wb') as f:
copyfileobj(storage.open(file_path), f)
temp = True
else:
temp = False
try:
with statsd.timer('devhub.validator'):
return validate(path,
for_appversions=for_appversions,
format='json',
# When False, this flag says to stop testing after
# one tier fails.
determined=test_all_tiers,
approved_applications=apps,
spidermonkey=settings.SPIDERMONKEY,
overrides=overrides,
timeout=settings.VALIDATOR_TIMEOUT,
compat_test=compat,
listed=listed)
finally:
if temp:
os.remove(path)
def run_validator(path,
for_appversions=None,
test_all_tiers=False,
overrides=None,
compat=False,
listed=True):
"""A pre-configured wrapper around the addon validator.
*file_path*
Path to addon / extension file to validate.
*for_appversions=None*
An optional dict of application versions to validate this addon
for. The key is an application GUID and its value is a list of
versions.
*test_all_tiers=False*
When False (default) the validator will not continue if it
encounters fatal errors. When True, all tests in all tiers are run.
See bug 615426 for discussion on this default.
*overrides=None*
Normally the validator gets info from install.rdf but there are a
few things we need to override. See validator for supported overrides.
Example: {'targetapp_maxVersion': {'<app guid>': '<version>'}}
*compat=False*
Set this to `True` when performing a bulk validation. This allows the
validator to ignore certain tests that should not be run during bulk
validation (see bug 735841).
*listed=True*
If the addon is unlisted, treat it as if it was a self hosted one
(don't fail on the presence of an updateURL).
To validate the addon for compatibility with Firefox 5 and 6,
you'd pass in::
for_appversions={amo.FIREFOX.guid: ['5.0.*', '6.0.*']}
Not all application versions will have a set of registered
compatibility tests.
"""
if not settings.VALIDATE_ADDONS:
# This should only ever be set on development instances.
# Don't run the validator, just return a skeleton passing result set.
results = deepcopy(amo.VALIDATOR_SKELETON_RESULTS)
results['metadata']['listed'] = listed
return json.dumps(results)
from validator.validate import validate
apps = dump_apps.Command.JSON_PATH
if not os.path.exists(apps):
call_command('dump_apps')
with NamedTemporaryFile(suffix='_' + os.path.basename(path)) as temp:
if path and not os.path.exists(path) and storage.exists(path):
# This file doesn't exist locally. Write it to our
# currently-open temp file and switch to that path.
copyfileobj(storage.open(path), temp.file)
path = temp.name
with statsd.timer('devhub.validator'):
return validate(
path,
for_appversions=for_appversions,
format='json',
# When False, this flag says to stop testing after
# one tier fails.
determined=test_all_tiers,
approved_applications=apps,
spidermonkey=settings.SPIDERMONKEY,
overrides=overrides,
compat_test=compat,
listed=listed)
