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_and_or_condition(self): first = rules.ac([1, 2, 3]) same_as_first = rules.ac([1, 2, 3]) second = rules.oc([1, 2, 3]) assert first == same_as_first assert second != first assert hash(first) == hash(same_as_first)
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_and_or_condition(self): first = rules.ac([1, 2, 3]) same_as_first = rules.ac([1, 2, 3]) second = rules.oc([1, 2, 3]) assert first == same_as_first assert second != first assert hash(first) == hash(same_as_first)
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_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_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 parse_or(self, lex): terms = [] while 1: term = self.parse_term(lex) terms.append(term) token_type, dummy = lex.peek() if token_type == '|': self.assert_type(lex, '|') else: break if len(terms) == 1: return terms[0] else: return oc(terms)
def parse_or(self, lex): terms = [] while 1: term = self.parse_term(lex) terms.append(term) token_type, dummy = lex.peek() if token_type == '|': self.assert_type(lex, '|') else: break if len(terms) == 1: return terms[0] else: return oc(terms)
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_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_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_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 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 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)