from unittest import mock
import unittest

import koji
import kojihub


class TestBasicTests(unittest.TestCase):

    def test_operation_test(self):
        obj = kojihub.OperationTest('operation foo*')
        self.assertFalse(obj.run({'operation': 'FOOBAR'}))
        self.assertTrue(obj.run({'operation': 'foobar'}))

    @mock.patch('kojihub.kojihub.policy_get_pkg')
    def test_package_test(self, policy_get_pkg):
        obj = kojihub.PackageTest('package foo*')
        policy_get_pkg.return_value = {'name': 'mypackage'}
        self.assertFalse(obj.run({}))
        policy_get_pkg.return_value = {'name': 'foobar'}
        self.assertTrue(obj.run({}))

    @mock.patch('kojihub.kojihub.policy_get_version')
    def test_version_test(self, policy_get_version):
        obj = kojihub.VersionTest('version 1.2.*')
        policy_get_version.return_value = '0.0.1'
        self.assertFalse(obj.run({}))
        policy_get_version.return_value = '1.2.1'
        self.assertTrue(obj.run({}))

    @mock.patch('kojihub.kojihub.policy_get_release')
    def test_release_test(self, policy_get_release):
        obj = kojihub.ReleaseTest('release 1.2.*')
        policy_get_release.return_value = '0.0.1'
        self.assertFalse(obj.run({}))
        policy_get_release.return_value = '1.2.1'
        self.assertTrue(obj.run({}))

    @mock.patch('kojihub.kojihub.policy_get_pkg')
    def test_new_package_test(self, policy_get_pkg):
        obj = kojihub.NewPackageTest('is_new_package')
        policy_get_pkg.return_value = {'name': 'mypackage', 'id': 42}
        self.assertFalse(obj.run({}))
        policy_get_pkg.return_value = {'name': 'foobar', 'id': None}
        self.assertTrue(obj.run({}))

    def test_skip_tag_test(self):
        obj = kojihub.kojihub.SkipTagTest('skip_tag')
        data = {'skip_tag': True}
        self.assertTrue(obj.run(data))
        data = {'skip_tag': False}
        self.assertFalse(obj.run(data))
        data = {'skip_tag': None}
        self.assertFalse(obj.run(data))
        data = {}
        self.assertFalse(obj.run(data))


class TestPolicyGetUser(unittest.TestCase):

    def setUp(self):
        self.get_user = mock.patch('kojihub.kojihub.get_user').start()
        self.context = mock.patch('kojihub.kojihub.context').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_get_user_specified(self):
        self.get_user.return_value = 'USER'
        result = kojihub.policy_get_user({'user_id': 42})
        self.assertEqual(result, 'USER')
        self.get_user.assert_called_once_with(42)

    def test_get_no_user(self):
        self.context.session.logged_in = False
        result = kojihub.policy_get_user({})
        self.assertEqual(result, None)
        self.get_user.assert_not_called()

    def test_get_logged_in_user(self):
        self.context.session.logged_in = True
        self.context.session.user_id = 99
        self.get_user.return_value = 'USER'
        result = kojihub.policy_get_user({})
        self.assertEqual(result, 'USER')
        self.get_user.assert_called_once_with(99)

    def test_get_user_specified_with_login(self):
        self.get_user.return_value = 'USER'
        self.context.session.logged_in = True
        self.context.session.user_id = 99
        result = kojihub.policy_get_user({'user_id': 42})
        self.assertEqual(result, 'USER')
        self.get_user.assert_called_once_with(42)


