Example #1
0
def test_get_applications():
    """Test the get_applications method on the RDFParser."""
    parser = RDFParser(None, open('tests/resources/installrdf/pass.rdf'))
    applications = parser.get_applications()
    assert applications == [{
        'guid': u'{ec8030f7-c20a-464f-9b0e-13a3a9e97384}',
        'min_version': u'3.7a5pre',
        'max_version': u'0.3'}]
Example #2
0
def test_namespacing():
    """Tests that the RDF parser successfully creates namespaces."""

    r = RDFParser(None, open("tests/resources/rdf/pass.rdf"), "foo")

    assert r.namespace == "foo"
    assert str(r.uri("bar")) == "foo#bar"
    assert str(r.uri("bar", "abc")) == "abc#bar"
Example #3
0
def test_namespacing():
    """Tests that the RDF parser successfully creates namespaces."""

    r = RDFParser(None, open('tests/resources/rdf/pass.rdf'), 'foo')

    assert r.namespace == 'foo'
    assert str(r.uri('bar')) == 'foo#bar'
    assert str(r.uri('bar', 'abc')) == 'abc#bar'
Example #4
0
def test_namespacing():
    """Tests that the RDF parser successfully creates namespaces."""
    
    r = RDFParser(_load_rdf("tests/resources/rdf/pass.rdf"), "foo")
    
    assert r.namespace == "foo"
    assert str(r.uri("bar")) == "foo#bar"
    assert str(r.uri("bar", "abc")) == "abc#bar"
def test_get_applications():
    """Test the get_applications method on the RDFParser."""
    parser = RDFParser(None, open('tests/resources/installrdf/pass.rdf'))
    applications = parser.get_applications()
    assert applications == [{
        'guid': u'{ec8030f7-c20a-464f-9b0e-13a3a9e97384}',
        'min_version': u'3.7a5pre',
        'max_version': u'0.3'}]
Example #6
0
def test_namespacing():
    """Tests that the RDF parser successfully creates namespaces."""

    r = RDFParser(None, open('tests/resources/rdf/pass.rdf'), 'foo')

    assert r.namespace == 'foo'
    assert str(r.uri('bar')) == 'foo#bar'
    assert str(r.uri('bar', 'abc')) == 'abc#bar'
def _do_test_raw(rdf, listed=True, overrides=None):
    err = ErrorBundle(listed=listed)
    err.overrides = overrides
    rdf = RDFParser(err, rdf.strip())
    err.save_resource('has_install_rdf', True)
    err.save_resource('install_rdf', rdf)

    targetapp.test_targetedapplications(err)
    return err
def _do_test_raw(rdf, listed=True, overrides=None):
    err = ErrorBundle(listed=listed)
    err.overrides = overrides
    rdf = RDFParser(err, rdf.strip())
    err.save_resource('has_install_rdf', True)
    err.save_resource('install_rdf', rdf)

    targetapp.test_targetedapplications(err)
    return err
def _do_test_raw(rdf, listed=True, overrides=None):
    err = ErrorBundle(listed=listed)
    err.overrides = overrides
    rdf = RDFParser(rdf.strip())
    err.save_resource("has_install_rdf", True)
    err.save_resource("install_rdf", rdf)

    targetapp.test_targetedapplications(err)
    print err.print_summary()
    return err
Example #10
0
def test_get_root_subject():
    'Tests the integrity of the get_root_subject() function'

    r = RDFParser(None, open('tests/resources/rdf/pass.rdf'))
    type_uri = r.uri('type')

    emtype = r.get_object(None, type_uri)
    assert emtype is not None

    emtype = r.get_object(r.get_root_subject(), type_uri)
    assert emtype is not None
Example #11
0
def test_get_root_subject():
    "Tests the integrity of the get_root_subject() function"
    
    r = RDFParser(_load_rdf("tests/resources/rdf/pass.rdf"))
    type_uri = r.uri("type")
    
    emtype = r.get_object(None, type_uri)
    assert emtype is not None
    
    emtype = r.get_object(r.get_root_subject(), type_uri)
    assert emtype is not None
