def test_xpi_subpackage(): "XPIs should never be subpackages; only nested extensions" err = ErrorBundle() err.set_type(PACKAGE_EXTENSION) mock_package = MockXPI( {"chrome/package.xpi": "tests/resources/content/subpackage.jar"}) content.testendpoint_validator = \ MockTestEndpoint(("test_package", )) 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(path, test, failure=True, require_install=False, set_type=0): package_data = open(path, "rb") package = XPIManager(package_data, path) contents = package.get_file_data() err = ErrorBundle() # Populate in the dependencies. if set_type: err.set_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(rdf_data) err.save_resource("install_rdf", install_rdf) test(err, contents, package) print err.print_summary(verbose=True) if failure: assert err.failed() else: assert not err.failed() return err
def test_langpack(): "Tests a language pack in the content validator." err = ErrorBundle(None, True) err.set_type(PACKAGE_LANGPACK) mock_package = MockXPIManager( {"foo.dtd": "tests/resources/content/junk.xpi"}) content.testendpoint_langpack = \ MockTestEndpoint(("test_unsafe_html", )) result = content.test_packed_packages( err, {"foo.dtd": {"extension": "dtd", "name_lower": "foo.dtd"}}, 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_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_jar_nonsubpackage(): "Tests XPI files that are not subpackages." err = ErrorBundle() err.set_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"}) content.testendpoint_validator = MockTestEndpoint(("test_inner_package", "test_package")) 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 _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.set_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(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 test_type(): """Tests that detected type is being stored properly in the error bundle.""" bundle = ErrorBundle() bundle.set_type(5) assert bundle.detected_type == 5
def test_subpackage(): "Test a package with localization that should pass validation." err = ErrorBundle() err.set_type(PACKAGE_DICTIONARY) assert l10n.test_xpi(err, None) is None err.set_type(PACKAGE_EXTENSION) err.push_state() assert l10n.test_xpi(err, None) is None
def _do_test(unpack=False, contents=(), set_type=0, is_ff4=False): "Runs the tests. Handy as hell." err = ErrorBundle(None, True) if set_type: err.set_type(set_type) err.save_resource("em:unpack", unpack) err.save_resource("ff4", is_ff4) packagelayout.test_emunpack(err, contents, None) 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.set_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_langpack(): "Tests a language pack in the content validator." err = ErrorBundle() err.supported_versions = {} err.set_type(PACKAGE_LANGPACK) mock_package = MockXPI({"foo.dtd": "tests/resources/content/junk.xpi"}) content.testendpoint_langpack = MockTestEndpoint(("test_unsafe_html", )) 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_raw(data, path, should_fail=False, type_=None): filename = path.split("/")[-1] extension = filename.split(".")[-1] err = ErrorBundle() err.supported_versions = {} if type_: err.set_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() return err
def test_json(): "Tests the JSON output capability of the error bundler." # Use the StringIO as an output buffer. bundle = ErrorBundle() # No color since no output bundle.set_type(4) bundle.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"] == 3
def _do_test(path, should_fail=False, type_=None): markup_file = open(path) data = markup_file.read() markup_file.close() filename = path.split("/")[-1] extension = filename.split(".")[-1] err = ErrorBundle(None, True) if type_: err.set_type(type_) parser = markuptester.MarkupParser(err, True) parser.process(filename, data, extension) err.print_summary(True) if should_fail: assert err.failed() else: assert not err.failed() return err
def test_states(): """Tests 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.set_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.set_type(2) bundle.error((), "nested error") bundle.warning((), "nested warning") bundle.notice((), "nested notice") # Push another state bundle.push_state("test2.xpi") bundle.set_type(3) bundle.error((), "super nested error") bundle.warning((), "super nested warning") bundle.notice((), "super nested notice") 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"]) == 9 print output messages = ["error", "warning", "notice", "nested error", "nested warning", "nested notice", "super nested error", "super nested warning", "super nested notice"] for message in output["messages"]: print message assert message["message"] in messages messages.remove(message["message"]) assert message["message"].endswith(message["type"]) assert not messages assert bundle.get_resource("test")
def test_json_constructs(): """This tests some of the internal JSON stuff so we don't break zamboni.""" e = ErrorBundle() e.set_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