class TestPolicyGetCGs(unittest.TestCase):

    def setUp(self):
        self.get_build = mock.patch('kojihub.kojihub.get_build').start()
        self.list_rpms = mock.patch('kojihub.kojihub.list_rpms').start()
        self.list_archives = mock.patch('kojihub.kojihub.list_archives').start()
        self.get_buildroot = mock.patch('kojihub.kojihub.get_buildroot').start()
        self.lookup_name = mock.patch('kojihub.kojihub.lookup_name').start()

    def tearDown(self):
        mock.patch.stopall()

    def _fakebr(self, br_id, strict):
        self.assertEqual(strict, True)
        return {
            'cg_name': self._cgname(br_id),
            'repo_create_event_id': 1234,
        }

    def _cgname(self, br_id):
        if br_id is None:
            return None
        return 'cg for br %s' % br_id

    def test_policy_get_cg_from_brs(self):
        self.get_build.return_value = {'id': 42}
        br1 = [1, 1, 1, 2, 3, 4, 5, 5]
        br2 = [2, 2, 7, 7, 8, 8, 9, 9, None]
        self.list_rpms.return_value = [{'buildroot_id': n} for n in br1]
        self.list_archives.return_value = [{'buildroot_id': n} for n in br2]
        self.get_buildroot.side_effect = self._fakebr
        # let's see...
        result = kojihub.policy_get_cgs({'build': 'NVR'})
        expect = set([self._cgname(n) for n in br1 + br2])
        self.assertEqual(result, expect)
        self.list_rpms.assert_called_once_with(buildID=42)
        self.list_archives.assert_called_once_with(buildID=42)
        self.get_build.assert_called_once_with('NVR', strict=True)

    def test_policy_get_cg_from_cgs(self):
        data = {
            'cg_list': [1, 1, 1, 2, 2, 2, 3, 3, 3],
            'build': 'whatever',
            'buildroots': [],
        }

        def my_lookup_name(table, info, strict=False, create=False):
            self.assertEqual(strict, True)
            self.assertEqual(create, False)
            self.assertEqual(table, 'content_generator')
            return {'id': info, 'name': "cg %i" % info}
        self.lookup_name.side_effect = my_lookup_name

        result = kojihub.policy_get_cgs(data)
        expect = set(['cg %i' % c for c in data['cg_list']])
        self.assertEqual(result, expect)
        self.get_build.assert_not_called()
        self.get_buildroot.assert_not_called()

    def test_policy_get_cg_nobuild(self):
        result = kojihub.policy_get_cgs({'package': 'foobar'})
        self.get_build.assert_not_called()
        self.assertEqual(result, set())


class TestBuildTagTest(unittest.TestCase):

    def setUp(self):
        self.get_build = mock.patch('kojihub.kojihub.get_build').start()
        self.get_tag = mock.patch('kojihub.kojihub.get_tag').start()
        self.list_rpms = mock.patch('kojihub.kojihub.list_rpms').start()
        self.list_archives = mock.patch('kojihub.kojihub.list_archives').start()
        self.get_buildroot = mock.patch('kojihub.kojihub.get_buildroot').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_build_tag_given(self):
        obj = kojihub.BuildTagTest('buildtag foo*')
        data = {'build_tag': 'TAGINFO'}
        self.get_tag.return_value = {'name': 'foo-3.0-build'}
        self.assertTrue(obj.run(data))
        self.list_rpms.assert_not_called()
        self.list_archives.assert_not_called()
        self.get_buildroot.assert_not_called()
        self.get_tag.assert_called_once_with('TAGINFO', event='auto', strict=True)

    def test_build_tag_given_alt(self):
        obj = kojihub.BuildTagTest('buildtag foo*')
        data = {'build_tag': 'TAGINFO'}
        self.get_tag.return_value = {'name': 'foo-3.0-build'}
        self.assertTrue(obj.run(data))
        self.get_tag.return_value = {'name': 'bar-1.2-build'}
        self.assertFalse(obj.run(data))

        obj = kojihub.BuildTagTest('buildtag foo-3* foo-4* fake-*')
        data = {'build_tag': 'TAGINFO', 'build': 'BUILDINFO'}
        self.get_tag.return_value = {'name': 'foo-4.0-build'}
        self.assertTrue(obj.run(data))
        self.get_tag.return_value = {'name': 'foo-3.0.1-build'}
        self.assertTrue(obj.run(data))
        self.get_tag.return_value = {'name': 'fake-0.99-build'}
        self.assertTrue(obj.run(data))
        self.get_tag.return_value = {'name': 'foo-2.1'}
        self.assertFalse(obj.run(data))
        self.get_tag.return_value = {'name': 'foo-5.5-alt'}
        self.assertFalse(obj.run(data))
        self.get_tag.return_value = {'name': 'baz-2-candidate'}
        self.assertFalse(obj.run(data))

        self.list_rpms.assert_not_called()
        self.list_archives.assert_not_called()
        self.get_buildroot.assert_not_called()

    def _fakebr(self, br_id, strict=None):
        return {
            'tag_name': self._brtag(br_id),
            'repo_create_event_id': 123,
        }

    def _brtag(self, br_id):
        if br_id == '':
            return None
        return br_id

    def test_build_tag_from_build(self):
        # Note: the match is for any buildroot tag
        brtags = [None, '', 'a', 'b', 'c', 'd', 'not-foo-5', 'foo-3-build']
        self.list_rpms.return_value = [{'buildroot_id': x} for x in brtags]
        self.list_archives.return_value = [{'buildroot_id': x} for x in brtags]
        self.get_buildroot.side_effect = self._fakebr

        obj = kojihub.BuildTagTest('buildtag foo-*')
        data = {'build': 'BUILDINFO'}
        self.assertTrue(obj.run(data))

        obj = kojihub.BuildTagTest('buildtag bar-*')
        data = {'build': 'BUILDINFO'}
        self.assertFalse(obj.run(data))

        self.get_tag.assert_has_calls([
            mock.call('a', event=123, strict=True),
            mock.call('b', event=123, strict=True),
            mock.call('c', event=123, strict=True),
            mock.call('d', event=123, strict=True),
            mock.call('not-foo-5', event=123, strict=True),
            mock.call('foo-3-build', event=123, strict=True),
        ], any_order=True)

    def test_build_tag_no_info(self):
        obj = kojihub.BuildTagTest('buildtag foo*')
        data = {}
        self.assertFalse(obj.run(data))
        self.list_rpms.assert_not_called()
        self.list_archives.assert_not_called()
        self.get_buildroot.assert_not_called()