Example #12
0
def test_get_object():
    """"Tests the integrity of the get_object() and get_objects()
    functions."""
    
    r = RDFParser(_load_rdf("tests/resources/rdf/pass.rdf"))
    test_uri = r.uri("test")
    
    emtest = r.get_object(None, test_uri)
    assert emtest is not None
    
    emtests = r.get_objects(None, test_uri)
    assert len(emtests) == 3
    assert emtests[0] == emtest
Example #13
0
def test_get_object():
    """Tests the integrity of the get_object() and get_objects()
    functions."""

    r = RDFParser(None, open('tests/resources/rdf/pass.rdf'))
    test_uri = r.uri('test')

    emtest = r.get_object(None, test_uri)
    assert emtest is not None

    emtests = r.get_objects(None, test_uri)
    assert len(emtests) == 3
    assert emtests[0] == emtest
Example #14
0
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
Example #15
0
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
Example #16
0
def test_billion_laughs_fail():
    """Test that the parsing fails for XML will a billion laughs attack."""
    xml = """<?xml version="1.0"?>
<!DOCTYPE lolz [
 <!ENTITY lol "lol">
 <!ELEMENT Description (#PCDATA)>
 <!ENTITY lol1 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
 <!ENTITY lol2 "&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;">
 <!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
 <!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
 <!ENTITY lol5 "&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;">
 <!ENTITY lol6 "&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;">
 <!ENTITY lol7 "&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;">
 <!ENTITY lol8 "&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;">
 <!ENTITY lol9 "&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;">
]>
<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
     xmlns:em="http://www.mozilla.org/2004/em-rdf#">
    <Description about="urn:mozilla:install-manifest">
        <em:id>&lol9;@basta.mozilla.com</em:id>
        <em:version>1.2.3.4</em:version>
        <em:name>foo bar</em:name>
        <em:targetApplication>
            <Description>
                <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
                <em:minVersion>3.7a5pre</em:minVersion>
                <em:maxVersion>0.3</em:maxVersion>
            </Description>
        </em:targetApplication>
        <em:optionsType>2</em:optionsType>
    </Description>
</RDF>
"""
    RDFParser(ErrorBundle(), xml)
Example #17
0
def _load_install_rdf(err, package, expectation):
    try:
        install_rdf = RDFParser(err, package.read("install.rdf"))
    except (RDFException, DefusedXmlException) as ex:
        if isinstance(ex, DefusedXmlException):
            url = "https://pypi.python.org/pypi/defusedxml/0.3#attack-vectors"
            reason = "Malicious XML was detected, see {0}.".format(url)
            line = 0
        else:
            reason = ("Try validating your RDF with the W3 validator: "
                      "http://www.w3.org/RDF/Validator/.")
            line = ex.line()
        err.error(err_id=("main", "test_package", "parse_error"),
                  error="Could not parse `install.rdf`.",
                  description=[
                      "The RDF parser was unable to parse the "
                      "install.rdf file included with this add-on.", reason
                  ],
                  filename="install.rdf",
                  line=line)
        return
    else:
        if install_rdf.rdf is None:
            err.error(err_id=("main", "test_package",
                              "cannot_parse_installrdf"),
                      error="Cannot read `install.rdf`",
                      description="The install.rdf file could not be parsed.",
                      filename="install.rdf")
            return
        else:
            err.save_resource("has_install_rdf", True, pushable=True)
            err.save_resource("install_rdf", install_rdf, pushable=True)

    # Load up the results of the type detection
    results = detect_type(err, install_rdf, package)
    if results is None:
        err.error(
            err_id=("main", "test_package", "undeterminable_type"),
            error="Unable to determine add-on type",
            description="The type detection algorithm could not determine "
            "the type of the add-on.")
        return
    else:
        err.detected_type = results

    # Compare the results of the low-level type detection to
    # that of the expectation and the assumption.
    if not expectation in (PACKAGE_ANY, results):
        err.warning(err_id=("main", "test_package", "extension_type_mismatch"),
                    warning="Extension Type Mismatch",
                    description=[
                        "We detected that the add-on's type does not match "
                        "the expected type.",
                        'Type "%s" expected, found "%s"' %
                        (types[expectation], types[results])
                    ])
