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_blacklisted_files(): """Tests the validator's ability to hash each individual file and (based on this information) determine whether the addon passes or fails the validation process.""" package_data = open("tests/resources/libraryblacklist/blocked.xpi") package = XPIManager(package_data, "blocked.xpi") contents = package.get_file_data() err = ErrorBundle() libblacklist.test_library_blacklist(err, contents, package) print err.print_summary() assert err.notices
def _test_type(file_, expectation, failure=False): "Tests a file against the expectations" err = ErrorBundle(None, True) package = XPIManager(open(file_, "rb"), file_) contents = package.get_file_data() # We need to have an install.rdf. assert "install.rdf" in contents # Load up the install.rdf into an RDFParser install_file = package.read("install.rdf") install_rdf = RDFParser(install_file) results = typedetection.detect_type(err, install_rdf, package) assert results == expectation if not failure: assert not err.failed() else: assert err.failed()
def test_package(err, file_, name, expectation=PACKAGE_ANY): "Begins tests for the package." # Load up a new instance of an XPI. package = XPIManager(file_, name) if not package.zf: # Die on this one because the file won't open. return err.error(("main", "test_package", "unopenable"), "The XPI could not be opened.") # Test the XPI file for corruption. if package.test(): err.reject = True return err.error(("main", "test_package", "corrupt"), "XPI package appears to be corrupt.") if package.extension in assumed_extensions: assumed_type = assumed_extensions[package.extension] # Is the user expecting a different package type? if not expectation in (PACKAGE_ANY, assumed_type): err.error(("main", "test_package", "unexpected_type"), "Unexpected package type (found theme)") # Cache a copy of the package contents. package_contents = package.get_file_data() # Test the install.rdf file to see if we can get the type that way. has_install_rdf = "install.rdf" in package_contents if has_install_rdf: _load_install_rdf(err, package, expectation) return test_inner_package(err, package_contents, package)
def test_valid_name(): "Test that the manager can retrieve the correct file name" z = XPIManager("tests/resources/xpi/install_rdf_only.xpi") contents = z.get_file_data() assert "install.rdf" in contents assert z.test() == False
def test_get_list(): "Test that the manager can read the file listing" z = XPIManager("tests/resources/xpi/install_rdf_only.xpi") assert z.get_file_data()
def test_lp_xpi(err, package_contents, xpi_package): "Tests a language pack for L10n completeness" # Don't even both with the test(s) if there's no chrome.manifest. if "chrome.manifest" not in package_contents: return None locales = _get_locales(err, xpi_package); # Get the reference packages. references = [] support_references = err.get_resource("supports") if not support_references: references.append("firefox") err.info(("testcases_l10ncompleteness", "test_lp_xpi", "missing_app_support"), "Supported app missing during L10n completeness.", """While testing for L10n comleteness, a list of supported applications for the language pack was not found. This is likely because there are no listed <em:targetApplication> elements in the install.rdf file.""") else: for support in support_references: ref_xpi = XPIManager(os.path.join(os.path.dirname(__file__), "langpacks/%s.xpi" % support)) ref_xpi.app_name = support reference_locales = _get_locales(None, ref_xpi) references.append((ref_xpi, reference_locales)) # Iterate each supported reference package for (ref_xpi, ref_locales) in references: # Iterate each locale in each supported reference package ref_pack = _get_locale_manager(err, ref_xpi, "en-US.jar", ref_xpi.get_file_data(), no_cache=True) for ref_locale_name in ref_locales: ref_locale = ref_locales[ref_locale_name] ref_predicate = ref_locale["predicate"] corresp_locales = [locales[name] for name in locales if locales[name]["predicate"] == ref_predicate] # If we found no matching locale, then it's missing from the pack if not corresp_locales: err.warning(("testcases_l10ncompleteness", "test_lp_xpi", "find_corresponding_locale"), "Could not find corresponding locale", ["A locale was found in the reference package, " "however it was not found in the target package.", "Missing locale: %s" % ref_predicate], filename="chrome.manifest") continue target_locale = corresp_locales[0] target_pack = _get_locale_manager(err, xpi_package, target_locale["path"], package_contents) if target_pack is None: continue results = _compare_packages(reference=ref_pack, target=target_pack, ref_base=ref_locale["target"], locale_base=target_locale["target"]) # Report the findings after each supported app's locale _aggregate_results(err, results, target_locale) # Clear the cache at the end of the test LOCALE_CACHE = {}
def test_packed_packages(err, package_contents=None, xpi_package=None): "Tests XPI and JAR files for naughty content." processed_files = 0 hash_whitelist = [x[:-1] for x in open(os.path.join(os.path.dirname(__file__), 'whitelist_hashes.txt')).readlines()] # Iterate each item in the package. for name, data in package_contents.items(): if name.startswith("__MACOSX") or \ name.startswith(".DS_Store"): continue if name.split("/")[-1].startswith("._"): err.notice(("testcases_content", "test_packed_packages", "macintosh_junk"), "Garbage file found.", ["""A junk file has been detected. It may cause problems with proper operation of the add-on down the road.""", "It is recommended that you delete the file"], name) try: file_data = xpi_package.read(name) except KeyError: # pragma: no cover _read_error(err, name) # Skip over whitelisted hashes hash = hashlib.sha1(file_data).hexdigest() if hash in hash_whitelist: continue processed = False # If that item is a container file, unzip it and scan it. if data["extension"] == "jar": # This is either a subpackage or a nested theme. # Whether this is a subpackage or a nested theme is # determined by whether it is in the root folder or not. # Subpackages are always found in a directory such as # /chrome or /content. is_subpackage = name.count("/") > 0 # Unpack the package and load it up. package = StringIO(file_data) sub_xpi = XPIManager(package, name, is_subpackage) if not sub_xpi.zf: err.error(("testcases_content", "test_packed_packages", "jar_subpackage_corrupt"), "Subpackage corrupt.", """The subpackage could not be opened due to issues with corruption. Ensure that the file is valid.""", name) continue temp_contents = sub_xpi.get_file_data() # Let the error bunder know we're in a sub-package. err.push_state(data["name_lower"]) err.set_type(PACKAGE_SUBPACKAGE) # Subpackage testendpoint_validator.test_inner_package(err, temp_contents, sub_xpi) err.tier = 2 package.close() err.pop_state() elif data["extension"] == "xpi": # It's not a subpackage, it's a nested extension. These are # found in multi-extension packages. # Unpack! package = StringIO(file_data) err.push_state(data["name_lower"]) # There are no expected types for packages within a multi- # item package. testendpoint_validator.test_package(err, package, name) err.tier = 2 # Reset to the current tier package.close() err.pop_state() elif data["extension"] in ("xul", "xml", "html", "xhtml"): parser = testendpoint_markup.MarkupParser(err) parser.process(name, charsethelper.decode(file_data), data["extension"]) processed = True elif data["extension"] in ("css", "js", "jsm"): if not file_data: continue file_data = charsethelper.decode(file_data) if data["extension"] == "css": testendpoint_css.test_css_file(err, name, file_data) elif data["extension"] in ("js", "jsm"): testendpoint_js.test_js_file(err, name, file_data) # This is tested in test_langpack.py if err.detected_type == PACKAGE_LANGPACK and not processed: testendpoint_langpack.test_unsafe_html(err, name, file_data) # This aids in creating unit tests. processed_files += 1 return processed_files