class TestHasTagTest(unittest.TestCase):

    def setUp(self):
        self.list_tags = mock.patch('kojihub.kojihub.list_tags').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_build_not_in_data(self):
        data = {'key': 'test'}
        obj = kojihub.HasTagTest('hastag *-candidate')
        self.assertFalse(obj.run(data))
        self.list_tags.assert_not_called()

    def test_has_tag_simple(self):
        obj = kojihub.HasTagTest('hastag *-candidate')
        tags = ['foo-1.0', 'foo-2.0', 'foo-3.0-candidate']
        self.list_tags.return_value = [{'name': t} for t in tags]
        data = {'build': 'NVR'}
        self.assertTrue(obj.run(data))
        self.list_tags.assert_called_once_with(build='NVR')

        # check no match case
        self.list_tags.return_value = []
        self.assertFalse(obj.run(data))


class TestBuildTagInheritsFromTest(unittest.TestCase):

    def setUp(self):
        self.policy_get_build_tags = mock.patch('kojihub.kojihub.policy_get_build_tags').start()
        self.readFullInheritance = mock.patch('kojihub.kojihub.readFullInheritance').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_wrong_test_name(self):
        obj = kojihub.BuildTagInheritsFromTest('buildtag_inherits_from_type foo*')
        data = {}
        self.policy_get_build_tags.return_value = {None}
        with self.assertRaises(AssertionError):
            obj.run(data)

    def test_no_buildtag(self):
        obj = kojihub.BuildTagInheritsFromTest('buildtag_inherits_from foo*')
        data = {}
        self.policy_get_build_tags.return_value = {None}
        self.assertFalse(obj.run(data))
        self.policy_get_build_tags.assert_called_once_with(data, taginfo=True)
        self.readFullInheritance.assert_not_called()

    def test_no_inheritance(self):
        obj = kojihub.BuildTagInheritsFromTest('buildtag_inherits_from foo*')
        data = {}
        self.policy_get_build_tags.return_value = [{'id': 123, 'tag_name': 'foox'}]
        self.readFullInheritance.return_value = []
        self.assertFalse(obj.run(data))
        self.policy_get_build_tags.assert_called_once_with(data, taginfo=True)
        self.readFullInheritance.assert_called_once_with(123, event=None)

    def test_inheritance_pass(self):
        obj = kojihub.BuildTagInheritsFromTest('buildtag_inherits_from foo*')
        data = {}
        self.policy_get_build_tags.return_value = [{'id': 123, 'tag_name': 'wrong'}]
        self.readFullInheritance.return_value = [
            {'name': 'still-wrong'},
            {'name': 'foox'},
        ]
        self.assertTrue(obj.run(data))
        self.policy_get_build_tags.assert_called_once_with(data, taginfo=True)
        self.readFullInheritance.assert_called_once_with(123, event=None)

    def test_inheritance_fail(self):
        obj = kojihub.BuildTagInheritsFromTest('buildtag_inherits_from foo*')
        data = {}
        self.policy_get_build_tags.return_value = [{'id': 123, 'tag_name': 'wrong'}]
        self.readFullInheritance.return_value = [
            {'name': 'still-wrong'},
            {'name': 'still-still-wrong'},
        ]
        self.assertFalse(obj.run(data))
        self.policy_get_build_tags.assert_called_once_with(data, taginfo=True)
        self.readFullInheritance.assert_called_once_with(123, event=None)


