def test_subpackage(): 'Test a package with localization that should pass validation.' err = ErrorBundle() err.detected_type = PACKAGE_DICTIONARY assert l10n.test_xpi(err, None) is None err.detected_type = PACKAGE_EXTENSION err.push_state() assert l10n.test_xpi(err, None) is None
def test_invalid_package_type(): "No such thing as a Conduit theme." err = ErrorBundle(None, True) err.detected_type = PACKAGE_ANY assert conduit.test_conduittoolbar(err) is None err.detected_type = PACKAGE_THEME assert conduit.test_conduittoolbar(err) is None err.detected_type = PACKAGE_SEARCHPROV assert conduit.test_conduittoolbar(err) is None
def test_invalid_package_type(): """Assert that conduit toolbars can only be extensions.""" err = ErrorBundle() err.detected_type = PACKAGE_ANY assert conduit.test_conduittoolbar(err) is None err.detected_type = PACKAGE_THEME assert conduit.test_conduittoolbar(err) is None err.detected_type = PACKAGE_SEARCHPROV assert conduit.test_conduittoolbar(err) is None
def _do_test(path, test, failure=True, require_install=False, set_type=0, listed=False, xpi_mode="r"): package_data = open(path, "rb") package = XPIManager(package_data, mode=xpi_mode, name=path) err = ErrorBundle() if listed: err.save_resource("listed", True) # Populate in the dependencies. if set_type: err.detected_type = set_type # Conduit test requires type if require_install: err.save_resource("has_install_rdf", True) rdf_data = package.read("install.rdf") install_rdf = RDFParser(err, rdf_data) err.save_resource("install_rdf", install_rdf) populate_chrome_manifest(err, package) test(err, package) print err.print_summary(verbose=True) if failure: assert err.failed() else: assert not err.failed() return err
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 _run_test_raw(data, failure=True, detected_type=0, listed=True, overrides=None, compat=False): "Runs a test on an install.rdf snippet" data = data.strip() err = ErrorBundle() err.detected_type = detected_type err.save_resource("listed", listed) err.overrides = overrides if compat: err.save_resource("is_compat_test", True) err.save_resource("has_install_rdf", True) err.save_resource("install_rdf", RDFParser(err, data)) installrdf.test_install_rdf_params(err) print err.print_summary(verbose=True) if failure: # pragma: no cover assert err.failed() or err.notices else: assert not err.failed() and not err.notices return err
def test_webapp_bom(): """Test that a plain webapp with a BOM won't throw errors.""" err = ErrorBundle(listed=False) err.detected_type = validator.constants.PACKAGE_WEBAPP validator.webapp.detect_webapp( err, "tests/resources/unicodehelper/utf8_webapp.json") assert not err.failed()
def test_json_constructs(): """This tests some of the internal JSON stuff so we don't break zamboni.""" e = ErrorBundle() e.detected_type = 1 e.error(("a", "b", "c"), "Test") e.error(("a", "b", "foo"), "Test") e.error(("a", "foo", "c"), "Test") e.error(("a", "foo", "c"), "Test") e.error(("b", "foo", "bar"), "Test") e.warning((), "Context test", context=("x", "y", "z")) e.warning((), "Context test", context=ContextGenerator("x\ny\nz\n"), line=2, column=0) e.notice((), "none") e.notice((), "line", line=1) e.notice((), "column", column=0) e.notice((), "line column", line=1, column=1) results = e.render_json() print results j = json.loads(results) assert "detected_type" in j assert j["detected_type"] == "extension" assert "message_tree" in j tree = j["message_tree"] assert "__errors" not in tree assert not tree["a"]["__messages"] assert tree["a"]["__errors"] == 4 assert not tree["a"]["b"]["__messages"] assert tree["a"]["b"]["__errors"] == 2 assert not tree["a"]["b"]["__messages"] assert tree["a"]["b"]["c"]["__errors"] == 1 assert tree["a"]["b"]["c"]["__messages"] assert "messages" in j for m in (m for m in j["messages"] if m["type"] == "warning"): assert m["context"] == ["x", "y", "z"] for m in (m for m in j["messages"] if m["type"] == "notice"): if "line" in m["message"]: assert m["line"] is not None assert isinstance(m["line"], int) assert m["line"] > 0 else: assert m["line"] is None if "column" in m["message"]: assert m["column"] is not None assert isinstance(m["column"], int) assert m["column"] > -1 else: assert m["column"] is None
def test_json_constructs(): """This tests some of the internal JSON stuff so we don't break zamboni.""" e = ErrorBundle() e.detected_type = 1 e.error(('a', 'b', 'c'), 'Test') e.error(('a', 'b', 'foo'), 'Test') e.error(('a', 'foo', 'c'), 'Test') e.error(('a', 'foo', 'c'), 'Test') e.error(('b', 'foo', 'bar'), 'Test') e.warning((), 'Context test', context=('x', 'y', 'z')) e.warning((), 'Context test', context=ContextGenerator('x\ny\nz\n'), line=2, column=0) e.notice((), 'none') e.notice((), 'line', line=1) e.notice((), 'column', column=0) e.notice((), 'line column', line=1, column=1) results = e.render_json() print results j = json.loads(results) assert 'detected_type' in j assert j['detected_type'] == 'extension' assert 'message_tree' in j tree = j['message_tree'] assert '__errors' not in tree assert not tree['a']['__messages'] assert tree['a']['__errors'] == 4 assert not tree['a']['b']['__messages'] assert tree['a']['b']['__errors'] == 2 assert not tree['a']['b']['__messages'] assert tree['a']['b']['c']['__errors'] == 1 assert tree['a']['b']['c']['__messages'] assert 'messages' in j for m in (m for m in j['messages'] if m['type'] == 'warning'): assert m['context'] == ['x', 'y', 'z'] for m in (m for m in j['messages'] if m['type'] == 'notice'): if 'line' in m['message']: assert m['line'] is not None assert isinstance(m['line'], int) assert m['line'] > 0 else: assert m['line'] is None if 'column' in m['message']: assert m['column'] is not None assert isinstance(m['column'], int) assert m['column'] > -1 else: assert m['column'] is None
def test_type(): """ Test that detected type is being stored properly in the error bundle. """ bundle = ErrorBundle() bundle.detected_type = 5 assert bundle.detected_type == 5
def test_subpackage_metadata_preserved(): """Tests that metadata is preserved for sub-packages.""" xpi1 = open('tests/resources/jetpack/jetpack-1.16-outdated.xpi') xpi2 = MockXPI({ 'thing.xpi': 'tests/resources/jetpack/jetpack-1.16-outdated.xpi'}) err1 = ErrorBundle() err1.detected_type = PACKAGE_EXTENSION err2 = ErrorBundle() err2.detected_type = PACKAGE_EXTENSION submain.test_package(err1, xpi1, 'jetpack-1.16-outdated.xpi') content.test_packed_packages(err2, xpi2) assert 'sub_packages' in err2.metadata assert err1.metadata == err2.metadata['sub_packages'].get('thing.xpi')
def test_subpackage_metadata_preserved(): """Tests that metadata is preserved for sub-packages.""" xpi1 = open('tests/resources/jetpack/jetpack-1.16-outdated.xpi') xpi2 = MockXPI( {'thing.xpi': 'tests/resources/jetpack/jetpack-1.16-outdated.xpi'}) err1 = ErrorBundle() err1.detected_type = PACKAGE_EXTENSION err2 = ErrorBundle() err2.detected_type = PACKAGE_EXTENSION submain.test_package(err1, xpi1, 'jetpack-1.16-outdated.xpi') content.test_packed_packages(err2, xpi2) assert 'sub_packages' in err2.metadata assert err1.metadata == err2.metadata['sub_packages'].get('thing.xpi')
def test_subpackage_metadata_preserved(): """Tests that metadata is preserved for sub-packages.""" xpi1 = open("tests/resources/jetpack/jetpack-1.8-outdated.xpi") xpi2 = MockXPI( {"thing.xpi": "tests/resources/jetpack/jetpack-1.8-outdated.xpi"}) err1 = ErrorBundle() err1.detected_type = PACKAGE_EXTENSION err2 = ErrorBundle() err2.detected_type = PACKAGE_EXTENSION submain.test_package(err1, xpi1, "jetpack-1.8-outdated.xpi") content.test_packed_packages(err2, xpi2) assert "sub_packages" in err2.metadata eq_(err1.metadata, err2.metadata["sub_packages"].get("thing.xpi"))
def test_subpackage_metadata_preserved(): """Tests that metadata is preserved for sub-packages.""" xpi1 = open("tests/resources/jetpack/jetpack-1.8-outdated.xpi") xpi2 = MockXPI({ "thing.xpi": "tests/resources/jetpack/jetpack-1.8-outdated.xpi"}) err1 = ErrorBundle() err1.detected_type = PACKAGE_EXTENSION err2 = ErrorBundle() err2.detected_type = PACKAGE_EXTENSION submain.test_package(err1, xpi1, "jetpack-1.8-outdated.xpi") content.test_packed_packages(err2, xpi2) assert "sub_packages" in err2.metadata eq_(err1.metadata, err2.metadata["sub_packages"] .get("thing.xpi"))
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_has_rdf(install_rdf): "Tests that tests won't be run if there's no install.rdf" err = ErrorBundle() assert installrdf.test_install_rdf_params(err, None) is None err.detected_type = 0 err.save_resource('install_rdf', RDFParser(err, '<rdf></rdf>')) err.save_resource('has_install_rdf', True) installrdf.test_install_rdf_params(err, None) assert install_rdf.called
def test_has_rdf(install_rdf): "Tests that tests won't be run if there's no install.rdf" err = ErrorBundle() assert installrdf.test_install_rdf_params(err, None) is None err.detected_type = 0 err.save_resource("install_rdf", RDFParser(err, "<rdf></rdf>")) err.save_resource("has_install_rdf", True) installrdf.test_install_rdf_params(err, None) assert install_rdf.called
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 _do_test(unpack=False, contents=None, set_type=0, is_ff4=False): 'Runs the tests. Handy as hell.' if not contents: contents = [] err = ErrorBundle(None, True) if set_type: err.detected_type = set_type err.save_resource('em:unpack', unpack) err.save_resource('ff4', is_ff4) packagelayout.test_emunpack( err, MockXPI(dict(zip(contents, [True for c in contents])))) return err
def _do_test(unpack=False, contents=None, set_type=0, is_ff4=False): "Runs the tests. Handy as hell." if not contents: contents = [] err = ErrorBundle(None, True) if set_type: err.detected_type = set_type err.save_resource("em:unpack", unpack) err.save_resource("ff4", is_ff4) packagelayout.test_emunpack( err, MockXPI(dict(zip(contents, [True for c in contents])))) return err
def test_xpi_subpackage(): "XPIs should never be subpackages; only nested extensions" err = ErrorBundle() err.detected_type = PACKAGE_EXTENSION mock_package = MockXPI( {"chrome/package.xpi": "tests/resources/content/subpackage.jar"}) result = content.test_packed_packages(err, mock_package) print result assert result == 1 content.testendpoint_validator.assert_expectation("test_package", 1) content.testendpoint_validator.assert_expectation("test_package", 0, "subpackage")
def test_remote_css(): """Test that remote CSS references are flagged.""" snippet = """ x {foo: url(http://foo.com/bar);} """ err = ErrorBundle() csstester.test_css_snippet(err, "x.css", snippet, 0) assert not err.failed() err = ErrorBundle() err.detected_type = PACKAGE_THEME csstester.test_css_snippet(err, "x.css", snippet, 0) assert err.failed()
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_remote_css(): """Test that remote CSS references are flagged.""" snippet = """ x {foo: url(http://foo.com/bar);} """ err = ErrorBundle() csstester.test_css_snippet(err, 'x.css', snippet, 0) assert not err.failed() err = ErrorBundle() err.detected_type = PACKAGE_THEME csstester.test_css_snippet(err, 'x.css', snippet, 0) assert err.failed()
def _do_test(path, should_fail=False, detected_type=None): data = open(path).read() err = ErrorBundle() if detected_type is not None: err.detected_type = detected_type csstester.test_css_file(err, 'css.css', data) err.print_summary(True) if should_fail: assert err.failed() else: assert not err.failed() return err
def test_remote_css_ignored(): """Test that suspicious but innocuous css-isms are ignored.""" snippet = """ @namespace url(http://foo.bar/asdf); @namespace url("http://foo.bar/asdf"); """ err = ErrorBundle() csstester.test_css_snippet(err, "x.css", snippet, 0) assert not err.failed() err = ErrorBundle() err.detected_type = PACKAGE_THEME csstester.test_css_snippet(err, "x.css", snippet, 0) assert not err.failed()
def test_remote_css_ignored(): """Test that suspicious but innocuous css-isms are ignored.""" snippet = """ @namespace url(http://foo.bar/asdf); @namespace url("http://foo.bar/asdf"); """ err = ErrorBundle() csstester.test_css_snippet(err, 'x.css', snippet, 0) assert not err.failed() err = ErrorBundle() err.detected_type = PACKAGE_THEME csstester.test_css_snippet(err, 'x.css', snippet, 0) assert not err.failed()
def _do_test(path, should_fail=False, detected_type=None): data = open(path).read() err = ErrorBundle() if detected_type is not None: err.detected_type = detected_type csstester.test_css_file(err, "css.css", data) err.print_summary(True) if should_fail: assert err.failed() else: assert not err.failed() return err
def test_has_rdf(): "Tests that tests won't be run if there's no install.rdf" err = ErrorBundle() err.detected_type = 0 err.save_resource("install_rdf", "test") err.save_resource("has_install_rdf", True) testrdf = installrdf._test_rdf installrdf._test_rdf = lambda x, y: y result = installrdf.test_install_rdf_params(err, None, None) installrdf._test_rdf = testrdf print result assert result return err
def _do_real_test_raw(script, path='foo.js', versions=None, detected_type=None, metadata=None, resources=None, jetpack=False): """Perform a JS test using a non-mock bundler.""" err = ErrorBundle(for_appversions=versions or {}) if detected_type: err.detected_type = detected_type if metadata is not None: err.metadata = metadata if resources is not None: err.resources = resources if jetpack: err.metadata['is_jetpack'] = True validator.testcases.content._process_file(err, MockXPI(), path, script, path.lower()) return err
def test_xpi_subpackage(): 'XPIs should never be subpackages; only nested extensions' err = ErrorBundle() err.detected_type = PACKAGE_EXTENSION mock_package = MockXPI( {'chrome/package.xpi': 'tests/resources/content/subpackage.jar'}) result = content.test_packed_packages(err, mock_package) print result assert result == 1 content.testendpoint_validator.assert_expectation( 'test_package', 1) content.testendpoint_validator.assert_expectation( 'test_package', 0, 'subpackage')
def _do_test_raw(script, path="foo.js", bootstrap=False, ignore_pollution=True, detected_type=None): "Performs a test on a JS file" err = ErrorBundle(instant=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 err.final_context.output() return err
def _run_test(filename, failure=True, detected_type=0): "Runs a test on an install.rdf file" err = ErrorBundle() err.detected_type = detected_type data = open(filename).read() parser = RDFParser(data) installrdf._test_rdf(err, parser) print err.print_summary() if failure: # pragma: no cover assert err.failed() or err.notices else: assert not err.failed() and not err.notices return err
def test_jar_nonsubpackage(): 'Tests XPI files that are not subpackages.' err = ErrorBundle() err.detected_type = PACKAGE_MULTI err.save_resource('is_multipackage', True) mock_package = MockXPI({ 'foo.jar': 'tests/resources/content/subpackage.jar', 'chrome/bar.jar': 'tests/resources/content/subpackage.jar' }) result = content.test_packed_packages(err, mock_package) print result assert result == 2 content.testendpoint_validator.assert_expectation('test_package', 2) content.testendpoint_validator.assert_expectation('test_package', 0, 'subpackage')
def test_jar_nonsubpackage(): "Tests XPI files that are not subpackages." err = ErrorBundle() err.detected_type = PACKAGE_MULTI err.save_resource("is_multipackage", True) mock_package = MockXPI({ "foo.jar": "tests/resources/content/subpackage.jar", "chrome/bar.jar": "tests/resources/content/subpackage.jar" }) result = content.test_packed_packages(err, mock_package) print result assert result == 2 content.testendpoint_validator.assert_expectation("test_package", 2) content.testendpoint_validator.assert_expectation("test_package", 0, "subpackage")
def test_jar_subpackage(): "Tests JAR files that are subpackages." err = ErrorBundle() err.detected_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" }) 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_xul_raw(data, path, should_fail=False, type_=None): filename = path.split("/")[-1] extension = filename.split(".")[-1] err = ErrorBundle() err.supported_versions = {} if type_: err.detected_type = type_ parser = markuptester.MarkupParser(err, debug=True) parser.process(filename, data, extension) print err.print_summary(verbose=True) if should_fail: assert err.failed() else: assert not err.failed(fail_on_warnings=False) return err
def test_jar_subpackage(): 'Tests JAR files that are subpackages.' err = ErrorBundle() err.detected_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' }) 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 _do_test(path, test, failure=True, require_install=False, set_type=0, listed=False, xpi_mode='r'): package_data = open(path, 'rb') package = XPIManager(package_data, mode=xpi_mode, name=path) err = ErrorBundle() if listed: err.save_resource('listed', True) # Populate in the dependencies. if set_type: err.detected_type = set_type # Conduit test requires type if require_install: if 'install.rdf' in package: err.save_resource('has_install_rdf', True) rdf_data = package.read('install.rdf') install_rdf = RDFParser(err, rdf_data) err.save_resource('install_rdf', install_rdf) elif 'manifest.json' in package: err.save_resource('has_manifest_json', True) manifest_data = package.read('manifest.json') manifest_json = ManifestJsonParser(err, manifest_data) err.save_resource('install_rdf', manifest_json) populate_chrome_manifest(err, package) test(err, package) print err.print_summary(verbose=True) if failure: assert err.failed() else: assert not err.failed() return err
def test_json(): """Test the JSON output capability of the error bundler.""" # Use the StringIO as an output buffer. bundle = ErrorBundle() bundle.detected_type = 4 bundle.set_tier(4) bundle.set_tier(3) bundle.error((), "error", "description") bundle.warning((), "warning", "description") bundle.notice((), "notice", "description") results = json.loads(bundle.render_json()) print results assert len(results["messages"]) == 3 assert results["detected_type"] == "langpack" assert not results["success"] assert results["ending_tier"] == 4
def test_json(): """Test the JSON output capability of the error bundler.""" # Use the StringIO as an output buffer. bundle = ErrorBundle() # No color since no output bundle.detected_type = 4 bundle.set_tier(4) bundle.set_tier(3) bundle.error((), "error", "description") bundle.warning((), "warning", "description") bundle.notice((), "notice", "description") results = json.loads(bundle.render_json()) print results assert len(results["messages"]) == 3 assert results["detected_type"] == 'langpack' assert not results["success"] assert results["ending_tier"] == 4
def test_json(): """Test the JSON output capability of the error bundler.""" # Use the StringIO as an output buffer. bundle = ErrorBundle() # No color since no output bundle.detected_type = 4 bundle.set_tier(4) bundle.set_tier(3) bundle.error((), 'error', 'description') bundle.warning((), 'warning', 'description') bundle.notice((), 'notice', 'description') results = json.loads(bundle.render_json()) print results assert len(results['messages']) == 3 assert results['detected_type'] == 'langpack' assert not results['success'] assert results['ending_tier'] == 4
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 _run_test_raw(data, failure=True, detected_type=0, listed=True, overrides=None): "Runs a test on an install.rdf snippet" data = data.strip() err = ErrorBundle() err.detected_type = detected_type err.save_resource("listed", listed) err.overrides = overrides parser = RDFParser(data) installrdf._test_rdf(err, parser) print err.print_summary(verbose=True) if failure: # pragma: no cover assert err.failed() or err.notices else: assert not err.failed() and not err.notices return err
def _do_test_raw(script, path="foo.js", bootstrap=False, ignore_pollution=True, detected_type=None, jetpack=False): "Performs a test on a JS file" err = ErrorBundle(instant=True) err.save_resource("SPIDERMONKEY", False) 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 err.final_context.output() return err
def test_jar_nonsubpackage(): 'Tests XPI files that are not subpackages.' err = ErrorBundle() err.detected_type = PACKAGE_MULTI err.save_resource('is_multipackage', True) mock_package = MockXPI( {'foo.jar': 'tests/resources/content/subpackage.jar', 'chrome/bar.jar': 'tests/resources/content/subpackage.jar'}) result = content.test_packed_packages(err, mock_package) print result assert result == 2 content.testendpoint_validator.assert_expectation( 'test_package', 2) content.testendpoint_validator.assert_expectation( 'test_package', 0, 'subpackage')
def test_jar_nonsubpackage(): "Tests XPI files that are not subpackages." err = ErrorBundle() err.detected_type = PACKAGE_MULTI err.save_resource("is_multipackage", True) mock_package = MockXPI( {"foo.jar": "tests/resources/content/subpackage.jar", "chrome/bar.jar": "tests/resources/content/subpackage.jar"}) result = content.test_packed_packages(err, mock_package) print result assert result == 2 content.testendpoint_validator.assert_expectation( "test_package", 2) content.testendpoint_validator.assert_expectation( "test_package", 0, "subpackage")
def test_states(): """Test that detected type is preserved, even in subpackages.""" # Use the StringIO as an output buffer. bundle = ErrorBundle() # Populate the bundle with some test data. bundle.detected_type = 4 bundle.error((), 'error') bundle.warning((), 'warning') bundle.notice((), 'notice') bundle.save_resource('test', True) # Push a state bundle.push_state('test.xpi') bundle.detected_type = 2 bundle.error((), 'nested error') bundle.warning((), 'nested warning') bundle.notice((), 'nested notice') # Push another state bundle.push_state('test2.xpi') bundle.detected_type = 3 bundle.error((), 'super nested error') bundle.warning((), 'super nested warning') bundle.notice((), 'super nested notice') # Test that nested compatibility messages retain various # properties. bundle.notice('comp', 'Compat Test notice', compatibility_type='error', editors_only=True, signing_severity='high') bundle.pop_state() bundle.pop_state() # Load the JSON output as an object. output = json.loads(bundle.render_json()) # Run some basic tests assert output['detected_type'] == 'langpack' assert len(output['messages']) == 10 messages = [ 'error', 'warning', 'notice', 'nested error', 'nested warning', 'nested notice', 'super nested error', 'super nested warning', 'super nested notice', 'Compat Test notice' ] for message in output['messages']: assert message['message'] in messages messages.remove(message['message']) assert message['message'].endswith(message['type']) if message['id'] == 'comp': assert message['compatibility_type'] == 'error' assert message['editors_only'] == True assert message['signing_severity'] == 'high' assert not messages assert bundle.get_resource('test')
def test_states(): """Test that detected type is preserved, even in subpackages.""" # Use the StringIO as an output buffer. bundle = ErrorBundle() # Populate the bundle with some test data. bundle.detected_type = 4 bundle.error((), "error") bundle.warning((), "warning") bundle.notice((), "notice") bundle.save_resource("test", True) # Push a state bundle.push_state("test.xpi") bundle.detected_type = 2 bundle.error((), "nested error") bundle.warning((), "nested warning") bundle.notice((), "nested notice") # Push another state bundle.push_state("test2.xpi") bundle.detected_type = 3 bundle.error((), "super nested error") bundle.warning((), "super nested warning") bundle.notice((), "super nested notice") # Test that nested compatibility messages retain their value bundle.notice("comp", "Compat Test notice", compatibility_type="error") bundle.pop_state() bundle.pop_state() # Load the JSON output as an object. output = json.loads(bundle.render_json()) # Run some basic tests assert output["detected_type"] == "langpack" assert len(output["messages"]) == 10 print output messages = [ "error", "warning", "notice", "nested error", "nested warning", "nested notice", "super nested error", "super nested warning", "super nested notice", "Compat Test notice" ] for message in output["messages"]: print message assert message["message"] in messages messages.remove(message["message"]) assert message["message"].endswith(message["type"]) if message["id"] == "comp": assert message["compatibility_type"] == "error" assert not messages assert bundle.get_resource("test")