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_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_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_validate_libs_in_compat_mode():
    xpi = "tests/resources/libraryblacklist/addon_with_mootools.xpi"
    with open(xpi) as data:
        package = XPIManager(data, mode="r", name="addon_with_mootools.xpi")
        err = ErrorBundle(for_appversions=FX9_DEFINITION)
        test_content.test_packed_packages(err, package)
    assert err.get_resource("scripts"), "expected mootools scripts to be marked for proessing"
    eq_(err.get_resource("scripts")[0]["scripts"], set(["content/mootools.js"]))

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_validate_libs_in_compat_mode():
    xpi = 'tests/resources/libraryblacklist/addon_with_mootools.xpi'
    with open(xpi) as data:
        package = XPIManager(data, mode='r', name='addon_with_mootools.xpi')
        appversions = {FIREFOX_GUID: version_range('firefox',
                                                   '39.0a1', '39.*')}
        err = ErrorBundle(for_appversions=appversions)
        test_content.test_packed_packages(err, package)
    assert err.get_resource('scripts'), (
                    'expected mootools scripts to be marked for proessing')
    assert err.get_resource('scripts')[0]['scripts'] == set(['content/mootools.js'])

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_jar_case():
    """Test that the capitalization of JARs is preserved."""

    err = ErrorBundle()
    mock_package = MockXPI(
        {'foo.JaR': 'tests/resources/packagelayout/ext_blacklist.xpi'})

    content.test_packed_packages(err, mock_package)

    assert err.failed()
    for message in err.errors + err.warnings:
        assert 'JaR' in message['file'][0]

def test_xpi_tiererror():
    'Tests that tiers are reset when a subpackage is encountered'

    err = ErrorBundle()
    mock_package = MockXPI(
        {'foo.xpi': 'tests/resources/content/subpackage.jar'})

    err.set_tier(2)
    content.test_packed_packages(err, mock_package)
    assert err.errors[0]['tier'] == 1
    assert err.tier == 2
    assert all(x == 1 for x in content.testendpoint_validator.found_tiers)

def test_skip_blacklisted_file():
    """Ensure blacklisted files are skipped for processing."""

    package_data = open("tests/resources/libraryblacklist/errors.xpi")
    package = XPIManager(package_data, mode="r", name="errors.xpi")
    err = ErrorBundle()

    test_content.test_packed_packages(err, package)

    print err.print_summary()
    assert err.notices
    assert not err.failed()

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 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 test_css():
    "Tests css files in the content validator."
    
    err = ErrorBundle(None, True)
    mock_package = MockXPIManager(
        {"foo.css":
             "tests/resources/content/junk.xpi"})
                        
    content.testendpoint_css = \
        MockTestEndpoint(("test_css_file", ))
    
    result = content.test_packed_packages(
                                    err,
                                    {"foo.css":
                                      {"extension": "css",
                                       "name_lower": "foo.css"}},
                                    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_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(None, True)
    mock_package = MockXPIManager(
        {"chrome/subpackage.jar":
             "tests/resources/content/subpackage.jar",
         "nonsubpackage.jar":
             "tests/resources/content/subpackage.jar"})
                        
    content.testendpoint_validator = \
        MockTestEndpoint(("test_inner_package", ))
    
    result = content.test_packed_packages(
                                    err,
                                    {"chrome/subpackage.jar":
                                      {"extension": "jar",
                                       "name_lower": "subpackage.jar"},
                                     "nonsubpackage.jar":
                                      {"extension": "jar",
                                       "name_lower": "subpackage.jar"},
                                       },
                                    mock_package)
    print result
    assert result == 2
    content.testendpoint_validator.assert_expectation(
                                    "test_inner_package",
                                    2)
    content.testendpoint_validator.assert_expectation(
                                    "test_inner_package",
                                    1,
                                    "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_xpi_nonsubpackage():
    "Tests XPI files that are not subpackages."
    
    err = ErrorBundle(None, True)
    mock_package = MockXPIManager(
        {"foo.xpi":
             "tests/resources/content/subpackage.jar"})
                        
    content.testendpoint_validator = \
        MockTestEndpoint(("test_package", ))
    
    result = content.test_packed_packages(
                                    err,
                                    {"foo.xpi":
                                      {"extension": "xpi",
                                       "name_lower": "foo.xpi"}},
                                    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_markup():
    "Tests markup files in the content validator."
    
    err = ErrorBundle(None, True)
    mock_package = MockXPIManager(
        {"foo.xml":
             "tests/resources/content/junk.xpi"})
                        
    content.testendpoint_markup = \
        MockMarkupEndpoint(("process", ))
    
    result = content.test_packed_packages(
                                    err,
                                    {"foo.xml":
                                      {"extension": "xml",
                                       "name_lower": "foo.xml"}},
                                    mock_package)
    print result
    assert result == 1
    content.testendpoint_markup.assert_expectation(
                                    "process",
                                    1)
    content.testendpoint_markup.assert_expectation(
                                    "process",
                                    0,
                                    "subpackage")

def test_password_in_defaults_prefs():
    """
    Tests that passwords aren't stored in the defaults/preferences/*.js files
    for bug 647109.
    """

    password_js = open("tests/resources/content/password.js").read()
    assert not _do_test_raw(password_js).failed()

    err = ErrorBundle()
    err.supported_versions = {}
    mock_package = MockXPI({"defaults/preferences/foo.js":
                                "tests/resources/content/password.js"})

    content.test_packed_packages(err, mock_package)
    print err.print_summary()
    assert err.failed()

def test_hidden_files():
    """Tests that hidden files are reported."""

    err = ErrorBundle()
    err.supported_versions = {}
    mock_package = MockXPI({".hidden": "tests/resources/content/junk.xpi"})

    content.test_packed_packages(err, mock_package)
    print err.print_summary(verbose=True)
    assert err.failed()

    err = ErrorBundle()
    mock_package_mac = MockXPI({"dir/__MACOSX/foo":
                                          "tests/resources/content/junk.xpi"})
    content.test_packed_packages(err, mock_package_mac)
    print err.print_summary(verbose=True)
    assert err.failed()