class TestBuildTypeTest(unittest.TestCase):
    def setUp(self):
        self.get_build_type = mock.patch('kojihub.kojihub.get_build_type').start()
        self.get_build = mock.patch('kojihub.kojihub.get_build').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_invalid(self):
        binfo = {'id': 1, 'name': 'nvr-1-2'}
        self.get_build.return_value = binfo
        self.get_build_type.return_value = {'rpm': None}
        obj = kojihub.BuildTypeTest('buildtype foo-*')
        data = {'build': 'nvr-1-2'}
        self.assertFalse(obj.run(data))
        self.get_build_type.assert_called_once_with(binfo)

    def test_valid(self):
        binfo = {'id': 1, 'name': 'nvr-1-2'}
        self.get_build.return_value = binfo
        self.get_build_type.return_value = {'rpm': None}
        obj = kojihub.BuildTypeTest('buildtype rpm')
        data = {'build': 'nvr-1-2'}
        self.assertTrue(obj.run(data))
        self.get_build_type.assert_called_once_with(binfo)

    def test_prepopulated(self):
        # self.get_build.return_value = {'id': 1, 'name': 'nvr-1-2'}
        self.get_build_type.return_value = {'rpm': None}
        obj = kojihub.BuildTypeTest('buildtype rpm')
        data = {'build': 123, 'btypes': set(['rpm'])}
        self.assertTrue(obj.run(data))
        self.get_build_type.assert_not_called()


class TestImportedTest(unittest.TestCase):
    def setUp(self):
        self.list_rpms = mock.patch('kojihub.kojihub.list_rpms').start()
        self.list_archives = mock.patch('kojihub.kojihub.list_archives').start()
        self.get_build = mock.patch('kojihub.kojihub.get_build').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_no_build(self):
        self.get_build.side_effect = koji.GenericError
        obj = kojihub.ImportedTest('imported - no build')
        data = {}
        with self.assertRaises(koji.GenericError) as cm:
            obj.run(data)
        self.assertEqual(cm.exception.args[0],
                         'policy data must contain a build')
        self.get_build.assert_not_called()

    def test_invalid_build(self):
        self.get_build.side_effect = koji.GenericError
        obj = kojihub.ImportedTest('imported - invalid build')
        data = {'build': 'nvr-1-1'}
        with self.assertRaises(koji.GenericError):
            obj.run(data)
        self.get_build.assert_called_once_with('nvr-1-1', strict=True)

    def test_imported_rpm(self):
        binfo = {'id': 1, 'name': 'nvr-1-1'}
        self.get_build.return_value = binfo
        self.list_rpms.return_value = [{'id': 1, 'buildroot_id': None}]
        obj = kojihub.ImportedTest('imported - imported rpm')
        data = {'build': 'nvr-1-1'}
        self.assertTrue(obj.run(data))
        self.get_build.assert_called_once_with('nvr-1-1', strict=True)
        self.list_rpms.assert_called_once_with(buildID=1)
        self.list_archives.assert_not_called()

    def test_imported_archive(self):
        binfo = {'id': 1, 'name': 'nvr-1-1'}
        self.get_build.return_value = binfo
        self.list_rpms.return_value = [{'id': 1, 'buildroot_id': 1}]
        self.list_archives.return_value = [{'id': 1, 'buildroot_id': None}]
        obj = kojihub.ImportedTest('imported - imported archive')
        data = {'build': 'nvr-1-1'}
        self.assertTrue(obj.run(data))
        self.get_build.assert_called_once_with('nvr-1-1', strict=True)
        self.list_rpms.assert_called_once_with(buildID=1)
        self.list_archives.assert_called_once_with(buildID=1)

    def test_false(self):
        binfo = {'id': 1, 'name': 'nvr-1-1'}
        self.get_build.return_value = binfo
        self.list_rpms.return_value = [{'id': 1, 'buildroot_id': 1}]
        self.list_archives.return_value = [{'id': 1, 'buildroot_id': 2}]
        obj = kojihub.ImportedTest('imported - false test')
        data = {'build': 'nvr-1-1'}
        self.assertFalse(obj.run(data))
        self.get_build.assert_called_once_with('nvr-1-1', strict=True)
        self.list_rpms.assert_called_once_with(buildID=1)
        self.list_archives.assert_called_once_with(buildID=1)


