+ class AdvancedMatchTest(BaseSimpleTest):

+     """Matches a field in the data against glob patterns

+ 

+     The field could be the same as match test,

+     or a dot-splited string which indicates key in a (nested) dict

+ 

+     True if any of the expressions match, else False

+     This test can be used as-is, or it can be subclassed to

+     test a specific field

+ 

+     Syntax:

+         adv_match field[.sub_field ...] pattern1 [pattern2 ...]

+ 

+     """

+     name = 'adv_match'

+     field = None

+ 

+     def run(self, data):

+         args = self.str.split()[1:]

+         if self.field is None:

+             field = args[0]

+             args = args[1:]

+         else:

+             # expected when we are subclassed

+             field = self.field

+         fields = field.split('.')

+         tgt = data

+         for i, f in enumerate(fields):

+             if not isinstance(tgt, dict):

+                 return False

+             if f not in tgt:

+                 return False

+             tgt = tgt.get(f)

+ 

+         for pattern in args:

+             if fnmatch.fnmatch(tgt, pattern):

+                 return True

+         return False

+ 

+ 

+ class FindTest(BaseSimpleTest):

+     """Matches any item of a list/tuple/set value in the data against glob patterns

+ 

+     True if any of the expressions matches any item in the list/tuple/set, else False.

+     If the field doesn't exist or isn't a list/tuple/set, the test returns False

+ 

+     Syntax:

+         find field pattern1 [pattern2 ...]

+ 

+     """

+     name = 'find'

+     field = None

+ 

+     def run(self, data):

+         args = self.str.split()[1:]

+         self.field = args[0]

+         args = args[1:]

+         tgt = data.get(self.field)

+         if tgt and isinstance(tgt, (list, tuple, set)):

+             for pattern in args:

+                 for i in tgt:

+                     if fnmatch.fnmatch(i, pattern):

+                         return True

+         return False

+ 

+ 

+     def test_adv_match_test(self):

+         obj = koji.policy.AdvancedMatchTest('not_important foo *bar*')

+         self.assertTrue(obj.run({'foo': 'foobar'}))

+         self.assertFalse(obj.run({'foo': 'nah...'}))

+         obj = koji.policy.AdvancedMatchTest('not_important foo.bar.hello world?')

+         self.assertTrue(obj.run({'foo': {

+             'bar': {

+                 'hello': 'world!'

+             }

+         }}))

+         self.assertFalse(obj.run({'foo': 'nah???'}))

+         self.assertFalse(obj.run({'foo': {

+             'bar': {

+                 'hello': 'world!!'

+             }

+         }}))

+ 

+     def test_find_test(self):

+         obj = koji.policy.FindTest('not_important foo *bar*')

+         self.assertTrue(obj.run({'foo': ['barrrr', 'any']}))

+         self.assertFalse(obj.run({'foo': ['nah....']}))

+         self.assertFalse(obj.run({'foo': 'nah...'}))

+         self.assertFalse(obj.run({'bar': ['any']}))

+ 

+             'adv_match': koji.policy.AdvancedMatchTest,

+             'find': koji.policy.FindTest,