def test_scripting_snippet():
'Assert that JS snippets are treated equally.'
err = ErrorBundle()
err.supported_versions = {}
scripting.test_js_snippet(err, 'alert(1 + 1 == 2)', 'bar.zap')
assert not err.failed()
err = ErrorBundle()
err.supported_versions = {}
scripting.test_js_snippet(err, "eval('foo');", 'bar.zap')
assert err.failed()
def test_scripting_snippet():
"Asserts that JS snippets are treated equally"
err = ErrorBundle()
err.supported_versions = {}
scripting.test_js_snippet(err, "alert(1 + 1 == 2)", "bar.zap")
assert not err.failed()
err = ErrorBundle()
err.supported_versions = {}
scripting.test_js_snippet(err, "eval('foo');", "bar.zap")
assert err.failed()
def test_scripting_snippet():
'Assert that JS snippets are treated equally.'
err = ErrorBundle()
err.supported_versions = {}
scripting.test_js_snippet(err, 'alert(1 + 1 == 2)', 'bar.zap')
assert not err.failed()
err = ErrorBundle()
err.supported_versions = {}
scripting.test_js_snippet(err, "eval('foo');", 'bar.zap')
assert err.failed()
def test_scripting_snippet():
"Asserts that JS snippets are treated equally"
err = ErrorBundle()
err.supported_versions = {}
scripting.test_js_snippet(err, "alert(1 + 1 == 2)", "bar.zap")
assert not err.failed()
err = ErrorBundle()
err.supported_versions = {}
scripting.test_js_snippet(err, "eval('foo');", "bar.zap")
assert err.failed()
def test_packed_scripts_no_pollution():
"""
Test that packed scripts test for pollution without being overzealous.
"""
x = MockXPI({'foo/bar.js': 'tests/resources/content/pollution_error.js'})
err = ErrorBundle()
err.supported_versions = {}
c = ChromeManifest("""
content ns jar:subpackage.jar!/
""", 'chrome.manifest')
err.save_resource('chrome.manifest_nopush', c, pushable=False)
err.save_resource(
'scripts',
[{'scripts': ['foo/bar.js'],
'package': x,
'state': ['subpackage', 'subsubpackage']}])
err.save_resource('marked_scripts', set(['chrome://otherns/foo/bar.js']))
content.test_packed_scripts(err, x)
assert err.package_stack == []
assert not err.failed()
def test_packed_scripts_no_pollution():
"""
Test that packed scripts test for pollution without being overzealous.
"""
x = MockXPI({'foo/bar.js': 'tests/resources/content/pollution_error.js'})
err = ErrorBundle()
err.supported_versions = {}
c = ChromeManifest("""
content ns jar:subpackage.jar!/
""", 'chrome.manifest')
err.save_resource('chrome.manifest_nopush', c, pushable=False)
err.save_resource('scripts', [{
'scripts': ['foo/bar.js'],
'package': x,
'state': ['subpackage', 'subsubpackage']
}])
err.save_resource('marked_scripts', set(['chrome://otherns/foo/bar.js']))
content.test_packed_scripts(err, x)
eq_(err.package_stack, [])
assert not err.failed()
def test_marking_overlays():
"""
Mark an overlay, then test that it marks the scripts within the overlay.
"""
err = ErrorBundle()
err.supported_versions = {}
c = chrome_manifest("""
content ns1 foo/
overlay chrome://foo chrome://ns1/content/main.xul
""")
err.save_resource('chrome.manifest', c)
err.save_resource('chrome.manifest_nopush', c)
xpi = MockXPI({'foo/main.xul': 'tests/resources/content/script_list.xul'})
content.test_packed_packages(err, xpi)
assert not err.failed()
marked_scripts = err.get_resource('marked_scripts')
eq_(
marked_scripts,
set([
'chrome://ns1/foo.js', 'chrome://ns1/bar.js',
'chrome://asdf/foo.js'
]))
def test_marking_overlays_root_package():
"""
Tests that '/' resolves correctly as a chrome content package.
"""
err = ErrorBundle()
err.supported_versions = {}
manifest = chrome_manifest("""
content ns1 /
overlay chrome://foo chrome://ns1/content/main.xul
""")
err.save_resource('chrome.manifest', manifest)
err.save_resource('chrome.manifest_nopush', manifest)
xpi = MockXPI({'main.xul': 'tests/resources/content/script_list.xul'})
content.test_packed_packages(err, xpi)
assert not err.failed()
marked_scripts = err.get_resource('marked_scripts')
eq_(
marked_scripts,
set([
'chrome://ns1/foo.js', 'chrome://ns1/bar.js',
'chrome://asdf/foo.js'
]))
def _do_test_raw(script,
path='foo.js',
bootstrap=False,
ignore_pollution=True,
detected_type=None,
jetpack=False,
instant=True):
"""Perform a test on a JS file."""
err = ErrorBundle(instant=instant)
if jetpack:
err.metadata['is_jetpack'] = True
err.handler = OutputHandler(sys.stdout, True)
err.supported_versions = {}
if bootstrap:
err.save_resource('em:bootstrap', True)
if detected_type:
err.detected_type = detected_type
validator.testcases.content._process_file(err, MockXPI(), path, script,
path.lower(),
not ignore_pollution)
if err.final_context is not None:
print 'CONTEXT', repr(err.final_context.keys())
return err
def test_packed_scripts_pollution():
"""Test that packed scripts test for pollution properly."""
x = MockXPI({"foo/bar.js": "tests/resources/content/pollution_error.js"})
err = ErrorBundle()
err.supported_versions = {}
c = ChromeManifest("""
content ns jar:subpackage.jar!/
""", "chrome.manifest")
err.save_resource("chrome.manifest_nopush", c, pushable=False)
err.save_resource(
"scripts",
[{"scripts": ["foo/bar.js"],
"package": x,
"state": ["subpackage.jar", "subsubpackage"]}])
err.save_resource("marked_scripts", set(["chrome://ns/foo/bar.js"]))
content.test_packed_scripts(err, x)
eq_(err.package_stack, [])
assert err.failed()
assert err.warnings
assert not err.errors
def _test(script):
err = ErrorBundle()
err.supported_versions = {}
err.save_resource("em:bootstrap", "true")
scripting.test_js_file(err, "foo", script)
return err
def test_packed_scripts_pollution():
"""Test that packed scripts test for pollution properly."""
x = MockXPI({'foo/bar.js': 'tests/resources/content/pollution_error.js'})
err = ErrorBundle()
err.supported_versions = {}
c = chrome_manifest('content ns jar:subpackage.jar!/')
err.save_resource('chrome.manifest_nopush', c, pushable=False)
err.save_resource(
'scripts',
[{'scripts': ['foo/bar.js'],
'package': x,
'state': ['subpackage.jar', 'subsubpackage']}])
err.save_resource('marked_scripts', set(['chrome://ns/foo/bar.js']))
content.test_packed_scripts(err, x)
eq_(err.package_stack, [])
assert err.failed()
assert err.warnings
assert not err.errors
eq_(err.warnings[0]['file'],
['subpackage.jar', 'subsubpackage', 'foo/bar.js'])
def test_marking_overlays_subdir():
"""
Mark an overlay in a subdirectory, then test that it marks the scripts
within the overlay. Make sure it properly figures out relative URLs.
"""
err = ErrorBundle()
err.supported_versions = {}
c = ChromeManifest("""
content ns1 foo/
overlay chrome://foo chrome://ns1/content/subdir/main.xul
""", 'chrome.manifest')
err.save_resource('chrome.manifest', c)
err.save_resource('chrome.manifest_nopush', c)
xpi = MockXPI({'foo/subdir/main.xul':
'tests/resources/content/script_list.xul'})
content.test_packed_packages(err, xpi)
assert not err.failed()
marked_scripts = err.get_resource('marked_scripts')
print marked_scripts
assert marked_scripts
eq_(marked_scripts, set(['chrome://ns1/subdir/foo.js', 'chrome://ns1/bar.js',
'chrome://asdf/foo.js']))
def test_packed_scripts_no_pollution():
"""
Test that packed scripts test for pollution without being overzealous.
"""
x = MockXPI({"foo/bar.js": "tests/resources/content/pollution_error.js"})
err = ErrorBundle()
err.supported_versions = {}
c = ChromeManifest("""
content ns jar:subpackage.jar!/
""", "chrome.manifest")
err.save_resource("chrome.manifest_nopush", c, pushable=False)
err.save_resource(
"scripts",
[{"scripts": ["foo/bar.js"],
"package": x,
"state": ["subpackage", "subsubpackage"]}])
err.save_resource("marked_scripts", set(["chrome://otherns/foo/bar.js"]))
content.test_packed_scripts(err, x)
eq_(err.package_stack, [])
assert not err.failed()
def _test(script):
err = ErrorBundle()
err.supported_versions = {}
err.save_resource("em:bootstrap", "true")
scripting.test_js_file(err, "foo", script)
return err
def test_packed_scripts_pollution():
"""Test that packed scripts test for pollution properly."""
x = MockXPI({"foo/bar.js": "tests/resources/content/pollution_error.js"})
err = ErrorBundle()
err.supported_versions = {}
c = ChromeManifest("""
content ns jar:subpackage.jar!/
""", "chrome.manifest")
err.save_resource("chrome.manifest_nopush", c, pushable=False)
err.save_resource(
"scripts",
[{"scripts": ["foo/bar.js"],
"package": x,
"state": ["subpackage.jar", "subsubpackage"]}])
err.save_resource("marked_scripts", set(["chrome://ns/foo/bar.js"]))
content.test_packed_scripts(err, x)
eq_(err.package_stack, [])
assert err.failed()
assert err.warnings
assert not err.errors
eq_(err.warnings[0]["file"],
['subpackage.jar', 'subsubpackage', 'foo/bar.js'])
def test_jar_subpackage():
"Tests JAR files that are subpackages."
err = ErrorBundle()
err.set_type(PACKAGE_EXTENSION)
err.supported_versions = {"foo": ["1.2.3"]}
mock_package = MockXPI(
{"chrome/subpackage.jar":
"tests/resources/content/subpackage.jar",
"subpackage.jar":
"tests/resources/content/subpackage.jar"})
content.testendpoint_validator = \
MockTestEndpoint(("test_inner_package", ))
result = content.test_packed_packages(
err,
mock_package)
print result
assert result == 2
content.testendpoint_validator.assert_expectation(
"test_inner_package",
2)
content.testendpoint_validator.assert_expectation(
"test_inner_package",
2,
"subpackage")
assert err.supported_versions == {"foo": ["1.2.3"]}
def test_version_forappversions_accepted():
"""
Test that for_appversions targets application versions properly.
"""
err = ErrorBundle()
err.supported_versions = {'firefox': ['1.2.3']}
tests = decorator.TEST_TIERS
decorator.TEST_TIERS = {}
@decorator.register_test(tier=5, versions={'firefox': ['1.0.0',
'1.2.3']})
def version_test(err, xpi):
print 'Ran test'
err.save_resource('executed', True)
print decorator.TEST_TIERS
validator.submain.test_inner_package(err, MockXPI(),
for_appversions={'firefox':
['1.2.3']})
assert err.get_resource('executed')
decorator.TEST_TIERS = tests
def test_marking_overlays():
"""
Mark an overlay, then test that it marks the scripts within the overlay.
"""
err = ErrorBundle()
err.supported_versions = {}
c = ChromeManifest("""
content ns1 foo/
overlay chrome://foo chrome://ns1/content/main.xul
""", "chrome.manifest")
err.save_resource("chrome.manifest", c)
err.save_resource("chrome.manifest_nopush", c)
xpi = MockXPI({"foo/main.xul": "tests/resources/content/script_list.xul"})
content.test_packed_packages(err, xpi)
assert not err.failed()
marked_scripts = err.get_resource("marked_scripts")
print marked_scripts
assert marked_scripts
eq_(marked_scripts, set(["chrome://ns1/foo.js",
"chrome://ns1/bar.js",
"chrome://asdf/foo.js"]))
def test_packed_scripts_pollution():
"""Test that packed scripts test for pollution properly."""
x = MockXPI({'foo/bar.js': 'tests/resources/content/pollution_error.js'})
err = ErrorBundle()
err.supported_versions = {}
c = ChromeManifest("""
content ns jar:subpackage.jar!/
""", 'chrome.manifest')
err.save_resource('chrome.manifest_nopush', c, pushable=False)
err.save_resource('scripts', [{
'scripts': ['foo/bar.js'],
'package': x,
'state': ['subpackage.jar', 'subsubpackage']
}])
err.save_resource('marked_scripts', set(['chrome://ns/foo/bar.js']))
content.test_packed_scripts(err, x)
assert err.package_stack == []
assert err.failed()
assert err.warnings
assert not err.errors
assert err.warnings[0]['file'] == [
'subpackage.jar', 'subsubpackage', 'foo/bar.js'
]
def test_structure(structure):
err = ErrorBundle()
err.supported_versions = {}
mock_package = MockXPI(structure)
content.test_packed_packages(err, mock_package)
print err.print_summary(verbose=True)
assert err.failed()
def _test(script):
err = ErrorBundle()
err.supported_versions = {}
err.save_resource('em:bootstrap', 'true')
scripting.test_js_file(err, 'foo', script)
return err
def test_structure(structure):
err = ErrorBundle()
err.supported_versions = {}
mock_package = MockXPI(structure)
content.test_packed_packages(err, mock_package)
print err.print_summary(verbose=True)
assert err.failed()
def _test(script):
err = ErrorBundle()
err.supported_versions = {}
err.save_resource('em:bootstrap', 'true')
scripting.test_js_file(err, 'foo', script)
return err
def test_hidden_files(test_input):
"""Tests that hidden files are reported."""
err = ErrorBundle()
err.supported_versions = {}
mock_package = MockXPI(test_input)
content.test_packed_packages(err, mock_package)
print err.print_summary(verbose=True)
assert err.failed()
def _do_test(path):
script = validator.unicodehelper.decode(open(path, 'rb').read())
print script.encode('ascii', 'replace')
err = ErrorBundle(instant=True)
err.supported_versions = {}
err.handler = OutputHandler(sys.stdout, False)
validator.testcases.scripting.test_js_file(err, path, script)
return err
def test_hidden_files(test_input):
"""Tests that hidden files are reported."""
err = ErrorBundle()
err.supported_versions = {}
mock_package = MockXPI(test_input)
content.test_packed_packages(err, mock_package)
print err.print_summary(verbose=True)
assert err.failed()
def test(versions):
err = ErrorBundle()
err.supported_versions = versions
parser = MarkupParser(err)
parser.process(name,
data,
name.split(".")[-1])
print err.print_summary(verbose=True)
assert not err.failed()
return err
def test_packed_scripts_ignored_no_scripts():
"""Test that packed scripts are not tested when there are no scripts."""
x = MockXPI({'foo.js': 'tests/resources/content/one_error.js'})
err = ErrorBundle()
err.supported_versions = {}
content.test_packed_scripts(err, x)
assert not err.failed()
def test_unsigned_xpi():
"""Test that unsigned packages don't raise warning"""
x = MockXPI()
err = ErrorBundle()
err.supported_versions = {}
content.test_signed_xpi(err, x)
assert not err.failed()
def test_unsigned_xpi():
"""Test that unsigned packages don't raise warning"""
x = MockXPI()
err = ErrorBundle()
err.supported_versions = {}
content.test_signed_xpi(err, x)
assert not err.failed()
def test(versions):
err = ErrorBundle()
err.supported_versions = versions
parser = MarkupParser(err)
parser.process(name,
data,
name.split(".")[-1])
print err.print_summary(verbose=True)
assert not err.failed()
return err
def test_packed_scripts_ignored_no_scripts():
"""Test that packed scripts are not tested when there are no scripts."""
x = MockXPI({'foo.js': 'tests/resources/content/one_error.js'})
err = ErrorBundle()
err.supported_versions = {}
content.test_packed_scripts(err, x)
assert not err.failed()
def test_unsigned_inner_xpi():
"""Test that inner XPIs need to be signed even if not multi-package."""
xpi = MockXPI(subpackage=True)
err = ErrorBundle()
err.supported_versions = {}
err.push_state('inner.xpi')
err.save_resource('is_multipackage', False)
content.test_signed_xpi(err, xpi)
assert err.failed()
def test_langpack():
'Tests a language pack in the content validator.'
err = ErrorBundle()
err.supported_versions = {}
err.detected_type = PACKAGE_LANGPACK
mock_package = MockXPI({'foo.dtd': 'tests/resources/content/junk.xpi'})
content.test_packed_packages(err, mock_package)
content.testendpoint_langpack.assert_expectation('test_unsafe_html', 1)
content.testendpoint_langpack.assert_expectation('test_unsafe_html', 0,
'subpackage')
def test_unsigned_inner_xpi():
"""Test that inner XPIs need to be signed even if not multi-package."""
xpi = MockXPI(subpackage=True)
err = ErrorBundle()
err.supported_versions = {}
err.push_state('inner.xpi')
err.save_resource('is_multipackage', False)
content.test_signed_xpi(err, xpi)
assert err.failed()
def test_markup():
'Tests markup files in the content validator.'
err = ErrorBundle()
err.supported_versions = {}
mock_package = MockXPI({'foo.xml': 'tests/resources/content/junk.xpi'})
result = content.test_packed_packages(err, mock_package)
print result
assert result == 1
content.testendpoint_markup.assert_expectation('process', 1)
content.testendpoint_markup.assert_expectation('process', 0, 'subpackage')
def test_markup():
"Tests markup files in the content validator."
err = ErrorBundle()
err.supported_versions = {}
mock_package = MockXPI({"foo.xml": "tests/resources/content/junk.xpi"})
result = content.test_packed_packages(err, mock_package)
print result
assert result == 1
content.testendpoint_markup.assert_expectation("process", 1)
content.testendpoint_markup.assert_expectation("process", 0, "subpackage")
def test_markup():
"Tests markup files in the content validator."
err = ErrorBundle()
err.supported_versions = {}
mock_package = MockXPI({"foo.xml": "tests/resources/content/junk.xpi"})
result = content.test_packed_packages(err, mock_package)
print result
assert result == 1
content.testendpoint_markup.assert_expectation("process", 1)
content.testendpoint_markup.assert_expectation("process", 0, "subpackage")
def test_markup():
'Tests markup files in the content validator.'
err = ErrorBundle()
err.supported_versions = {}
mock_package = MockXPI({'foo.xml': 'tests/resources/content/junk.xpi'})
result = content.test_packed_packages(err, mock_package)
print result
assert result == 1
content.testendpoint_markup.assert_expectation('process', 1)
content.testendpoint_markup.assert_expectation('process', 0, 'subpackage')
def test_unsigned_inner_jar():
"""Test that inner packages don't need to be signed if not multipackage."""
xpi = MockXPI(subpackage=True)
xpi.filename = 'mock_jar.jar'
err = ErrorBundle()
err.supported_versions = {}
err.push_state('inner.jar')
err.save_resource('is_multipackage', False)
content.test_signed_xpi(err, xpi)
assert not err.failed()
def test_unsigned_inner_jar():
"""Test that inner packages don't need to be signed if not multipackage."""
xpi = MockXPI(subpackage=True)
xpi.filename = 'mock_jar.jar'
err = ErrorBundle()
err.supported_versions = {}
err.push_state('inner.jar')
err.save_resource('is_multipackage', False)
content.test_signed_xpi(err, xpi)
assert not err.failed()
def test_langpack():
"Tests a language pack in the content validator."
err = ErrorBundle()
err.supported_versions = {}
err.detected_type = PACKAGE_LANGPACK
mock_package = MockXPI({"foo.dtd": "tests/resources/content/junk.xpi"})
result = content.test_packed_packages(err, mock_package)
print result
assert result == 1
content.testendpoint_langpack.assert_expectation("test_unsafe_html", 1)
content.testendpoint_langpack.assert_expectation("test_unsafe_html", 0,
"subpackage")
def test_langpack():
"Tests a language pack in the content validator."
err = ErrorBundle()
err.supported_versions = {}
err.detected_type = PACKAGE_LANGPACK
mock_package = MockXPI({"foo.dtd": "tests/resources/content/junk.xpi"})
result = content.test_packed_packages(err, mock_package)
print result
assert result == 1
content.testendpoint_langpack.assert_expectation("test_unsafe_html", 1)
content.testendpoint_langpack.assert_expectation("test_unsafe_html", 0,
"subpackage")
def test_missing_installrdfs_are_handled():
"""
Tests that install.rdf files are present and supported_versions is set to
an empty dict if an install.rdf is not found.
"""
err = ErrorBundle()
# This is the default, but I'm specifying it for clarity of purpose.
err.supported_versions = None
# Test package to make sure has_install_rdf is set to True.
assert targetapp.test_targetedapplications(err, None) is None
# The supported versions list must be empty or other tests will fail.
assert err.supported_versions == {}
def _do_real_test_raw(script, path="foo.js", versions=None, detected_type=None,
metadata=None, resources=None):
"""Perform a JS test using a non-mock bundler."""
err = ErrorBundle()
if detected_type:
err.detected_type = detected_type
err.supported_versions = versions or {}
if metadata is not None:
err.metadata = metadata
if resources is not None:
err.resources = resources
validator.testcases.content._process_file(err, MockXPI(), path, script)
return err
def test_css():
"Tests css files in the content validator."
err = ErrorBundle()
err.supported_versions = {}
mock_package = MockXPI({"foo.css": "tests/resources/content/junk.xpi"})
content.testendpoint_css = MockTestEndpoint(("test_css_file", ))
result = content.test_packed_packages(err, mock_package)
print result
assert result == 1
content.testendpoint_css.assert_expectation("test_css_file", 1)
content.testendpoint_css.assert_expectation("test_css_file", 0,
"subpackage")
def test_basic_regex_fail():
'Tests that a simple Regex match causes a warning'
assert _do_test_raw("var x = 'network.http.';").failed()
assert _do_test_raw("var x = 'extensions.foo.update.url';").failed()
assert _do_test_raw("var x = 'network.websocket.foobar';").failed()
assert _do_test_raw("var x = 'browser.preferences.instantApply';").failed()
assert _do_test_raw("var x = 'nglayout.debug.disable_xul_cache';").failed()
err = ErrorBundle()
err.supported_versions = {}
validator.testcases.content._process_file(
err, MockXPI(), 'foo.hbs',
'All I wanna do is <%= interpolate %> to you', 'foo.hbs')
assert err.failed()
def test_unsigned_multi_xpi():
"""Test that unsigned inner packages raise an error."""
xpi = MockXPI(subpackage=True)
err = ErrorBundle()
err.supported_versions = {}
err.push_state('sub.xpi')
err.save_resource('is_multipackage', True)
content.test_signed_xpi(err, xpi)
assert err.failed()
assert not err.warnings
assert err.errors
assert err.errors[0]['id'] == ('testcases_content', 'unsigned_sub_xpi')
def test_unsigned_multi_xpi():
"""Test that unsigned inner packages raise an error."""
xpi = MockXPI(subpackage=True)
err = ErrorBundle()
err.supported_versions = {}
err.push_state('sub.xpi')
err.save_resource('is_multipackage', True)
content.test_signed_xpi(err, xpi)
assert err.failed()
assert not err.warnings
assert err.errors
assert err.errors[0]['id'] == ('testcases_content', 'unsigned_sub_xpi')
def test_basic_regex_fail():
"Tests that a simple Regex match causes a warning"
assert _do_test_raw("var x = 'network.http.';").failed()
assert _do_test_raw("var x = 'extensions.foo.update.url';").failed()
assert _do_test_raw("var x = 'network.websocket.foobar';").failed()
assert _do_test_raw("var x = 'browser.preferences.instantApply';").failed()
err = ErrorBundle()
err.supported_versions = {}
result = validator.testcases.content._process_file(
err, MockXPI(), "foo.css",
"All I wanna do is browser.preferences.instantApply() to you",
"foo.css")
assert result
assert err.failed()
def test_mozilla_signed_multi_xpi():
"""Test that mozilla signed inner packages don't raise an error."""
xpi = MockXPI({
'META-INF/manifest.mf': 'tests/resources/main/foo.bar',
'META-INF/mozilla.rsa': 'tests/resources/main/foo.bar',
'META-INF/mozilla.sf': 'tests/resources/main/foo.bar',
}, subpackage=True)
err = ErrorBundle()
err.supported_versions = {}
err.push_state('sub.xpi')
err.save_resource('is_multipackage', True)
content.test_signed_xpi(err, xpi)
assert not err.failed()
def test_basic_regex_fail():
'Tests that a simple Regex match causes a warning'
assert _do_test_raw("var x = 'network.http.';").failed()
assert _do_test_raw("var x = 'extensions.foo.update.url';").failed()
assert _do_test_raw("var x = 'network.websocket.foobar';").failed()
assert _do_test_raw("var x = 'browser.preferences.instantApply';").failed()
assert _do_test_raw("var x = 'nglayout.debug.disable_xul_cache';").failed()
err = ErrorBundle()
err.supported_versions = {}
validator.testcases.content._process_file(
err, MockXPI(), 'foo.hbs',
'All I wanna do is <%= interpolate %> to you',
'foo.hbs')
assert err.failed()
def test_packed_scripts_ignored():
"""Test that packed scripts are not tested in subpackages."""
x = MockXPI({'foo.js': 'tests/resources/content/one_error.js'})
err = ErrorBundle()
err.supported_versions = {}
err.save_resource('scripts', [{
'scripts': ['foo.js'],
'package': x,
'state': []
}])
err.package_stack = ['foo']
content.test_packed_scripts(err, x)
assert not err.failed()
def test_mozilla_signed_multi_xpi():
"""Test that mozilla signed inner packages don't raise an error."""
xpi = MockXPI(
{
'META-INF/manifest.mf': 'tests/resources/main/foo.bar',
'META-INF/mozilla.rsa': 'tests/resources/main/foo.bar',
'META-INF/mozilla.sf': 'tests/resources/main/foo.bar',
},
subpackage=True)
err = ErrorBundle()
err.supported_versions = {}
err.push_state('sub.xpi')
err.save_resource('is_multipackage', True)
content.test_signed_xpi(err, xpi)
assert not err.failed()