class TestPolicyGetVersion(unittest.TestCase):
    def setUp(self):
        self.get_build = mock.patch('kojihub.kojihub.get_build').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_policy_version(self):
        data = {'version': 123}
        rv = kojihub.policy_get_version(data)
        self.assertEqual(rv, 123)
        self.get_build.assert_not_called()

    def test_policy_build(self):
        data = {'build': 123}
        buildinfo = {'id': 123, 'version': 100}
        self.get_build.return_value = buildinfo
        rv = kojihub.policy_get_version(data)
        self.assertEqual(rv, 100)
        self.get_build.assert_called_once_with(data['build'], strict=True)

    def test_policy_version_error(self):
        data = {'release': 123}
        with self.assertRaises(koji.GenericError) as cm:
            kojihub.policy_get_version(data)
        self.assertEqual("policy requires version data", str(cm.exception))
        self.get_build.assert_not_called()


class TestPolicyGetRelease(unittest.TestCase):
    def setUp(self):
        self.get_build = mock.patch('kojihub.kojihub.get_build').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_policy_release(self):
        data = {'release': 123}
        rv = kojihub.policy_get_release(data)
        self.assertEqual(rv, 123)
        self.get_build.assert_not_called()

    def test_policy_build(self):
        data = {'build': 123}
        buildinfo = {'id': 123, 'release': 100}
        self.get_build.return_value = buildinfo
        rv = kojihub.policy_get_release(data)
        self.assertEqual(rv, 100)
        self.get_build.assert_called_once_with(data['build'], strict=True)

    def test_policy_release_error(self):
        data = {'version': 123}
        with self.assertRaises(koji.GenericError) as cm:
            kojihub.policy_get_release(data)
        self.assertEqual("policy requires release data", str(cm.exception))
        self.get_build.assert_not_called()


class TestPolicyGetPkg(unittest.TestCase):
    def setUp(self):
        self.get_build = mock.patch('kojihub.kojihub.get_build').start()
        self.lookup_package = mock.patch('kojihub.kojihub.lookup_package').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_no_such_pkg(self):
        data = {'package': 123}
        self.lookup_package.return_value = None
        with self.assertRaises(koji.GenericError) as cm:
            kojihub.policy_get_pkg(data)
        self.assertEqual(f"No such package: {data['package']}", str(cm.exception))
        self.lookup_package.assert_called_once_with(data['package'], strict=False)
        self.get_build.assert_not_called()

    def test_with_pkg_not_found_lookup_pkg(self):
        data = {'package': 'test-pkg'}
        self.lookup_package.return_value = None
        rv = kojihub.policy_get_pkg(data)
        self.assertEqual(rv, {'id': None, 'name': data['package']})
        self.lookup_package.assert_called_once_with(data['package'], strict=False)
        self.get_build.assert_not_called()

    def test_with_pkg(self):
        data = {'package': 'test-pkg'}
        self.lookup_package.return_value = {'id': 1, 'name': data['package']}
        rv = kojihub.policy_get_pkg(data)
        self.assertEqual(rv, {'id': 1, 'name': data['package']})
        self.lookup_package.assert_called_once_with(data['package'], strict=False)
        self.get_build.assert_not_called()

    def test_build(self):
        data = {'build': 123}
        buildinfo = {'id': 123, 'package_id': 1, 'name': 'test-pkg'}
        self.get_build.return_value = buildinfo
        rv = kojihub.policy_get_pkg(data)
        self.assertEqual(rv, {'id': buildinfo['package_id'], 'name': buildinfo['name']})
        self.lookup_package.assert_not_called()
        self.get_build.assert_called_once_with(data['build'], strict=True)

    def test_wrong_data_key(self):
        data = {'id': 123}
        with self.assertRaises(koji.GenericError) as cm:
            kojihub.policy_get_pkg(data)
        self.assertEqual("policy requires package data", str(cm.exception))
        self.lookup_package.assert_not_called()
        self.get_build.assert_not_called()