Example #18
0
def _load_install_rdf(err, package, expectation):
    try:
        install_rdf = RDFParser(err, package.read('install.rdf'))
    except (RDFException, DefusedXmlException) as ex:
        if isinstance(ex, DefusedXmlException):
            url = 'https://pypi.python.org/pypi/defusedxml/0.3#attack-vectors'
            reason = 'Malicious XML was detected, see {0}.'.format(url)
            line = 0
        else:
            reason = ('Try validating your RDF with the W3 validator: '
                      'http://www.w3.org/RDF/Validator/.')
            line = ex.line()
        err.error(err_id=('main', 'test_package', 'parse_error'),
                  error='Could not parse `install.rdf`.',
                  description=('The RDF parser was unable to parse the '
                               'install.rdf file included with this add-on.',
                               reason),
                  filename='install.rdf',
                  line=line)
        return
    else:
        if install_rdf.rdf is None:
            err.error(err_id=('main', 'test_package',
                              'cannot_parse_installrdf'),
                      error='Cannot read `install.rdf`',
                      description='The install.rdf file could not be parsed.',
                      filename='install.rdf')
            return
        else:
            err.save_resource('has_install_rdf', True, pushable=True)
            err.save_resource('install_rdf', install_rdf, pushable=True)

    # Load up the results of the type detection
    results = detect_type(err, install_rdf, package)
    if results is None:
        err.error(
            err_id=('main', 'test_package', 'undeterminable_type'),
            error='Unable to determine add-on type',
            description='The type detection algorithm could not determine '
            'the type of the add-on.')
        return
    else:
        err.detected_type = results

    # Compare the results of the low-level type detection to
    # that of the expectation and the assumption.
    if expectation not in (PACKAGE_ANY, results):
        err.warning(
            err_id=('main', 'test_package', 'extension_type_mismatch'),
            warning='Extension Type Mismatch',
            description=("We detected that the add-on's type does not match "
                         'the expected type.',
                         'Type "%s" expected, found "%s"' %
                         (types[expectation], types[results])))
def test_manifest_ordering():
    err = ErrorBundle(listed=True)
    manifest = ManifestJsonParser(err, INVALID_MANIFEST_JSON)
    err.save_resource('has_manifest_json', True)
    err.save_resource('manifest_json', manifest)
    rdf = RDFParser(err, VALID_INSTALL_RDF.strip())
    err.save_resource('has_install_rdf', True)
    err.save_resource('install_rdf', rdf)

    targetapp.test_targetedapplications(err)

    assert not err.failed()
Example #20
0
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
Example #21
0
def test_get_root_subject():
    'Tests the integrity of the get_root_subject() function'

    r = RDFParser(None, open('tests/resources/rdf/pass.rdf'))
    type_uri = r.uri('type')

    emtype = r.get_object(None, type_uri)
    assert emtype is not None

    emtype = r.get_object(r.get_root_subject(), type_uri)
    assert emtype is not None
Example #22
0
def _test_type(file_, expectation, failure=False):
    'Tests a file against the expectations'

    err = ErrorBundle(None, True)
    package = XPIManager(open(file_), mode='r', name=file_)
    contents = package.package_contents()

    # 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(err, install_file)

    results = typedetection.detect_type(err, install_rdf, package)

    assert results == expectation
    if not failure:
        assert not err.failed()
    else:
        assert err.failed()

    return err
Example #23
0
def testopen():
    """Tests that the RDF parser is capable of loading an RDF file
    successfully."""

    r = RDFParser(None, open('tests/resources/rdf/pass.rdf'))
    assert r.rdf
Example #24
0
def test_load_rdf_stringio():
    """Tests that the RDF parser is capable of loading an RDF file
    from a StringIO object successfully."""

    r = RDFParser(None, StringIO(open('tests/resources/rdf/pass.rdf').read()))
    assert r.rdf
Example #25
0
def test_load_bad():
    """Tests that the RDF parser throws an error for invalid, damaged,
    or corrupt RDF files."""

    r = RDFParser(None, open('tests/resources/rdf/fail.rdf'))
    assert not r.rdf