def test_load_fields(self):
"""compdesc.load populates id, name, etc. fields"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0"?>
<component>
<id>resolveme</id>
<name>Resolve Me</name>
<description>
I need to be resolved
</description>
<requires>a</requires>
<requires>b</requires>
<provides>c</provides>
<provides>d</provides>
</component>
EOF
''')
desc = ComponentDescriptor('a.xml')
component = desc.load(None)
self.assert_equals('resolveme', component.id)
self.assert_equals('Resolve Me', component.name)
self.assert_equals('\n I need to be resolved\n ',
component.description)
self.assert_equals(['a', 'b'], component.requires)
self.assert_equals(['c', 'd'], component.provides)
def test_read_write_and_or(self):
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb>
<or>
<and>
<name>a</name>
<arch>b</arch>
</and>
<name>c</name>
</or>
<my.some>value</my.some>
</deb>
</contents>
</component>
EOF
cp a.xml b.xml
''')
desc = ComponentDescriptor('a.xml')
deb_ref = desc.contents[0]
expected = rules.ac([
rules.oc([ rules.ac([ rules.rc(eq, 'pdk', 'name', 'a'),
rules.rc(eq, 'pdk', 'arch', 'b') ]),
rules.rc(eq, 'pdk', 'name', 'c') ]),
rules.rc(eq, 'my', 'some', 'value') ])
expected = PhantomConditionWrapper(expected, deb, None)
self.assert_equals_long(expected, deb_ref.reference.condition)
desc.write()
self.assert_equals_long(open('b.xml').read(), open('a.xml').read())
def test_load_fields(self):
"""compdesc.load populates id, name, etc. fields"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0"?>
<component>
<id>resolveme</id>
<name>Resolve Me</name>
<description>
I need to be resolved
</description>
<requires>a</requires>
<requires>b</requires>
<provides>c</provides>
<provides>d</provides>
</component>
EOF
''')
desc = ComponentDescriptor('a.xml')
component = desc.load(None)
self.assert_equals('resolveme', component.id)
self.assert_equals('Resolve Me', component.name)
self.assert_equals('\n I need to be resolved\n ',
component.description)
self.assert_equals(['a', 'b'], component.requires)
self.assert_equals(['c', 'd'], component.provides)
def test_load_and_write_cond(self):
"""compdesc.load returns a component with packages"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb>
<cond><![CDATA[ apache (>>2) ]]></cond>
<deb ref="sha-1:aaa">
<cond>apache</cond>
</deb>
</deb>
</contents>
</component>
EOF
cp a.xml b.xml
''')
desc = ComponentDescriptor('a.xml')
desc.write()
self.assert_equals_long(open('b.xml').read(), open('a.xml').read())
condition = desc.contents[0].reference.condition
a = MockPackage('apache', '2-1', deb, 'sha-1:aaa')
b = MockPackage('apache', '1.3', deb, 'sha-1:bbb')
assert condition.evaluate(a)
assert not condition.evaluate(b)
def test_load_and_write_cond(self):
"""compdesc.load returns a component with packages"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb>
<cond><![CDATA[ apache (>>2) ]]></cond>
<deb ref="sha-1:aaa">
<cond>apache</cond>
</deb>
</deb>
</contents>
</component>
EOF
cp a.xml b.xml
''')
desc = ComponentDescriptor('a.xml')
desc.write()
self.assert_equals_long(open('b.xml').read(), open('a.xml').read())
condition = desc.contents[0].reference.condition
a = MockPackage('apache', '2-1', deb, 'sha-1:aaa')
b = MockPackage('apache', '1.3', deb, 'sha-1:bbb')
assert condition.evaluate(a)
assert not condition.evaluate(b)
def test_parse_link(self):
'''Check that we can parse entities at all.'''
open('test.xml', 'w').write('''<?xml version="1.0"?>
<component>
<contents>
<deb ref="sha-1:aaa">
<meta>
<pdk.link>
<some-meta>can-do</some-meta>
</pdk.link>
</meta>
</deb>
</contents>
</component>
''')
desc = ComponentDescriptor('test.xml')
self.assert_equal([('some-meta', 'can-do')],
desc.contents[0].links)
cache = ShamCache()
package = MockPackage('a', '1', deb, 'sha-1:aaa')
cache.add(package)
comp = desc.load(cache)
package = comp.iter_packages().next()
self.assert_equals([('some-meta', 'can-do')], package.links)
def test_load_sub_component_meta(self):
"""Be sure metadata gets loaded from subcomponents even if
the toplevel component has none.
"""
open('test1.xml', 'w').write('''<?xml version="1.0"?>
<component>
<contents>
<component>test2.xml</component>
</contents>
</component>
''')
open('test2.xml', 'w').write('''<?xml version="1.0"?>
<component>
<contents>
<deb ref="sha-1:aaa">
<meta>
<necessity>mandatory</necessity>
</meta>
</deb>
</contents>
</component>
''')
cache = ShamCache()
package = MockPackage('a', '1', deb, 'sha-1:aaa')
cache.add(package)
desc = ComponentDescriptor('test1.xml')
comp = desc.load(cache)
assert package in list(comp.iter_packages())
self.assert_equal("mandatory", package[('pdk', 'necessity')])
def test_write_relation(self):
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb>
<version>2.0.53</version>
<version-lt>2.0.53</version-lt>
<version-lt-eq>2.0.53</version-lt-eq>
<version-gt>2.0.53</version-gt>
<version-gt-eq>2.0.53</version-gt-eq>
</deb>
<dsc>
<version>2.0.53</version>
<version-lt>2.0.53</version-lt>
</dsc>
<rpm>
<version>2.0.53-0</version>
<version-lt>2.0.53-0</version-lt>
</rpm>
<srpm>
<version>2.0.53-0</version>
<version-lt>2.0.53-0</version-lt>
</srpm>
</contents>
</component>
EOF
cp a.xml b.xml
''')
desc = ComponentDescriptor('a.xml')
desc.write()
self.assert_equals_long(open('b.xml').read(), open('a.xml').read())
def test_load_sub_component_meta(self):
"""Be sure metadata gets loaded from subcomponents even if
the toplevel component has none.
"""
open('test1.xml', 'w').write('''<?xml version="1.0"?>
<component>
<contents>
<component>test2.xml</component>
</contents>
</component>
''')
open('test2.xml', 'w').write('''<?xml version="1.0"?>
<component>
<contents>
<deb ref="sha-1:aaa">
<meta>
<necessity>mandatory</necessity>
</meta>
</deb>
</contents>
</component>
''')
cache = ShamCache()
package = MockPackage('a', '1', deb, 'sha-1:aaa')
cache.add(package)
desc = ComponentDescriptor('test1.xml')
comp = desc.load(cache)
assert package in list(comp.iter_packages())
self.assert_equal("mandatory", package[('pdk', 'necessity')])
def test_write_relation(self):
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb>
<version>2.0.53</version>
<version-lt>2.0.53</version-lt>
<version-lt-eq>2.0.53</version-lt-eq>
<version-gt>2.0.53</version-gt>
<version-gt-eq>2.0.53</version-gt-eq>
</deb>
<dsc>
<version>2.0.53</version>
<version-lt>2.0.53</version-lt>
</dsc>
<rpm>
<version>2.0.53-0</version>
<version-lt>2.0.53-0</version-lt>
</rpm>
<srpm>
<version>2.0.53-0</version>
<version-lt>2.0.53-0</version-lt>
</srpm>
</contents>
</component>
EOF
cp a.xml b.xml
''')
desc = ComponentDescriptor('a.xml')
desc.write()
self.assert_equals_long(open('b.xml').read(), open('a.xml').read())
def test_self_reference(self):
os.system('''
cat >a.xml <<EOF
<component/>
''')
desc = ComponentDescriptor('a.xml')
ref = desc.get_self_reference()
self.assert_equal('a.xml', ref.filename)
self.assert_equal(rules.tc, ref.condition.__class__)
def test_self_reference(self):
os.system('''
cat >a.xml <<EOF
<component/>
''')
desc = ComponentDescriptor('a.xml')
ref = desc.get_self_reference()
self.assert_equal('a.xml', ref.filename)
self.assert_equal(rules.tc, ref.condition.__class__)
def test_load_empty(self):
"""compdesc.load returns an empty component"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component/>
EOF
''')
desc = ComponentDescriptor('a.xml')
descriptor = desc.load(None)
assert isinstance(descriptor, Component)
def test_load_empty(self):
"""compdesc.load returns an empty component"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component/>
EOF
''')
desc = ComponentDescriptor('a.xml')
descriptor = desc.load(None)
assert isinstance(descriptor, Component)
def test_build_bare_name_rule(self):
'''rules like <deb>name</deb> should have name conditions.
No metadata should be present.
'''
builder = ComponentDescriptor(None)
name_element = XML('<deb>some-name</deb>')
ref = builder.build_package_ref(name_element)
assert not ref.reference.blob_id
self.assert_equal('deb', ref.reference.package_type.type_string)
self.assert_rule_matches([('pdk', 'name', 'some-name'),
('pdk', 'type', 'deb')], [], [], ref.rule)
def test_load_and_use_star_cond(self):
"""compdesc.load returns a component with packages"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<dsc>
<name>apache</name>
<dsc ref="sha-1:ccc">
<name>apache</name>
</dsc>
<deb ref="sha-1:aaa">
<name>apache</name>
</deb>
<deb ref="sha-1:bbb">
<name>apache-common</name>
</deb>
</dsc>
<dsc>
<cond><![CDATA[ * apache (>=2) ]]></cond>
</dsc>
<src>
<cond><![CDATA[ * apache (>=2) ]]></cond>
</src>
<bin>
<cond><![CDATA[ * apache-common (>=2) ]]></cond>
</bin>
</contents>
</component>
EOF
cp a.xml b.xml
''')
desc = ComponentDescriptor('a.xml')
desc.write()
self.assert_equals_long(open('b.xml').read(), open('a.xml').read())
condition = desc.contents[1].rule.condition
a = MockPackage('apache', '2', deb, 'sha-1:aaa')
b = MockPackage('apache-commmon', '2', deb, 'sha-1:bbb')
c = MockPackage('apache', '2', dsc, 'sha-1:ccc')
a.complement = [c]
b.complement = [c]
c.complement = [a, b]
assert condition.evaluate(a)
assert condition.evaluate(b)
assert not condition.evaluate(c)
src_condition = desc.contents[2].rule.condition
assert src_condition.evaluate(a)
assert src_condition.evaluate(b)
assert not src_condition.evaluate(c)
def test_build_bare_name_rule(self):
'''rules like <deb>name</deb> should have name conditions.
No metadata should be present.
'''
builder = ComponentDescriptor(None)
name_element = XML('<deb>some-name</deb>')
ref = builder.build_package_ref(name_element)
assert not ref.reference.blob_id
self.assert_equal('deb', ref.reference.package_type.type_string)
self.assert_rule_matches([('pdk', 'name', 'some-name'),
('pdk', 'type', 'deb')],
[], [], ref.rule)
def test_load_and_use_star_cond(self):
"""compdesc.load returns a component with packages"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<dsc>
<name>apache</name>
<dsc ref="sha-1:ccc">
<name>apache</name>
</dsc>
<deb ref="sha-1:aaa">
<name>apache</name>
</deb>
<deb ref="sha-1:bbb">
<name>apache-common</name>
</deb>
</dsc>
<dsc>
<cond><![CDATA[ * apache (>=2) ]]></cond>
</dsc>
<src>
<cond><![CDATA[ * apache (>=2) ]]></cond>
</src>
<bin>
<cond><![CDATA[ * apache-common (>=2) ]]></cond>
</bin>
</contents>
</component>
EOF
cp a.xml b.xml
''')
desc = ComponentDescriptor('a.xml')
desc.write()
self.assert_equals_long(open('b.xml').read(), open('a.xml').read())
condition = desc.contents[1].rule.condition
a = MockPackage('apache', '2', deb, 'sha-1:aaa')
b = MockPackage('apache-commmon', '2', deb, 'sha-1:bbb')
c = MockPackage('apache', '2', dsc, 'sha-1:ccc')
a.complement = [c]
b.complement = [c]
c.complement = [a, b]
assert condition.evaluate(a)
assert condition.evaluate(b)
assert not condition.evaluate(c)
src_condition = desc.contents[2].rule.condition
assert src_condition.evaluate(a)
assert src_condition.evaluate(b)
assert not src_condition.evaluate(c)
def test_empty_meta_element(self):
open('test.xml', 'w').write('''<?xml version="1.0"?>
<component>
<meta/>
</component>
''')
desc = ComponentDescriptor('test.xml')
desc.write()
expected = '''<?xml version="1.0" encoding="utf-8"?>
<component>
</component>
'''
self.assert_equals_long(expected, open('test.xml').read())
def test_empty_meta_element(self):
open('test.xml', 'w').write('''<?xml version="1.0"?>
<component>
<meta/>
</component>
''')
desc = ComponentDescriptor('test.xml')
desc.write()
expected = '''<?xml version="1.0" encoding="utf-8"?>
<component>
</component>
'''
self.assert_equals_long(expected, open('test.xml').read())
def test_conditional_include(self):
os.system('''
cat >b.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb ref="sha-1:aaa">
<name>apache</name>
</deb>
<deb ref="sha-1:bbb">
<name>libc6</name>
</deb>
<deb ref="sha-1:ccc">
<name>ls</name>
</deb>
</contents>
</component>
EOF
''')
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<component>
<file>b.xml</file>
<limit>apache</limit>
<exclude>ls</exclude>
</component>
</contents>
</component>
EOF
cp a.xml c.xml
''')
apache = MockPackage('apache', '1', deb, 'sha-1:aaa',
arch = 'i386')
libc = MockPackage('libc6', '1', deb, 'sha-1:bbb', arch = 'i386')
ls = MockPackage('ls', '1', deb, 'sha-1:ccc', arch = 'i386')
cache = ShamCache()
cache.add(apache)
cache.add(libc)
cache.add(ls)
desc_a = ComponentDescriptor('a.xml')
desc_a.write()
self.assert_equals_long(open('c.xml').read(), open('a.xml').read())
component_a = desc_a.load(cache)
assert isinstance(component_a, Component)
expected = [ apache ]
actual = list(component_a.iter_packages())
self.assert_equal(expected, actual)
def test_conditional_include(self):
os.system('''
cat >b.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb ref="sha-1:aaa">
<name>apache</name>
</deb>
<deb ref="sha-1:bbb">
<name>libc6</name>
</deb>
<deb ref="sha-1:ccc">
<name>ls</name>
</deb>
</contents>
</component>
EOF
''')
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<component>
<file>b.xml</file>
<limit>apache</limit>
<exclude>ls</exclude>
</component>
</contents>
</component>
EOF
cp a.xml c.xml
''')
apache = MockPackage('apache', '1', deb, 'sha-1:aaa', arch='i386')
libc = MockPackage('libc6', '1', deb, 'sha-1:bbb', arch='i386')
ls = MockPackage('ls', '1', deb, 'sha-1:ccc', arch='i386')
cache = ShamCache()
cache.add(apache)
cache.add(libc)
cache.add(ls)
desc_a = ComponentDescriptor('a.xml')
desc_a.write()
self.assert_equals_long(open('c.xml').read(), open('a.xml').read())
component_a = desc_a.load(cache)
assert isinstance(component_a, Component)
expected = [apache]
actual = list(component_a.iter_packages())
self.assert_equal(expected, actual)
def test_meta_implicit_ref(self):
"""Check that implicit references in metadata are supported and
correctly resolve to references to self.
"""
open('test.xml', 'w').write('''<?xml version="1.0"?>
<component>
<meta>
<necessity>mandatory</necessity>
</meta>
</component>
''')
desc = ComponentDescriptor('test.xml')
comp = desc.load(Cache(os.path.join(self.work_dir, 'cache')))
self.assert_equal('mandatory', comp.meta[('pdk', 'necessity')])
def test_meta_implicit_ref(self):
"""Check that implicit references in metadata are supported and
correctly resolve to references to self.
"""
open('test.xml', 'w').write('''<?xml version="1.0"?>
<component>
<meta>
<necessity>mandatory</necessity>
</meta>
</component>
''')
desc = ComponentDescriptor('test.xml')
comp = desc.load(Cache(os.path.join(self.work_dir, 'cache')))
self.assert_equal('mandatory', comp.meta[('pdk', 'necessity')])
def test_dont_mutate_meta(self):
"""Make sure the load method does not mutate the meta info
in the descriptor.
"""
open('test.xml', 'w').write('''<?xml version="1.0"?>
<component>
<meta>
<predicate>object</predicate>
</meta>
<contents>
<dsc>
<name>a</name>
<meta>
<c>d</c>
</meta>
</dsc>
<deb ref="sha-1:aaa">
<meta>
<necessity>mandatory</necessity>
</meta>
</deb>
</contents>
</component>
''')
desc = ComponentDescriptor('test.xml')
cache = ShamCache()
cache.add(MockPackage('a', '1', deb, 'sha-1:aaa'))
desc.load(cache)
desc.write()
expected = '''<?xml version="1.0" encoding="utf-8"?>
<component>
<meta>
<predicate>object</predicate>
</meta>
<contents>
<dsc>
<name>a</name>
<meta>
<c>d</c>
</meta>
</dsc>
<deb ref="sha-1:aaa">
<meta>
<necessity>mandatory</necessity>
</meta>
</deb>
</contents>
</component>
'''
self.assert_equals_long(expected, open('test.xml').read())
def test_load_component_meta(self):
"""compdesc.load finds component metadata"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<meta>
<necessity>optional</necessity>
</meta>
</component>
EOF
''')
desc = ComponentDescriptor('a.xml')
component = desc.load(None)
self.assert_equals(component.meta['pdk', 'necessity'], 'optional')
def test_load_component_meta(self):
"""compdesc.load finds component metadata"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<meta>
<necessity>optional</necessity>
</meta>
</component>
EOF
''')
desc = ComponentDescriptor('a.xml')
component = desc.load(None)
self.assert_equals(component.meta['pdk', 'necessity'], 'optional')
def test_build_ref(self):
builder = ComponentDescriptor(None)
element = XML('''
<deb>
<name>hello</name>
<meta>
<ice>cube</ice>
</meta>
</deb>
''')
ref = builder.build_package_ref(element)
assert not ref.reference.blob_id
self.assert_equal('deb', ref.reference.package_type.type_string)
self.assert_rule_matches([('pdk', 'name', 'hello'),
('pdk', 'type', 'deb')],
[('pdk', 'ice', 'cube')], [], ref.rule)
def test_build_ref(self):
builder = ComponentDescriptor(None)
element = XML('''
<deb>
<name>hello</name>
<meta>
<ice>cube</ice>
</meta>
</deb>
''')
ref = builder.build_package_ref(element)
assert not ref.reference.blob_id
self.assert_equal('deb', ref.reference.package_type.type_string)
self.assert_rule_matches([('pdk', 'name', 'hello'),
('pdk', 'type', 'deb')],
[('pdk', 'ice', 'cube')], [], ref.rule)
def test_occupied_meta_element(self):
open('test.xml', 'w').write('''<?xml version="1.0"?>
<component>
<meta>
<key>value</key>
</meta>
<contents>
<deb ref="sha-1:aaa">
<meta>
<other-key>other-value</other-key>
<link>
<vuln>22</vuln>
</link>
<unlink>
<vuln>20</vuln>
</unlink>
</meta>
</deb>
</contents>
</component>
''')
desc = ComponentDescriptor('test.xml')
desc.write()
expected = '''<?xml version="1.0" encoding="utf-8"?>
<component>
<meta>
<key>value</key>
</meta>
<contents>
<deb ref="sha-1:aaa">
<meta>
<other-key>other-value</other-key>
<link>
<vuln>22</vuln>
</link>
<unlink>
<vuln>20</vuln>
</unlink>
</meta>
</deb>
</contents>
</component>
'''
self.assert_equals_long(expected, open('test.xml').read())
def test_occupied_meta_element(self):
open('test.xml', 'w').write('''<?xml version="1.0"?>
<component>
<meta>
<key>value</key>
</meta>
<contents>
<deb ref="sha-1:aaa">
<meta>
<other-key>other-value</other-key>
<link>
<vuln>22</vuln>
</link>
<unlink>
<vuln>20</vuln>
</unlink>
</meta>
</deb>
</contents>
</component>
''')
desc = ComponentDescriptor('test.xml')
desc.write()
expected = '''<?xml version="1.0" encoding="utf-8"?>
<component>
<meta>
<key>value</key>
</meta>
<contents>
<deb ref="sha-1:aaa">
<meta>
<other-key>other-value</other-key>
<link>
<vuln>22</vuln>
</link>
<unlink>
<vuln>20</vuln>
</unlink>
</meta>
</deb>
</contents>
</component>
'''
self.assert_equals_long(expected, open('test.xml').read())
def test_static_create(self):
desc = ComponentDescriptor.create('a.xml')
# As part of this test, make sure we call write, as the black magic
# might get fooled.
desc.write()
actual = open('a.xml').read()
expected = '''<?xml version="1.0" encoding="utf-8"?>
<component>
</component>
'''
self.assert_equals_long(expected, actual)
def test_iter_package_refs(self):
class MockRef(PackageStanza):
def __init__(self, label):
condition = rules.ac([('pdk', 'name', 'apache')])
PackageStanza.__init__(self, deb, None, condition, [])
self.label = label
self.children = []
def __repr__(self):
return str(self.label)
desc = ComponentDescriptor(None)
a = MockRef('a')
b = MockRef('b')
c = MockRef('c')
a.children = [b]
desc.contents = [a, c]
self.assert_equal([a, c], list(desc.iter_package_refs()))
self.assert_equal([a, b, c], list(desc.iter_full_package_refs()))
def test_iter_package_refs(self):
class MockRef(PackageStanza):
def __init__(self, label):
condition = rules.ac([('pdk', 'name', 'apache')])
PackageStanza.__init__(self, deb, None, condition, [])
self.label = label
self.children = []
def __repr__(self):
return str(self.label)
desc = ComponentDescriptor(None)
a = MockRef('a')
b = MockRef('b')
c = MockRef('c')
a.children = [b]
desc.contents = [ a, c ]
self.assert_equal([a, c], list(desc.iter_package_refs()))
self.assert_equal([a, b, c], list(desc.iter_full_package_refs()))
def test_static_create(self):
desc = ComponentDescriptor.create('a.xml')
# As part of this test, make sure we call write, as the black magic
# might get fooled.
desc.write()
actual = open('a.xml').read()
expected = '''<?xml version="1.0" encoding="utf-8"?>
<component>
</component>
'''
self.assert_equals_long(expected, actual)
def test_complement(self):
"""compdesc.load returns a component with packages"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb>
<deb ref="sha-1:aaa"/>
<deb ref="sha-1:bbb"/>
<dsc ref="sha-1:ccc"/>
</deb>
<dsc>
<dsc ref="sha-1:ccc"/>
<deb ref="sha-1:aaa"/>
<deb ref="sha-1:bbb"/>
<deb ref="sha-1:ddd"/>
</dsc>
</contents>
</component>
EOF
''')
desc = ComponentDescriptor('a.xml')
cache = ShamCache(make_copies = True)
a = MockPackage('a', '1', deb, 'sha-1:aaa', arch='i386')
b = MockPackage('b', '1', deb, 'sha-1:bbb', arch='i386')
c = MockPackage('c', '1', dsc, 'sha-1:ccc', arch='any')
d = MockPackage('b', '1', deb, 'sha-1:ddd', arch='i386')
cache.add(a)
cache.add(b)
cache.add(c)
cache.add(d)
component = desc.load(cache)
packages = list(component.iter_packages())
self.assert_equal([c], packages[0].complement)
self.assert_equal([c], packages[1].complement)
self.assert_equal([a, b], packages[2].complement)
self.assert_equal([a, b, d], packages[3].complement)
self.assert_equal([c], packages[4].complement)
self.assert_equal([c], packages[5].complement)
self.assert_equal([c], packages[6].complement)
def test_complement(self):
"""compdesc.load returns a component with packages"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb>
<deb ref="sha-1:aaa"/>
<deb ref="sha-1:bbb"/>
<dsc ref="sha-1:ccc"/>
</deb>
<dsc>
<dsc ref="sha-1:ccc"/>
<deb ref="sha-1:aaa"/>
<deb ref="sha-1:bbb"/>
<deb ref="sha-1:ddd"/>
</dsc>
</contents>
</component>
EOF
''')
desc = ComponentDescriptor('a.xml')
cache = ShamCache(make_copies=True)
a = MockPackage('a', '1', deb, 'sha-1:aaa', arch='i386')
b = MockPackage('b', '1', deb, 'sha-1:bbb', arch='i386')
c = MockPackage('c', '1', dsc, 'sha-1:ccc', arch='any')
d = MockPackage('b', '1', deb, 'sha-1:ddd', arch='i386')
cache.add(a)
cache.add(b)
cache.add(c)
cache.add(d)
component = desc.load(cache)
packages = list(component.iter_packages())
self.assert_equal([c], packages[0].complement)
self.assert_equal([c], packages[1].complement)
self.assert_equal([a, b], packages[2].complement)
self.assert_equal([a, b, d], packages[3].complement)
self.assert_equal([c], packages[4].complement)
self.assert_equal([c], packages[5].complement)
self.assert_equal([c], packages[6].complement)
def test_load_file_object(self):
"""compdesc.load returns a component with packages"""
handle = stringio('''<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb ref="sha-1:aaa"/>
</contents>
</component>
''')
desc = ComponentDescriptor('a.xml', handle)
cache = ShamCache()
cache.add(MockPackage('a', '1', deb, 'sha-1:aaa'))
component = desc.load(cache)
assert isinstance(component, Component)
self.assert_equal('a.xml', desc.filename)
self.assert_equal(1, len(list(component.iter_packages())))
self.assert_equal(1, len(list(component.iter_direct_packages())))
self.assert_equal(['sha-1:aaa'],
[ p.blob_id for p in component.iter_packages() ])
self.assert_equal(0, len(list(component.iter_direct_components())))
self.assert_equal(0, len(list(component.iter_components())))
def test_load_file_object(self):
"""compdesc.load returns a component with packages"""
handle = stringio('''<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb ref="sha-1:aaa"/>
</contents>
</component>
''')
desc = ComponentDescriptor('a.xml', handle)
cache = ShamCache()
cache.add(MockPackage('a', '1', deb, 'sha-1:aaa'))
component = desc.load(cache)
assert isinstance(component, Component)
self.assert_equal('a.xml', desc.filename)
self.assert_equal(1, len(list(component.iter_packages())))
self.assert_equal(1, len(list(component.iter_direct_packages())))
self.assert_equal(['sha-1:aaa'],
[p.blob_id for p in component.iter_packages()])
self.assert_equal(0, len(list(component.iter_direct_components())))
self.assert_equal(0, len(list(component.iter_components())))
def test_parse_entity(self):
'''Check that we can parse entities at all.'''
open('test.xml', 'w').write('''<?xml version="1.0"?>
<component>
<entities>
<some-ent id="can-do">
<a.name>hello</a.name>
<b.description>whodo whodo whodo</b.description>
</some-ent>
</entities>
</component>
''')
desc = ComponentDescriptor('test.xml')
entity1 = desc.entities[('some-ent', 'can-do')]
self.assert_equal('hello', entity1[('a', 'name')])
self.assert_equal('whodo whodo whodo', entity1[('b', 'description')])
cache = ShamCache()
comp = desc.load(cache)
entity2 = comp.entities[('some-ent', 'can-do')]
self.assert_equal('hello', entity2[('a', 'name')])
self.assert_equal('whodo whodo whodo', entity2[('b', 'description')])
def test_read_write_and_or(self):
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb>
<or>
<and>
<name>a</name>
<arch>b</arch>
</and>
<name>c</name>
</or>
<my.some>value</my.some>
</deb>
</contents>
</component>
EOF
cp a.xml b.xml
''')
desc = ComponentDescriptor('a.xml')
deb_ref = desc.contents[0]
expected = rules.ac([
rules.oc([
rules.ac([
rules.rc(eq, 'pdk', 'name', 'a'),
rules.rc(eq, 'pdk', 'arch', 'b')
]),
rules.rc(eq, 'pdk', 'name', 'c')
]),
rules.rc(eq, 'my', 'some', 'value')
])
expected = PhantomConditionWrapper(expected, deb, None)
self.assert_equals_long(expected, deb_ref.reference.condition)
desc.write()
self.assert_equals_long(open('b.xml').read(), open('a.xml').read())
def test_load(self):
"""compdesc.load returns a component with packages"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb ref="sha-1:aaa"/>
</contents>
</component>
EOF
''')
desc = ComponentDescriptor('a.xml')
cache = ShamCache()
cache.add(MockPackage('a', '1', deb, 'sha-1:aaa'))
component = desc.load(cache)
assert isinstance(component, Component)
self.assert_equal(1, len(list(component.iter_packages())))
self.assert_equal(1, len(list(component.iter_direct_packages())))
self.assert_equal(['sha-1:aaa'],
[ p.blob_id for p in component.iter_packages() ])
self.assert_equal(0, len(list(component.iter_direct_components())))
self.assert_equal(0, len(list(component.iter_components())))
def test_load(self):
"""compdesc.load returns a component with packages"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb ref="sha-1:aaa"/>
</contents>
</component>
EOF
''')
desc = ComponentDescriptor('a.xml')
cache = ShamCache()
cache.add(MockPackage('a', '1', deb, 'sha-1:aaa'))
component = desc.load(cache)
assert isinstance(component, Component)
self.assert_equal(1, len(list(component.iter_packages())))
self.assert_equal(1, len(list(component.iter_direct_packages())))
self.assert_equal(['sha-1:aaa'],
[p.blob_id for p in component.iter_packages()])
self.assert_equal(0, len(list(component.iter_direct_components())))
self.assert_equal(0, len(list(component.iter_components())))
def test_bad_comp_ref(self):
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<component>
<limit><![CDATA[ apache ]]></limit>
</component>
</contents>
</component>
EOF
''')
try:
ComponentDescriptor('a.xml').load(ShamCache())
self.fail('should have thrown exception')
except InputError:
pass
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<component>
<zzz></zzz>
<limit><![CDATA[ apache ]]></limit>
</component>
</contents>
</component>
EOF
''')
try:
ComponentDescriptor('a.xml').load(ShamCache())
self.fail('should have thrown exception')
except InputError, error:
assert '"zzz"' in str(error)
def test_parse_link(self):
'''Check that we can parse entities at all.'''
open('test.xml', 'w').write('''<?xml version="1.0"?>
<component>
<contents>
<deb ref="sha-1:aaa">
<meta>
<pdk.link>
<some-meta>can-do</some-meta>
</pdk.link>
</meta>
</deb>
</contents>
</component>
''')
desc = ComponentDescriptor('test.xml')
self.assert_equal([('some-meta', 'can-do')], desc.contents[0].links)
cache = ShamCache()
package = MockPackage('a', '1', deb, 'sha-1:aaa')
cache.add(package)
comp = desc.load(cache)
package = comp.iter_packages().next()
self.assert_equals([('some-meta', 'can-do')], package.links)
def test_parse_entity(self):
'''Check that we can parse entities at all.'''
open('test.xml', 'w').write('''<?xml version="1.0"?>
<component>
<entities>
<some-ent id="can-do">
<a.name>hello</a.name>
<b.description>whodo whodo whodo</b.description>
</some-ent>
</entities>
</component>
''')
desc = ComponentDescriptor('test.xml')
entity1 = desc.entities[('some-ent', 'can-do')]
self.assert_equal('hello', entity1[('a', 'name')])
self.assert_equal('whodo whodo whodo',
entity1[('b', 'description')])
cache = ShamCache()
comp = desc.load(cache)
entity2 = comp.entities[('some-ent', 'can-do')]
self.assert_equal('hello', entity2[('a', 'name')])
self.assert_equal('whodo whodo whodo',
entity2[('b', 'description')])
def test_is_package_ref(self):
builder = ComponentDescriptor(None)
deb_rule = Element('deb')
udeb_rule = Element('udeb')
dsc_rule = Element('dsc')
rpm_rule = Element('rpm')
srpm_rule = Element('srpm')
component_rule = Element('component')
assert builder.is_package_ref(deb_rule)
assert builder.is_package_ref(udeb_rule)
assert builder.is_package_ref(dsc_rule)
assert builder.is_package_ref(rpm_rule)
assert builder.is_package_ref(srpm_rule)
assert not builder.is_package_ref(component_rule)
def test_dont_mutate_meta(self):
"""Make sure the load method does not mutate the meta info
in the descriptor.
"""
open('test.xml', 'w').write('''<?xml version="1.0"?>
<component>
<meta>
<predicate>object</predicate>
</meta>
<contents>
<dsc>
<name>a</name>
<meta>
<c>d</c>
</meta>
</dsc>
<deb ref="sha-1:aaa">
<meta>
<necessity>mandatory</necessity>
</meta>
</deb>
</contents>
</component>
''')
desc = ComponentDescriptor('test.xml')
cache = ShamCache()
cache.add(MockPackage('a', '1', deb, 'sha-1:aaa'))
desc.load(cache)
desc.write()
expected = '''<?xml version="1.0" encoding="utf-8"?>
<component>
<meta>
<predicate>object</predicate>
</meta>
<contents>
<dsc>
<name>a</name>
<meta>
<c>d</c>
</meta>
</dsc>
<deb ref="sha-1:aaa">
<meta>
<necessity>mandatory</necessity>
</meta>
</deb>
</contents>
</component>
'''
self.assert_equals_long(expected, open('test.xml').read())
def test_is_package_ref(self):
builder = ComponentDescriptor(None)
deb_rule = Element('deb')
udeb_rule = Element('udeb')
dsc_rule = Element('dsc')
rpm_rule = Element('rpm')
srpm_rule = Element('srpm')
component_rule = Element('component')
assert builder.is_package_ref(deb_rule)
assert builder.is_package_ref(udeb_rule)
assert builder.is_package_ref(dsc_rule)
assert builder.is_package_ref(rpm_rule)
assert builder.is_package_ref(srpm_rule)
assert not builder.is_package_ref(component_rule)
def test_load_multilevel(self):
"""test loading a component that refers to another"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb>
<name>libc6</name>
<meta>
<necessity>mandatory</necessity>
</meta>
</deb>
<deb>
<name>apache</name>
<meta>
<necessity>default</necessity>
</meta>
</deb>
<component>b.xml</component>
</contents>
</component>
EOF
''')
os.system('''
cat >b.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb>
<name>libc6</name>
<meta>
<necessity>optional</necessity>
</meta>
</deb>
<deb ref="sha-1:aaa">
<name>apache</name>
<meta>
<necessity>optional</necessity>
</meta>
</deb>
<component>c.xml</component>
</contents>
</component>
EOF
''')
os.system('''
cat >c.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb ref="sha-1:bbb">
<name>libc6</name>
<meta>
<necessity>mandatory</necessity>
<some-random-key>42</some-random-key>
</meta>
</deb>
</contents>
</component>
EOF
''')
apache = MockPackage('apache', '1', deb, 'sha-1:aaa')
libc = MockPackage('libc6', '1', deb, 'sha-1:bbb')
cache = ShamCache()
cache.add(apache)
cache.add(libc)
desc_b = ComponentDescriptor('b.xml')
component_b = desc_b.load(cache)
assert isinstance(component_b, Component)
self.assert_equal('b.xml', desc_b.filename)
self.assert_equal('b.xml', component_b.ref)
self.assert_equal(2, len(list(component_b.iter_packages())))
self.assert_equal(['sha-1:aaa', 'sha-1:bbb'],
[p.blob_id for p in component_b.iter_packages()])
self.assert_equal(1, len(list(component_b.iter_direct_packages())))
self.assert_equal(1, len(list(component_b.iter_direct_components())))
self.assert_equal(1, len(list(component_b.iter_components())))
self.assert_equal('optional', libc['pdk', 'necessity'])
self.assert_equal('optional', apache['pdk', 'necessity'])
apache = MockPackage('apache', '1', deb, 'sha-1:aaa')
libc = MockPackage('libc6', '1', deb, 'sha-1:bbb')
cache = ShamCache()
cache.add(apache)
cache.add(libc)
desc_a = ComponentDescriptor('a.xml')
component_a = desc_a.load(cache)
assert isinstance(component_a, Component)
self.assert_equal(2, len(list(component_a.iter_packages())))
self.assert_equal(['sha-1:aaa', 'sha-1:bbb'],
[p.blob_id for p in component_a.iter_packages()])
self.assert_equal(0, len(list(component_a.iter_direct_packages())))
self.assert_equal(1, len(list(component_a.iter_direct_components())))
self.assert_equal(2, len(list(component_a.iter_components())))
self.assert_equal('mandatory', libc['pdk', 'necessity'])
self.assert_equal('default', apache['pdk', 'necessity'])
self.assert_equal('42', libc['pdk', 'some-random-key'])
def audit(args):
"""\\fB%prog\\fP
.PP
Load the component,
and verify that it and it's parts are well-formed.
"""
##specialization code starts here
def note_problem(fact, prediction, prediction_basis,
evidence, evidence_basis):
"""A mismatch handler for Arbiter
Handle the case of a prediction that doesn't pan out
by reporting the mismatch to stdout, in a format
suitable for: cut -d'|'
"""
note_problem.called = True
fields = fact.get_problem_description(prediction, prediction_basis,
evidence, evidence_basis)
result = string_together(fields, '|')
print result
note_problem.called = False
my_cache = workspace.current_workspace().cache
arbiter = Arbiter(note_problem)
for component_name in args.args:
def _note_blob_id(blob_id):
"""Make common predictions and warrants for blob_id.
Predict that a blob_id will be in cache
Warrant the blob_id will be needed by the component.
"""
arbiter.predict(InCache(blob_id), True, component_name)
# Get the set of packages in the component
descriptor = ComponentDescriptor(component_name)
component = descriptor.load(my_cache)
# predict expected blob_ids and headers
for package in component.iter_packages():
_note_blob_id(package.blob_id)
arbiter.predict(InCache(package.blob_id + '.header'),
True, component_name)
for package_tuple in package.extra_files:
blob_id = package_tuple[0]
_note_blob_id(blob_id)
# predict upcoming source packages
for package in component.iter_packages():
if package.role == 'binary':
fact = HasSource(package.format, package.pdk.sp_name,
package.pdk.sp_version.full_version)
arbiter.predict(fact, True, component_name)
# warrant source packages found
for package in component.iter_packages():
if package.role == 'source':
fact = HasSource(package.format, package.name,
package.version.full_version)
arbiter.warrant(fact, True, component_name)
# predict upcoming cache checksums
# pre-warrant found inodes
# note inode -> filename relationships for later
found_by_inode = {}
for blob_id in my_cache:
inode = my_cache.get_inode(blob_id)
if blob_id.endswith('.header'):
arbiter.warrant(InCache(blob_id), True, 'cache')
continue
entry = found_by_inode.setdefault(inode, Set([]))
entry.add(blob_id)
# ? Won't this create repeated predictions?
for blob_id in found_by_inode[inode]:
arbiter.predict(ChecksumMatches(blob_id), blob_id, 'cache')
for inode, blob_ids in found_by_inode.iteritems():
for blob_id in blob_ids:
arbiter.warrant(InCache(blob_id), True, 'cache')
# warrant cache checksums
one_id = tuple(blob_ids)[0]
handle = open(my_cache.file_path(one_id))
sha1_digest = sha.new()
md5_digest = md5.new()
read_size = 8196
while 1:
block = handle.read(read_size)
if not block:
break
sha1_digest.update(block)
md5_digest.update(block)
handle.close()
prefixes = []
for blob_id in blob_ids:
if blob_id.startswith('sha-1'):
prefixes.append('sha-1')
arbiter.warrant(ChecksumMatches(blob_id),
'sha-1:' + sha1_digest.hexdigest(),
'cache')
elif blob_id.startswith('md5'):
prefixes.append('md5')
arbiter.warrant(ChecksumMatches(blob_id),
'md5:' + md5_digest.hexdigest(), 'cache')
else:
# note unknown prefixes
arbiter.note_problem(
blob_id
, ('md5:', 'sha-1:')
, 'unknown prefix'
)
prefixes.sort()
if prefixes != ['md5', 'sha-1']:
digests = (md5_digest.hexdigest(), sha1_digest.hexdigest())
arbiter.note_problem(tuple(blob_ids), digests,
'not hard linked properly')
arbiter.note_leftovers()
if note_problem.called:
raise IntegrityFault, "Audit detected fault(s)"
def audit(args):
"""\\fB%prog\\fP
.PP
Load the component,
and verify that it and it's parts are well-formed.
"""
##specialization code starts here
def note_problem(fact, prediction, prediction_basis, evidence,
evidence_basis):
"""A mismatch handler for Arbiter
Handle the case of a prediction that doesn't pan out
by reporting the mismatch to stdout, in a format
suitable for: cut -d'|'
"""
note_problem.called = True
fields = fact.get_problem_description(prediction, prediction_basis,
evidence, evidence_basis)
result = string_together(fields, '|')
print result
note_problem.called = False
my_cache = workspace.current_workspace().cache
arbiter = Arbiter(note_problem)
for component_name in args.args:
def _note_blob_id(blob_id):
"""Make common predictions and warrants for blob_id.
Predict that a blob_id will be in cache
Warrant the blob_id will be needed by the component.
"""
arbiter.predict(InCache(blob_id), True, component_name)
# Get the set of packages in the component
descriptor = ComponentDescriptor(component_name)
component = descriptor.load(my_cache)
# predict expected blob_ids and headers
for package in component.iter_packages():
_note_blob_id(package.blob_id)
arbiter.predict(InCache(package.blob_id + '.header'), True,
component_name)
for package_tuple in package.extra_files:
blob_id = package_tuple[0]
_note_blob_id(blob_id)
# predict upcoming source packages
for package in component.iter_packages():
if package.role == 'binary':
fact = HasSource(package.format, package.pdk.sp_name,
package.pdk.sp_version.full_version)
arbiter.predict(fact, True, component_name)
# warrant source packages found
for package in component.iter_packages():
if package.role == 'source':
fact = HasSource(package.format, package.name,
package.version.full_version)
arbiter.warrant(fact, True, component_name)
# predict upcoming cache checksums
# pre-warrant found inodes
# note inode -> filename relationships for later
found_by_inode = {}
for blob_id in my_cache:
inode = my_cache.get_inode(blob_id)
if blob_id.endswith('.header'):
arbiter.warrant(InCache(blob_id), True, 'cache')
continue
entry = found_by_inode.setdefault(inode, Set([]))
entry.add(blob_id)
# ? Won't this create repeated predictions?
for blob_id in found_by_inode[inode]:
arbiter.predict(ChecksumMatches(blob_id), blob_id, 'cache')
for inode, blob_ids in found_by_inode.iteritems():
for blob_id in blob_ids:
arbiter.warrant(InCache(blob_id), True, 'cache')
# warrant cache checksums
one_id = tuple(blob_ids)[0]
handle = open(my_cache.file_path(one_id))
sha1_digest = sha.new()
md5_digest = md5.new()
read_size = 8196
while 1:
block = handle.read(read_size)
if not block:
break
sha1_digest.update(block)
md5_digest.update(block)
handle.close()
prefixes = []
for blob_id in blob_ids:
if blob_id.startswith('sha-1'):
prefixes.append('sha-1')
arbiter.warrant(ChecksumMatches(blob_id),
'sha-1:' + sha1_digest.hexdigest(), 'cache')
elif blob_id.startswith('md5'):
prefixes.append('md5')
arbiter.warrant(ChecksumMatches(blob_id),
'md5:' + md5_digest.hexdigest(), 'cache')
else:
# note unknown prefixes
arbiter.note_problem(blob_id, ('md5:', 'sha-1:'),
'unknown prefix')
prefixes.sort()
if prefixes != ['md5', 'sha-1']:
digests = (md5_digest.hexdigest(), sha1_digest.hexdigest())
arbiter.note_problem(tuple(blob_ids), digests,
'not hard linked properly')
arbiter.note_leftovers()
if note_problem.called:
raise IntegrityFault, "Audit detected fault(s)"
def test_dont_lose_entities(self):
"""Make sure the write method handles entities."""
open('test.xml', 'w').write('''<?xml version="1.0"?>
<component>
<meta>
<predicate>object</predicate>
</meta>
<contents>
<dsc>
<name>a</name>
<meta>
<c>d</c>
</meta>
</dsc>
<deb ref="sha-1:aaa">
<meta>
<necessity>mandatory</necessity>
</meta>
</deb>
</contents>
<entities>
<test id="1">
<a>b</a>
<c>d</c>
<e>f</e>
</test>
</entities>
</component>
''')
desc = ComponentDescriptor('test.xml')
cache = ShamCache()
cache.add(MockPackage('a', '1', deb, 'sha-1:aaa'))
desc.load(cache)
desc.write()
expected = '''<?xml version="1.0" encoding="utf-8"?>
<component>
<meta>
<predicate>object</predicate>
</meta>
<contents>
<dsc>
<name>a</name>
<meta>
<c>d</c>
</meta>
</dsc>
<deb ref="sha-1:aaa">
<meta>
<necessity>mandatory</necessity>
</meta>
</deb>
</contents>
<entities>
<test id="1">
<a>b</a>
<c>d</c>
<e>f</e>
</test>
</entities>
</component>
'''
self.assert_equals_long(expected, open('test.xml').read())
def test_read_relation_condition(self):
os.system('''
cat >a.xml <<EOF
<component>
<contents>
<deb>
<version>2.0.53</version>
<version-lt>2.0.53</version-lt>
<version-lt-eq>2.0.53</version-lt-eq>
<version-gt>2.0.53</version-gt>
<version-gt-eq>2.0.53</version-gt-eq>
</deb>
<dsc>
<version>2.0.53</version>
<version-lt>2.0.53</version-lt>
</dsc>
<rpm>
<version>2.0.53</version>
<version-lt>2.0.53</version-lt>
</rpm>
<srpm>
<version>2.0.53</version>
<version-lt>2.0.53</version-lt>
</srpm>
</contents>
</component>
EOF
''')
desc = ComponentDescriptor('a.xml')
deb_conditions = desc.contents[0].reference.condition.conditions
dv = DebianVersion
self.assert_equal(rules.rc(eq, 'pdk', 'version', dv('2.0.53')),
deb_conditions[0])
assert isinstance(deb_conditions[0].target, DebianVersion)
self.assert_equal(rules.rc(lt, 'pdk', 'version', dv('2.0.53')),
deb_conditions[1])
assert isinstance(deb_conditions[1].target, DebianVersion)
self.assert_equal(rules.rc(le, 'pdk', 'version', dv('2.0.53')),
deb_conditions[2])
assert isinstance(deb_conditions[2].target, DebianVersion)
self.assert_equal(rules.rc(gt, 'pdk', 'version', dv('2.0.53')),
deb_conditions[3])
assert isinstance(deb_conditions[3].target, DebianVersion)
self.assert_equal(rules.rc(ge, 'pdk', 'version', dv('2.0.53')),
deb_conditions[4])
assert isinstance(deb_conditions[4].target, DebianVersion)
dsc_conditions = desc.contents[1].reference.condition.conditions
self.assert_equal(rules.rc(eq, 'pdk', 'version', dv('2.0.53')),
dsc_conditions[0])
assert isinstance(dsc_conditions[0].target, DebianVersion)
self.assert_equal(rules.rc(lt, 'pdk', 'version', dv('2.0.53')),
dsc_conditions[1])
assert isinstance(dsc_conditions[1].target, DebianVersion)
def rv(version):
return RPMVersion(version_string=version)
rpm_conditions = desc.contents[2].reference.condition.conditions
self.assert_equal(rules.rc(eq, 'pdk', 'version', rv('2.0.53')),
rpm_conditions[0])
assert isinstance(rpm_conditions[0].target, RPMVersion)
self.assert_equal(rules.rc(lt, 'pdk', 'version', rv('2.0.53')),
rpm_conditions[1])
assert isinstance(rpm_conditions[1].target, RPMVersion)
srpm_conditions = desc.contents[3].reference.condition.conditions
self.assert_equal(rules.rc(eq, 'pdk', 'version', rv('2.0.53')),
srpm_conditions[0])
assert isinstance(srpm_conditions[0].target, RPMVersion)
self.assert_equal(rules.rc(lt, 'pdk', 'version', rv('2.0.53')),
srpm_conditions[1])
assert isinstance(srpm_conditions[1].target, RPMVersion)
def test_load_multilevel(self):
"""test loading a component that refers to another"""
os.system('''
cat >a.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb>
<name>libc6</name>
<meta>
<necessity>mandatory</necessity>
</meta>
</deb>
<deb>
<name>apache</name>
<meta>
<necessity>default</necessity>
</meta>
</deb>
<component>b.xml</component>
</contents>
</component>
EOF
''')
os.system('''
cat >b.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb>
<name>libc6</name>
<meta>
<necessity>optional</necessity>
</meta>
</deb>
<deb ref="sha-1:aaa">
<name>apache</name>
<meta>
<necessity>optional</necessity>
</meta>
</deb>
<component>c.xml</component>
</contents>
</component>
EOF
''')
os.system('''
cat >c.xml <<EOF
<?xml version="1.0" encoding="utf-8"?>
<component>
<contents>
<deb ref="sha-1:bbb">
<name>libc6</name>
<meta>
<necessity>mandatory</necessity>
<some-random-key>42</some-random-key>
</meta>
</deb>
</contents>
</component>
EOF
''')
apache = MockPackage('apache', '1', deb,'sha-1:aaa')
libc = MockPackage('libc6', '1', deb, 'sha-1:bbb')
cache = ShamCache()
cache.add(apache)
cache.add(libc)
desc_b = ComponentDescriptor('b.xml')
component_b = desc_b.load(cache)
assert isinstance(component_b, Component)
self.assert_equal('b.xml', desc_b.filename)
self.assert_equal('b.xml', component_b.ref)
self.assert_equal(2, len(list(component_b.iter_packages())))
self.assert_equal(['sha-1:aaa', 'sha-1:bbb'],
[ p.blob_id
for p in component_b.iter_packages() ])
self.assert_equal(1, len(list(component_b.iter_direct_packages())))
self.assert_equal(1,
len(list(component_b.iter_direct_components())))
self.assert_equal(1, len(list(component_b.iter_components())))
self.assert_equal('optional',
libc['pdk', 'necessity'])
self.assert_equal('optional',
apache['pdk', 'necessity'])
apache = MockPackage('apache', '1', deb,'sha-1:aaa')
libc = MockPackage('libc6', '1', deb, 'sha-1:bbb')
cache = ShamCache()
cache.add(apache)
cache.add(libc)
desc_a = ComponentDescriptor('a.xml')
component_a = desc_a.load(cache)
assert isinstance(component_a, Component)
self.assert_equal(2, len(list(component_a.iter_packages())))
self.assert_equal(['sha-1:aaa', 'sha-1:bbb'],
[ p.blob_id
for p in component_a.iter_packages() ])
self.assert_equal(0, len(list(component_a.iter_direct_packages())))
self.assert_equal(1,
len(list(component_a.iter_direct_components())))
self.assert_equal(2, len(list(component_a.iter_components())))
self.assert_equal('mandatory', libc['pdk', 'necessity'])
self.assert_equal('default', apache['pdk', 'necessity'])
self.assert_equal('42', libc['pdk', 'some-random-key'])
def test_dont_lose_entities(self):
"""Make sure the write method handles entities."""
open('test.xml', 'w').write('''<?xml version="1.0"?>
<component>
<meta>
<predicate>object</predicate>
</meta>
<contents>
<dsc>
<name>a</name>
<meta>
<c>d</c>
</meta>
</dsc>
<deb ref="sha-1:aaa">
<meta>
<necessity>mandatory</necessity>
</meta>
</deb>
</contents>
<entities>
<test id="1">
<a>b</a>
<c>d</c>
<e>f</e>
</test>
</entities>
</component>
''')
desc = ComponentDescriptor('test.xml')
cache = ShamCache()
cache.add(MockPackage('a', '1', deb, 'sha-1:aaa'))
desc.load(cache)
desc.write()
expected = '''<?xml version="1.0" encoding="utf-8"?>
<component>
<meta>
<predicate>object</predicate>
</meta>
<contents>
<dsc>
<name>a</name>
<meta>
<c>d</c>
</meta>
</dsc>
<deb ref="sha-1:aaa">
<meta>
<necessity>mandatory</necessity>
</meta>
</deb>
</contents>
<entities>
<test id="1">
<a>b</a>
<c>d</c>
<e>f</e>
</test>
</entities>
</component>
'''
self.assert_equals_long(expected, open('test.xml').read())