class TestVolumeTest(unittest.TestCase):
    def setUp(self):
        self.lookup_name = mock.patch('kojihub.kojihub.lookup_name').start()
        self.get_build = mock.patch('kojihub.kojihub.get_build').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_volume_data(self):
        self.lookup_name.return_value = {'id': 159, 'name': 'test-volume'}
        obj = kojihub.VolumeTest('volume - volume data')
        data = {'volume': 'test-volume'}
        obj.run(data)
        self.get_build.assert_not_called()
        self.lookup_name.assert_called_once_with('volume', data['volume'], strict=False)

    def test_build_data(self):
        buildinfo = {'volume_id': 5, 'volume_name': 'test-volume', 'id': 2}
        self.get_build.return_value = buildinfo
        obj = kojihub.VolumeTest('volume - build data')
        data = {'build': 'nvr-1-1'}
        obj.run(data)
        self.get_build.assert_called_once_with(data['build'])
        self.lookup_name.assert_not_called()

    def test_not_volinfo(self):
        data = {'key': 'test'}
        obj = kojihub.VolumeTest('volume - volume none')
        self.assertFalse(obj.run(data))
        self.get_build.assert_not_called()
        self.lookup_name.assert_not_called()


class TestTagTest(unittest.TestCase):
    def setUp(self):
        self.get_tag = mock.patch('kojihub.kojihub.get_tag').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_tag_is_none(self):
        data = {'key': 'test'}
        obj = kojihub.TagTest('tagtest - tag none')
        self.assertFalse(obj.run(data))
        self.get_tag.assert_not_called()

    def test_taginfo_is_none(self):
        self.get_tag.return_value = None
        data = {'tag': 'test-tag'}
        obj = kojihub.TagTest('tagtest - taginfo none')
        self.assertFalse(obj.run(data))
        self.get_tag.assert_called_once_with(data['tag'], strict=False)

    def test_taginfo_valid(self):
        data = {'tag': 'test-tag'}
        self.get_tag.return_value = {'name': data['tag']}
        obj = kojihub.TagTest('tagtest - taginfo none')
        self.assertIsNotNone(obj.run(data))
        self.get_tag.assert_called_once_with(data['tag'], strict=False)


class FromTagTest(unittest.TestCase):
    def setUp(self):
        self.get_tag = mock.patch('kojihub.kojihub.get_tag').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_tag_is_none(self):
        data = {'key': 'test'}
        obj = kojihub.FromTagTest('fromtagtest - tag none')
        self.assertIsNone(obj.get_tag(data))
        self.get_tag.assert_not_called()

    def test_valid(self):
        data = {'fromtag': 'test-tag'}
        self.get_tag.return_value = {'name': data['fromtag']}
        obj = kojihub.FromTagTest('fromtagtest - tag none')
        self.assertEqual(obj.get_tag(data), {'name': data['fromtag']})
        self.get_tag.assert_called_once_with(data['fromtag'], strict=False)


class CGMatchAnyTest(unittest.TestCase):
    def setUp(self):
        self.policy_get_cgs = mock.patch('kojihub.kojihub.policy_get_cgs').start()
        self.multi_fnmatch = mock.patch('kojihub.kojihub.multi_fnmatch').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_cgname_is_none(self):
        data = {'key': 'test'}
        self.policy_get_cgs.return_value = [None]
        obj = kojihub.CGMatchAnyTest('cgmatchanytest - cg name none')
        self.assertFalse(obj.run(data))

    def test_cg_name_true(self):
        data = {'key': 'test'}
        self.policy_get_cgs.return_value = ['cgname']
        self.multi_fnmatch.return_value = True
        obj = kojihub.CGMatchAnyTest('cgmatchanytest - cg name true')
        self.assertTrue(obj.run(data))


