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
