def test_name_version(self): actual = compile_debish('apache (=2.0-1)', deb, None) expected = ac([rc(eq, 'pdk', 'name', 'apache'), rc(eq, 'pdk', 'version', DebianVersion('2.0-1'))]) wrapper = ac([expected, rc(eq, 'pdk', 'type', 'deb')]) self.assert_equals(wrapper, actual)
def test_untyped_version(self): actual = compile_debish('apache (=2.0-1)', None, None) expected = ac([ rc(eq, 'pdk', 'name', 'apache'), rc(eq, 'pdk', 'version', '2.0-1') ]) self.assert_equals(expected, actual)
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_or(self): actual = compile_debish('apache | apache2', None, None) expected = oc([ ac([rc(eq, 'pdk', 'name', 'apache')]), ac([rc(eq, 'pdk', 'name', 'apache2')]) ]) self.assert_equals(expected, actual)
def test_relation_condition(self): first = rules.rc(ge, 'a', 'b', 'c') same_as_first = rules.rc(ge, 'a', 'b', 'c') second = rules.rc(ge, 'd', 'e', 'f') assert first == same_as_first assert second != first assert hash(first) == hash(same_as_first)
def test_name_version(self): actual = compile_debish('apache (=2.0-1)', deb, None) expected = ac([ rc(eq, 'pdk', 'name', 'apache'), rc(eq, 'pdk', 'version', DebianVersion('2.0-1')) ]) wrapper = ac([expected, rc(eq, 'pdk', 'type', 'deb')]) self.assert_equals(wrapper, actual)
def test_term_with_blob_id(self): actual = compile_debish('apache (=2.0-1)', deb, 'sha-1:aaa') expected = ac([rc(eq, 'pdk', 'name', 'apache'), rc(eq, 'pdk', 'version', DebianVersion('2.0-1'))]) wrapper = ac([rc(eq, 'pdk', 'blob-id', 'sha-1:aaa'), expected, rc(eq, 'pdk', 'type', 'deb')]) self.assert_equals(wrapper, actual)
def test_not_arch(self): actual = compile_debish('apache [!i386 !amd64]', deb, None) expected = ac([rc(eq, 'pdk', 'name', 'apache'), notc(oc([rc(eq, 'deb', 'arch', 'i386'), rc(eq, 'deb', 'arch', 'amd64')]))]) wrapper = ac([expected, rc(eq, 'pdk', 'type', 'deb')]) self.assert_equals(wrapper, actual)
def test_get_srpm_child_condition(self): version = RPMVersion(version_string='1-2') apache_srpm = MockPackage('apache', version, srpm, 'sha-1:aaa') expected = rules.ac([ rules.rc(eq, 'pdk', 'source-rpm', 'apache-1-2.src.rpm'), rules.rc(eq, 'pdk', 'type', 'rpm') ]) self.assert_equals(expected, get_srpm_child_condition(apache_srpm))
def test_name_arch(self): actual = compile_debish('apache [i386 amd64]', deb, None) expected = ac([ rc(eq, 'pdk', 'name', 'apache'), oc([rc(eq, 'deb', 'arch', 'i386'), rc(eq, 'deb', 'arch', 'amd64')]) ]) wrapper = ac([expected, rc(eq, 'pdk', 'type', 'deb')]) self.assert_equals(wrapper, actual)
def test_get_srpm_child_condition(self): version = RPMVersion(version_string = '1-2') apache_srpm = MockPackage('apache', version, srpm, 'sha-1:aaa') expected = rules.ac([ rules.rc(eq, 'pdk', 'source-rpm', 'apache-1-2.src.rpm'), rules.rc(eq, 'pdk', 'type', 'rpm') ]) self.assert_equals(expected, get_srpm_child_condition(apache_srpm))
def test_name_other(self): actual = compile_debish('apache {a:b = c dd:ee>=fgh i=j}', deb, None) expected = ac([rc(eq, 'pdk', 'name', 'apache'), ac([rc(eq, 'a', 'b', 'c'), rc(ge, 'dd', 'ee', 'fgh'), rc(eq, 'pdk', 'i', 'j')])]) wrapper = ac([expected, rc(eq, 'pdk', 'type', 'deb')]) self.assert_equals(wrapper, actual)
def test_term_with_blob_id(self): actual = compile_debish('apache (=2.0-1)', deb, 'sha-1:aaa') expected = ac([ rc(eq, 'pdk', 'name', 'apache'), rc(eq, 'pdk', 'version', DebianVersion('2.0-1')) ]) wrapper = ac([ rc(eq, 'pdk', 'blob-id', 'sha-1:aaa'), expected, rc(eq, 'pdk', 'type', 'deb') ]) self.assert_equals(wrapper, actual)
def test_get_rpm_child_condition(self): version = RPMVersion(version_string = '1-2') extras = {('pdk', 'source-rpm'): 'apache.src.rpm'} apache_rpm = MockPackage('apache', version, rpm, 'sha-1:aaa', extras = extras) expected = rules.ac([ rules.rc(eq, 'pdk', 'filename', 'apache.src.rpm'), rules.rc(eq, 'pdk', 'type', 'srpm') ]) self.assert_equals(expected, get_rpm_child_condition(apache_rpm))
def test_get_dsc_child_condition(self): version = DebianVersion('1-2') apache_dsc = MockPackage('apache', version, dsc, 'sha-1:aaa') type_condition = rules.oc([ rules.rc(eq, 'pdk', 'type', 'deb'), rules.rc(eq, 'pdk', 'type', 'udeb')]) expected = rules.ac([ rules.rc(eq, 'pdk', 'sp-name', 'apache'), rules.rc(eq, 'pdk', 'sp-version', '1-2'), type_condition ]) self.assert_equals(expected, get_dsc_child_condition(apache_dsc))
def test_get_deb_child_condition(self): sp_version = DebianVersion('1-2') extra = {('pdk', 'sp-name'): 'one', ('pdk', 'sp-version'): sp_version} apache_deb = MockPackage('apache', '1', deb, 'sha-1:aaa', extra) expected = rules.ac([ rules.rc(eq, 'pdk', 'name', 'one'), rules.rc(eq, 'pdk', 'version', '1-2'), rules.rc(eq, 'pdk', 'type', 'dsc') ]) self.assert_equals(expected, get_deb_child_condition(apache_deb))
def test_name_other(self): actual = compile_debish('apache {a:b = c dd:ee>=fgh i=j}', deb, None) expected = ac([ rc(eq, 'pdk', 'name', 'apache'), ac([ rc(eq, 'a', 'b', 'c'), rc(ge, 'dd', 'ee', 'fgh'), rc(eq, 'pdk', 'i', 'j') ]) ]) wrapper = ac([expected, rc(eq, 'pdk', 'type', 'deb')]) self.assert_equals(wrapper, actual)
def test_get_dsc_child_condition(self): version = DebianVersion('1-2') apache_dsc = MockPackage('apache', version, dsc, 'sha-1:aaa') type_condition = rules.oc([ rules.rc(eq, 'pdk', 'type', 'deb'), rules.rc(eq, 'pdk', 'type', 'udeb') ]) expected = rules.ac([ rules.rc(eq, 'pdk', 'sp-name', 'apache'), rules.rc(eq, 'pdk', 'sp-version', '1-2'), type_condition ]) self.assert_equals(expected, get_dsc_child_condition(apache_dsc))
def test_get_rpm_child_condition(self): version = RPMVersion(version_string='1-2') extras = {('pdk', 'source-rpm'): 'apache.src.rpm'} apache_rpm = MockPackage('apache', version, rpm, 'sha-1:aaa', extras=extras) expected = rules.ac([ rules.rc(eq, 'pdk', 'filename', 'apache.src.rpm'), rules.rc(eq, 'pdk', 'type', 'srpm') ]) self.assert_equals(expected, get_rpm_child_condition(apache_rpm))
def test_star(self): condition = rules.starc(rules.rc(eq, 'pdk', 'name', 'c')) assert condition.evaluate(self.a1) assert not condition.evaluate(self.a2) assert not condition.evaluate(self.b1) assert not condition.evaluate(self.c) assert not condition.evaluate(None)
def set_up(self): super(ConditionsAndRulesFixture, self).set_up() self.name_condition = rules.rc(eq, 'pdk', 'name', 'a') self.version_condition = rules.rc(eq, 'pdk', 'version', '1') self.and_condition = rules.ac( [self.name_condition, self.version_condition]) self.or_condition = rules.oc( [self.name_condition, self.version_condition]) self.a1 = MockPackage('a', '1', deb) self.a2 = MockPackage('a', '2', deb) self.b1 = MockPackage('b', '1', deb) self.b2 = MockPackage('b', '2', deb) self.c = MockPackage('c', '1', dsc, lang='de') self.d = MockPackage('d', '1', dsc, lang='en') self.a1.complement.append(self.c) self.a2.complement.append(self.d)
def set_up(self): super(ConditionsAndRulesFixture, self).set_up() self.name_condition = rules.rc(eq, 'pdk', 'name', 'a') self.version_condition = rules.rc(eq, 'pdk', 'version', '1') self.and_condition = rules.ac([self.name_condition, self.version_condition]) self.or_condition = rules.oc([self.name_condition, self.version_condition]) self.a1 = MockPackage('a', '1', deb) self.a2 = MockPackage('a', '2', deb) self.b1 = MockPackage('b', '1', deb) self.b2 = MockPackage('b', '2', deb) self.c = MockPackage('c', '1', dsc, lang = 'de') self.d = MockPackage('d', '1', dsc, lang = 'en') self.a1.complement.append(self.c) self.a2.complement.append(self.d)
def test_get_general_condition(self): version = DebianVersion('1-2') apache_dsc = MockPackage('apache', version, dsc, 'sha-1:aaa') sp_version = DebianVersion('1-2') extra = {('pdk', 'sp-name'): 'one', ('pdk', 'sp-version'): sp_version, ('deb', 'arch'): 'i386'} apache_deb = MockPackage('apache', '1-2', deb, 'sha-1:aaa', extra) expected = rules.ac([ rules.rc(eq, 'pdk', 'name', 'apache'), rules.rc(eq, 'pdk', 'version', version) ]) self.assert_equals(expected, get_general_condition(apache_dsc)) expected = rules.ac([ rules.rc(eq, 'pdk', 'name', 'apache'), rules.rc(eq, 'pdk', 'version', version), rules.rc(eq, 'pdk', 'arch', 'i386') ]) self.assert_equals(expected, get_general_condition(apache_deb))
def test_field_lookups(self): condition = rules.ac([rules.rc(eq, 'pdk', 'name', 'apache')]) ref = PackageStanza(deb, 'sha-1:aaa', condition, []) assert ('pdk', 'name') in ref assert ('pdk', 'version') not in ref self.assert_equal('apache', ref[('pdk', 'name')]) self.assert_equal('apache', ref.name) self.assert_equal('', ref.version) self.assert_equal('', ref.arch)
def wrap_condition(self, condition): '''Wrap the condition to verify the package_type and blob_id. Return the original condition of neither are given. ''' if self.blob_id or self.package_type: wrapper = ac([]) conditions = wrapper.conditions if self.blob_id: conditions.append(rc(eq, 'pdk', 'blob-id', self.blob_id)) conditions.append(condition) if self.package_type: if self.package_type.format_string == 'unknown': role_string = self.package_type.role_string conditions.append(rc(eq, 'pdk', 'role', role_string)) else: type_string = self.package_type.type_string conditions.append(rc(eq, 'pdk', 'type', type_string)) return wrapper else: return condition
def test_get_child_condition(self): sp_version = DebianVersion('1-3') extra = {('pdk', 'sp-name'): 'apache', ('pdk', 'sp-version'): sp_version, ('deb', 'arch'): 'i386'} apache_deb = MockPackage('apache', '1-2', deb, 'sha-1:aaa', extra) ref_condition = rules.ac([rules.rc(eq, 'pdk', 'name', 'apache')]) apache_ref = PackageStanza(deb, 'sha-1:aaa', ref_condition, []) parent_condition = rules.ac([ apache_ref.reference.condition, rules.rc(eq, 'pdk', 'version', DebianVersion('1-2')) ]) child_condition = get_deb_child_condition(apache_deb) expected_rule = rules.oc([child_condition, parent_condition]) expected_key_info = ('pdk', 'name', 'apache') actual_rule, actual_key_info = get_child_condition(apache_deb, apache_ref) self.assert_equals(expected_rule, actual_rule) self.assert_equals(expected_key_info, actual_key_info)
def test_get_child_condition(self): sp_version = DebianVersion('1-3') extra = { ('pdk', 'sp-name'): 'apache', ('pdk', 'sp-version'): sp_version, ('deb', 'arch'): 'i386' } apache_deb = MockPackage('apache', '1-2', deb, 'sha-1:aaa', extra) ref_condition = rules.ac([rules.rc(eq, 'pdk', 'name', 'apache')]) apache_ref = PackageStanza(deb, 'sha-1:aaa', ref_condition, []) parent_condition = rules.ac([ apache_ref.reference.condition, rules.rc(eq, 'pdk', 'version', DebianVersion('1-2')) ]) child_condition = get_deb_child_condition(apache_deb) expected_rule = rules.oc([child_condition, parent_condition]) expected_key_info = ('pdk', 'name', 'apache') actual_rule, actual_key_info = get_child_condition( apache_deb, apache_ref) self.assert_equals(expected_rule, actual_rule) self.assert_equals(expected_key_info, actual_key_info)
def test_get_general_condition(self): version = DebianVersion('1-2') apache_dsc = MockPackage('apache', version, dsc, 'sha-1:aaa') sp_version = DebianVersion('1-2') extra = { ('pdk', 'sp-name'): 'one', ('pdk', 'sp-version'): sp_version, ('deb', 'arch'): 'i386' } apache_deb = MockPackage('apache', '1-2', deb, 'sha-1:aaa', extra) expected = rules.ac([ rules.rc(eq, 'pdk', 'name', 'apache'), rules.rc(eq, 'pdk', 'version', version) ]) self.assert_equals(expected, get_general_condition(apache_dsc)) expected = rules.ac([ rules.rc(eq, 'pdk', 'name', 'apache'), rules.rc(eq, 'pdk', 'version', version), rules.rc(eq, 'pdk', 'arch', 'i386') ]) self.assert_equals(expected, get_general_condition(apache_deb))
def test_rule_system(self): rule_a = rules.Rule(self.and_condition, True) rule_b = rules.Rule(rules.rc(eq, 'pdk', 'name', 'b'), True) composite = rules.RuleSystem([rule_a, rule_b]) assert not composite.evaluate_metacondition() expected_empty = [] rule_a.action = ShamAction() rule_b.action = ShamAction() composite.fire(self.a1) expected_data = [self.a1] self.assert_equal(expected_data, rule_a.action.calls) self.assert_equal(expected_empty, rule_b.action.calls) assert not composite.evaluate_metacondition() rule_a.action = ShamAction() rule_b.action = ShamAction() composite.fire(self.b2) expected_data = [self.b2] self.assert_equal(expected_empty, rule_a.action.calls) self.assert_equal(expected_data, rule_b.action.calls) assert composite.evaluate_metacondition()
def test_rule_system(self): rule_a = rules.Rule(self.and_condition, True) rule_b = rules.Rule(rules.rc(eq, 'pdk', 'name', 'b'), True) composite = rules.RuleSystem([rule_a, rule_b]) assert not composite.evaluate_metacondition() expected_empty = [] rule_a.action = ShamAction() rule_b.action = ShamAction() composite.fire(self.a1) expected_data = [ self.a1 ] self.assert_equal(expected_data, rule_a.action.calls) self.assert_equal(expected_empty, rule_b.action.calls) assert not composite.evaluate_metacondition() rule_a.action = ShamAction() rule_b.action = ShamAction() composite.fire(self.b2) expected_data = [ self.b2 ] self.assert_equal(expected_empty, rule_a.action.calls) self.assert_equal(expected_data, rule_b.action.calls) assert composite.evaluate_metacondition()
def test_relaxed_relation(self): actual = compile_debish('apache {a:b %= c}', None, None) expected = ac( [rc(eq, 'pdk', 'name', 'apache'), ac([relrc(eq, 'a', 'b', 'c')])]) self.assert_equals(expected, actual)
def test_version_relation(self): vrc = rules.rc(ge, 'pdk', 'version', 3) assert vrc.evaluate({('pdk', 'version'): 4}) assert vrc.evaluate({('pdk', 'version'): 3}) assert not vrc.evaluate({('pdk', 'version'): 2})
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 parse_term(self, lex): # this method does most of the heavy listing. condition = ac([]) conditions = condition.conditions # optional first word is a package name token_type, dummy = lex.peek() if token_type == 'word': dummy, name = lex.next() conditions.append(rc(eq, 'pdk', 'name', name)) # followed by an optional () containing 1 or more version relations token_type, dummy = lex.peek() if token_type == '(': self.assert_type(lex, '(') while 1: rel_type, op_func = self.parse_op(lex) version_str = self.assert_type(lex, 'word') version = self.version_class(version_str) conditions.append(rel_type(op_func, 'pdk', 'version', version)) token_type, dummy = lex.peek() if token_type == ')': self.assert_type(lex, ')') break # followed by an optional [] containing 1 or more arch conditions # These can be marked with ! meaning not. They must all be marked # or unmarked with !. token_type, dummy = lex.peek() if token_type == '[': self.assert_type(lex, '[') or_condition = oc([]) or_conditions = or_condition.conditions token_type, dummy = lex.peek() if token_type == '!': invert_mode = True else: invert_mode = False while 1: if invert_mode: self.assert_type(lex, '!') arch = self.assert_type(lex, 'word') domain = self.package_type.type_string or_conditions.append(rc(eq, domain, 'arch', arch)) token_type, dummy = lex.peek() if token_type == ']': self.assert_type(lex, ']') break if invert_mode: arch_condition = notc(or_condition) else: arch_condition = or_condition conditions.append(arch_condition) # followed by an optional {} containing 0 or more arbitrary # relations. token_type, dummy = lex.peek() if token_type == '{': self.assert_type(lex, '{') and_condition = ac([]) and_conditions = and_condition.conditions while 1: pred_str = self.assert_type(lex, 'word') if ':' in pred_str: domain, predicate = pred_str.split(':', 1) else: domain = 'pdk' predicate = pred_str rel_type, op_func = self.parse_op(lex) target = self.assert_type(lex, 'word') and_conditions.append( rel_type(op_func, domain, predicate, target)) token_type, dummy = lex.peek() if token_type == '}': self.assert_type(lex, '}') break conditions.append(and_condition) return condition
def test_relaxed_relation(self): actual = compile_debish('apache {a:b %= c}', None, None) expected = ac([rc(eq, 'pdk', 'name', 'apache'), ac([relrc(eq, 'a', 'b', 'c')])]) self.assert_equals(expected, actual)
def parse_term(self, lex): # this method does most of the heavy listing. condition = ac([]) conditions = condition.conditions # optional first word is a package name token_type, dummy = lex.peek() if token_type == 'word': dummy, name = lex.next() conditions.append(rc(eq, 'pdk', 'name', name)) # followed by an optional () containing 1 or more version relations token_type, dummy = lex.peek() if token_type == '(': self.assert_type(lex, '(') while 1: rel_type, op_func = self.parse_op(lex) version_str = self.assert_type(lex, 'word') version = self.version_class(version_str) conditions.append(rel_type(op_func, 'pdk', 'version', version)) token_type, dummy = lex.peek() if token_type == ')': self.assert_type(lex, ')') break # followed by an optional [] containing 1 or more arch conditions # These can be marked with ! meaning not. They must all be marked # or unmarked with !. token_type, dummy = lex.peek() if token_type == '[': self.assert_type(lex, '[') or_condition = oc([]) or_conditions = or_condition.conditions token_type, dummy = lex.peek() if token_type == '!': invert_mode = True else: invert_mode = False while 1: if invert_mode: self.assert_type(lex, '!') arch = self.assert_type(lex, 'word') domain = self.package_type.type_string or_conditions.append(rc(eq, domain, 'arch', arch)) token_type, dummy = lex.peek() if token_type == ']': self.assert_type(lex, ']') break if invert_mode: arch_condition = notc(or_condition) else: arch_condition = or_condition conditions.append(arch_condition) # followed by an optional {} containing 0 or more arbitrary # relations. token_type, dummy = lex.peek() if token_type == '{': self.assert_type(lex, '{') and_condition = ac([]) and_conditions = and_condition.conditions while 1: pred_str = self.assert_type(lex, 'word') if ':' in pred_str: domain, predicate = pred_str.split(':', 1) else: domain = 'pdk' predicate = pred_str rel_type, op_func = self.parse_op(lex) target = self.assert_type(lex, 'word') and_conditions.append(rel_type(op_func, domain, predicate, target)) token_type, dummy = lex.peek() if token_type == '}': self.assert_type(lex, '}') break conditions.append(and_condition) return condition
def test_star2(self): actual = compile_debish('** apache | apache2', None, None) expected = star2c(oc([ac([rc(eq, 'pdk', 'name', 'apache')]), ac([rc(eq, 'pdk', 'name', 'apache2')])])) self.assert_equals(expected, actual)
def test_untyped_version(self): actual = compile_debish('apache (=2.0-1)', None, None) expected = ac([rc(eq, 'pdk', 'name', 'apache'), rc(eq, 'pdk', 'version', '2.0-1')]) self.assert_equals(expected, actual)
def test_name_only(self): actual = compile_debish('apache', None, None) expected = ac([rc(eq, 'pdk', 'name', 'apache')]) self.assert_equals(expected, actual)
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_build_general_debish_ref(self): actual = compile_debish('apache', src, None) expected = ac([rc(eq, 'pdk', 'name', 'apache')]) wrapper = ac([expected, rc(eq, 'pdk', 'role', 'source')]) self.assert_equals(wrapper, actual)