class CGMatchAllTest(unittest.TestCase):
    def setUp(self):
        self.policy_get_cgs = mock.patch('kojihub.kojihub.policy_get_cgs').start()
        self.multi_fnmatch = mock.patch('kojihub.kojihub.multi_fnmatch').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_cgs_none(self):
        data = {'key': 'test'}
        self.policy_get_cgs.return_value = []
        obj = kojihub.CGMatchAllTest('cgmatchalltest - cg name none')
        self.assertFalse(obj.run(data))

    def test_cgname_is_none(self):
        data = {'key': 'cgname'}
        self.policy_get_cgs.return_value = [None]
        obj = kojihub.CGMatchAllTest('cgmatchalltest - cg name none')
        self.assertFalse(obj.run(data))

    def test_cg_name_all_true(self):
        data = {'key': 'cgname'}
        self.policy_get_cgs.return_value = ['cgname']
        self.multi_fnmatch.return_value = True
        obj = kojihub.CGMatchAllTest('cgmatchalltest - cg name true')
        self.assertTrue(obj.run(data))

    def test_cg_name_not_found(self):
        data = {'key': 'cgname'}
        self.policy_get_cgs.return_value = ['cgname']
        self.multi_fnmatch.return_value = False
        obj = kojihub.CGMatchAllTest('cgmatchalltest - cg name true')
        self.assertFalse(obj.run(data))


class UserTest(unittest.TestCase):
    def setUp(self):
        self.policy_get_user = mock.patch('kojihub.kojihub.policy_get_user').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_not_user(self):
        data = {'user': 'username'}
        self.policy_get_user.return_value = None
        obj = kojihub.UserTest('usertest - not user')
        self.assertFalse(obj.run(data))

    def test_valid(self):
        data = {'user': 'username'}
        self.policy_get_user.return_value = {'name': 'username'}
        obj = kojihub.UserTest('usertest - valid')
        self.assertIsNotNone(obj.run(data))


class IsBuildOwnerTest(unittest.TestCase):
    def setUp(self):
        self.policy_get_user = mock.patch('kojihub.kojihub.policy_get_user').start()
        self.get_build = mock.patch('kojihub.kojihub.get_build').start()
        self.get_user = mock.patch('kojihub.kojihub.get_user').start()
        self.get_user_groups = mock.patch('kojihub.kojihub.get_user_groups').start()

    def tearDown(self):
        mock.patch.stopall()

    def test_not_user(self):
        data = {'build': 1}
        self.get_build.return_value = {'build_id': data['build'], 'owner_id': 3}
        self.get_user.return_value = {'id': 3, 'name': 'username'}
        self.policy_get_user.return_value = None
        obj = kojihub.IsBuildOwnerTest('isbuildownertest - not user')
        self.assertFalse(obj.run(data))
        self.get_build.assert_called_once_with(data['build'])
        self.get_user.assert_called_once_with(3)
        self.policy_get_user.assert_called_once_with(data)
        self.get_user_groups.assert_not_called()

    def test_owner_is_user(self):
        data = {'build': 1}
        self.get_build.return_value = {'build_id': data['build'], 'owner_id': 3}
        self.get_user.return_value = {'id': 3, 'name': 'username'}
        self.policy_get_user.return_value = {'id': 3, 'name': 'username'}
        obj = kojihub.IsBuildOwnerTest('isbuildownertest - owner is user')
        self.assertTrue(obj.run(data))
        self.get_build.assert_called_once_with(data['build'])
        self.get_user.assert_called_once_with(3)
        self.policy_get_user.assert_called_once_with(data)
        self.get_user_groups.assert_not_called()

    def test_owner_is_group(self):
        data = {'build': 1}
        self.get_build.return_value = {'build_id': data['build'], 'owner_id': 3}
        self.get_user.return_value = {'id': 2, 'name': 'testuser', 'usertype': 2}
        self.policy_get_user.return_value = {'id': 3, 'name': 'username'}
        self.get_user_groups.return_value = {2: 'group_name'}
        obj = kojihub.IsBuildOwnerTest('isbuildownertest - owner group')
        self.assertTrue(obj.run(data))
        self.get_build.assert_called_once_with(data['build'])
        self.get_user.assert_called_once_with(3)
        self.policy_get_user.assert_called_once_with(data)
        self.get_user_groups.assert_called_once_with(3)

    def test_owner_false(self):
        data = {'build': 1}
        self.get_build.return_value = {'build_id': data['build'], 'owner_id': 3}
        self.get_user.return_value = {'id': 2, 'name': 'testuser', 'usertype': 1}
        self.policy_get_user.return_value = {'id': 3, 'name': 'username'}
        obj = kojihub.IsBuildOwnerTest('isbuildownertest - owner false')
        self.assertFalse(obj.run(data))
        self.get_build.assert_called_once_with(data['build'])
        self.get_user.assert_called_once_with(3)
        self.policy_get_user.assert_called_once_with(data)
        self.get_user_groups.assert_not_called()


class TestPolicyDataFromTask(unittest.TestCase):

    def setUp(self):
        self.lookup_build_target = mock.patch('kojihub.kojihub.lookup_build_target').start()
        self.lookup_build_target.return_value = {'id': 100, 'name': 'MYTARGET'}
        self.lookup_tag = mock.patch('kojihub.kojihub.lookup_tag').start()
        self.lookup_tag.return_value = {'id': 100, 'name': 'MYTAG'}

    def tearDown(self):
        mock.patch.stopall()

    GOOD = [
        # method, kwargs, expect
        ['build',
            {'src': 'git://foo', 'target': 100, 'opts': {}},
            {'source': 'git://foo', 'target': 'MYTARGET'}],
        ['build',
            {'src': 'git://foo', 'target': 100, 'opts': {'scratch': True}},
            {'source': 'git://foo', 'target': 'MYTARGET', 'scratch': True}],
        ['build', 
            {'src': 'git://foo', 'target': {'name': 'MYTARGET'}, 'opts': {}},
            {'source': 'git://foo', 'target': 'MYTARGET'}],
        ['newRepo',
            {'tag': 100},
            {'tag': 'MYTAG'}],
        ['newRepo',
            {'tag': 'MYTAG', 'src': 'should be ignored'},
            {'tag': 'MYTAG'}],
        ['rebuildSRPM',
            {'srpm': 'SRPM', 'build_tag': 100},
            {'build_tag': 'MYTAG'}],
        ['indirectionimage',
            {'opts': {'scratch': True, 'target': 100}},
            {'target': 'MYTARGET', 'scratch': True}],
    ]

    BAD = [
        # method, arglist
        ['nosuchmethod', []],
        ['build', [1,2,3,4,5,6,7,8]],  # too many args
        ['build', True],  # not a list
    ]

    def test_good(self):
        for method, kwargs, expect in self.GOOD:
            arglist = koji.encode_args(**kwargs)
            data = kojihub.policy_data_from_task_args(method, arglist)
            self.assertEqual(data, expect)

    def test_bad(self):
        # this function should be tolerant of bad parameters
        for method, arglist in self.BAD:
            data = kojihub.policy_data_from_task_args(method, arglist)
            self.assertEqual(data, {})

    def test_unexpected_exception(self):
        arglist = mock.MagicMock()
        arglist.__len__.side_effect = Exception('highly unlikely scenario')
        data = kojihub.policy_data_from_task_args('build', arglist)
        self.assertEqual(data, {})

    def test_bad_target(self):
        kwargs = {'src': 'git://foo', 'target': {}}
        arglist = koji.encode_args(**kwargs)
        data = kojihub.policy_data_from_task_args('build', arglist)
        self.assertEqual(data, {'source': 'git://foo', 'target': None})

    def test_bad_target2(self):
        kwargs = {'src': 'git://foo', 'target': 100}
        arglist = koji.encode_args(**kwargs)
        self.lookup_build_target.return_value = None
        data = kojihub.policy_data_from_task_args('build', arglist)
        self.assertEqual(data, {'source': 'git://foo', 'target': None})

    def test_bad_tag(self):
        kwargs = {'tag': 100}
        arglist = koji.encode_args(**kwargs)
        self.lookup_tag.side_effect = koji.GenericError('...')
        data = kojihub.policy_data_from_task_args('newRepo', arglist)
        self.assertEqual(data, {})

    def test_bad_build_tag(self):
        kwargs = {'srpm': 'SRPM', 'build_tag': 100}
        arglist = koji.encode_args(**kwargs)
        self.lookup_tag.side_effect = koji.GenericError('...')
        data = kojihub.policy_data_from_task_args('rebuildSRPM', arglist)
        self.assertEqual(data, {})


# the end