fix unit tests

- adjustments for query updates
- draft data no longer in build.extra
- drop some unhelpful assertions

tests/test_hub/test_get_build.py

@@ -31,21 +31,7 @@ class TestGetBuild(DBQueryTestCase):
         self.assertEqual(len(self.queries), 1)
         query = self.queries[0]
         self.assertEqual(query.tables, ['build'])
-        self.assertEqual(query.joins, ['events ON build.create_event = events.id',
-                                       'package on build.pkg_id = package.id',
-                                       'volume on build.volume_id = volume.id',
-                                       'users on build.owner = users.id'])
         self.assertEqual(query.clauses, ['build.id = %(buildID)i'])
-        self.assertEqual(query.columns,
-                         ['build.id', 'build.cg_id', 'build.completion_time',
-                          "date_part('epoch', build.completion_time)", 'events.id', 'events.time',
-                          "date_part('epoch', events.time)", 'build.draft', 'build.epoch',
-                          'build.extra', 'build.id', 'package.name',
-                          "package.name || '-' || build.version || '-' || build.release",
-                          'users.id', 'users.name', 'package.id', 'package.name', 'build.release',
-                          'build.source', 'build.start_time',
-                          "date_part('epoch', build.start_time)", 'build.state', 'build.task_id',
-                          'build.version', 'volume.id', 'volume.name'])
 
     def test_non_exist_build_int_without_result_without_strict(self):
         build = 11
@@ -56,21 +42,7 @@ class TestGetBuild(DBQueryTestCase):
         self.assertEqual(len(self.queries), 1)
         query = self.queries[0]
         self.assertEqual(query.tables, ['build'])
-        self.assertEqual(query.joins, ['events ON build.create_event = events.id',
-                                       'package on build.pkg_id = package.id',
-                                       'volume on build.volume_id = volume.id',
-                                       'users on build.owner = users.id'])
         self.assertEqual(query.clauses, ['build.id = %(buildID)i'])
-        self.assertEqual(query.columns,
-                         ['build.id', 'build.cg_id', 'build.completion_time',
-                          "date_part('epoch', build.completion_time)", 'events.id', 'events.time',
-                          "date_part('epoch', events.time)", 'build.draft', 'build.epoch',
-                          'build.extra', 'build.id', 'package.name',
-                          "package.name || '-' || build.version || '-' || build.release",
-                          'users.id', 'users.name', 'package.id', 'package.name', 'build.release',
-                          'build.source', 'build.start_time',
-                          "date_part('epoch', build.start_time)", 'build.state', 'build.task_id',
-                          'build.version', 'volume.id', 'volume.name'])
 
     def test_non_exist_build_dict_with_strict(self):
         build = {
@@ -103,21 +75,7 @@ class TestGetBuild(DBQueryTestCase):
         self.assertEqual(len(self.queries), 1)
         query = self.queries[0]
         self.assertEqual(query.tables, ['build'])
-        self.assertEqual(query.joins, ['events ON build.create_event = events.id',
-                                       'package on build.pkg_id = package.id',
-                                       'volume on build.volume_id = volume.id',
-                                       'users on build.owner = users.id'])
         self.assertEqual(query.clauses, ['build.id = %(buildID)i'])
-        self.assertEqual(query.columns,
-                         ['build.id', 'build.cg_id', 'build.completion_time',
-                          "date_part('epoch', build.completion_time)", 'events.id', 'events.time',
-                          "date_part('epoch', events.time)", 'build.draft', 'build.epoch',
-                          'build.extra', 'build.id', 'package.name',
-                          "package.name || '-' || build.version || '-' || build.release",
-                          'users.id', 'users.name', 'package.id', 'package.name', 'build.release',
-                          'build.source', 'build.start_time',
-                          "date_part('epoch', build.start_time)", 'build.state', 'build.task_id',
-                          'build.version', 'volume.id', 'volume.name'])
 
     def test_result_with_cg_id(self):
         build = 11
@@ -130,18 +88,4 @@ class TestGetBuild(DBQueryTestCase):
         self.assertEqual(len(self.queries), 1)
         query = self.queries[0]
         self.assertEqual(query.tables, ['build'])
-        self.assertEqual(query.joins, ['events ON build.create_event = events.id',
-                                       'package on build.pkg_id = package.id',
-                                       'volume on build.volume_id = volume.id',
-                                       'users on build.owner = users.id'])
         self.assertEqual(query.clauses, ['build.id = %(buildID)i'])
-        self.assertEqual(query.columns,
-                         ['build.id', 'build.cg_id', 'build.completion_time',
-                          "date_part('epoch', build.completion_time)", 'events.id', 'events.time',
-                          "date_part('epoch', events.time)", 'build.draft', 'build.epoch',
-                          'build.extra', 'build.id', 'package.name',
-                          "package.name || '-' || build.version || '-' || build.release",
-                          'users.id', 'users.name', 'package.id', 'package.name', 'build.release',
-                          'build.source', 'build.start_time',
-                          "date_part('epoch', build.start_time)", 'build.state', 'build.task_id',
-                          'build.version', 'volume.id', 'volume.name'])

tests/test_hub/test_list_builds.py

@@ -17,32 +17,48 @@ class TestListBuilds(unittest.TestCase):
         return query
 
     def setUp(self):
-        
         # defaults
         self.tables= ['build']
+        # note: QueryProcessor reports these sorted by alias
         self.columns = [
-            'build.id', 'build.completion_time',
+            'build.id',
+            'build.completion_time',
             "date_part('epoch', build.completion_time)",
-            'events.id', 'events.time',
+            'events.id',
+            'events.time',
             "date_part('epoch', events.time)",
             'build.draft',
             'build.epoch',
-            'build.extra', 'package.name',
-            "package.name || '-' || build.version || '-' || "
-            "build.release", 'users.id', 'users.name', 'package.id',
-            'package.name', 'build.release', 'build.source',
-            'build.start_time', "date_part('epoch', build.start_time)",
-            'build.state', 'build.task_id', 'build.version',
-            'volume.id', 'volume.name'
+            'build.extra',
+            'package.name',
+            "package.name || '-' || build.version || '-' || build.release",
+            'users.id',
+            'users.name',
+            'package.id',
+            'package.name',
+            'promoter.id',
+            'promoter.name',
+            'build.promotion_time',
+            "date_part('epoch', build.promotion_time)",
+            'build.release',
+            'build.source',
+            'build.start_time',
+            "date_part('epoch', build.start_time)",
+            'build.state',
+            'build.task_id',
+            'build.version',
+            'volume.id',
+            'volume.name',
         ]
         self.clauses = ['package.id = %(packageID)i']
         self.joins = [
             'LEFT JOIN events ON build.create_event = events.id',
             'LEFT JOIN package ON build.pkg_id = package.id',
             'LEFT JOIN volume ON build.volume_id = volume.id',
-            'LEFT JOIN users ON build.owner = users.id'
+            'LEFT JOIN users ON build.owner = users.id',
+            'LEFT JOIN users AS promoter ON build.promoter = promoter.id',
         ]
-        
+
         self.maxDiff = None
         self.exports = kojihub.RootExports()
         self.query_executeOne = mock.MagicMock()

tests/test_hub/test_new_build.py

@@ -179,8 +179,8 @@ class TestNewBuild(unittest.TestCase):
         insert_data = {
             "completion_time": "NOW",
             "epoch": "test_epoch",
-            "extra": '{"draft": {"target_release": "test_release", "promoted": false}}',
             "id": 108,
+            "extra": None,
             "owner": 123,
             "pkg_id": 54,
             "release": "test_release,draft_108",

tests/test_hub/test_promote_build.py

@@ -39,9 +39,6 @@ class TestPromoteBuild(unittest.TestCase):
         self.list_tags = mock.patch('kojihub.kojihub.list_tags',
                                     return_value=[{'id': 101}]).start()
         self.set_tag_update = mock.patch('kojihub.kojihub.set_tag_update').start()
-        self.encode_datetime = mock.patch(
-            'kojihub.kojihub.encode_datetime', return_value='NOW'
-        ).start()
         self._now = datetime.datetime.now()
         self._datetime = mock.patch('kojihub.kojihub.datetime.datetime').start()
         self.now = self._datetime.now = mock.MagicMock(return_value=self._now)
@@ -52,11 +49,6 @@ class TestPromoteBuild(unittest.TestCase):
             'version': 'bar',
             'release': 'tgtrel,draft_1',
             'nvr': 'testnvr',
-            'extra': {
-                'draft': {
-                    'promoted': False,
-                    'target_release': 'tgtrel'
-                }},
             'state': 1,
             'draft': True,
             'volume_id': 99,
@@ -83,19 +75,6 @@ class TestPromoteBuild(unittest.TestCase):
             self.new_build
         ]
 
-        extra = json.dumps(
-            {
-                'draft': {
-                    'promoted': True,
-                    'target_release': 'tgtrel',
-                    'old_release': 'tgtrel,draft_1',
-                    'promotion_time': 'NOW',
-                    'promotion_ts': self._now.timestamp(),
-                    'promoter': self.user['name']
-                }
-            }
-        )
-
         ret = self.exports.promoteBuild('a-draft-build')
         self.assertEqual(ret, self.new_build)
         self.assertEqual(len(self.updates), 1)
@@ -103,9 +82,9 @@ class TestPromoteBuild(unittest.TestCase):
         self.assertEqual(update.table, 'build')
         self.assertEqual(update.values, self.draft_build)
         self.assertEqual(update.data, {'draft': False,
-                                       'release': 'tgtrel',
-                                       'extra': extra})
-        self.assertEqual(update.rawdata, {})
+                                       'promoter': self.user['id'],
+                                       'release': 'tgtrel'})
+        self.assertEqual(update.rawdata, {'promotion_time': 'now()'})
         self.assertEqual(update.clauses, ['id=%(id)i'])
         self.apply_volume_policy.assert_called_once_with(
             self.new_build, strict=False
@@ -138,12 +117,6 @@ class TestPromoteBuild(unittest.TestCase):
             # bad delimiter
             'release': 'tgtrel@draft_1',
             'nvr': 'testnvr',
-            'extra': {
-                'draft': {
-                    'promoted': False,
-                    # target_release doesn't matter now
-                    'target_release': 'any'
-                }},
             'state': 1,
             'draft': True,
             'volume_id': 99,
@@ -168,11 +141,6 @@ class TestPromoteBuild(unittest.TestCase):
             'version': 'bar',
             'release': 'tgtrel#draft_1',
             'nvr': 'testnvr',
-            'extra': {
-                'draft': {
-                    'promoted': False,
-                    'target_release': 'any'
-                }},
             'draft': True,
             'state': 0,
             'volume_id': 99,

tests/test_hub/test_read_tagged_builds.py

@@ -6,6 +6,8 @@ import koji
 import kojihub
 import copy
 
+from koji.util import dslice
+
 QP = kojihub.QueryProcessor
 
 
@@ -29,35 +31,32 @@ class TestReadTaggedBuilds(unittest.TestCase):
         self.readPackageList = mock.patch('kojihub.kojihub.readPackageList').start()
         self.lookup_name = mock.patch('kojihub.kojihub.lookup_name').start()
         self.tag_name = 'test-tag'
-        self.columns = ['tag.id', 'tag.name', 'build.id', 'build.version', 'build.release',
-                        'build.epoch', 'build.state', 'build.completion_time', 'build.start_time',
-                        'build.task_id', 'build.draft', 'users.id', 'users.name', 'events.id', 'events.time',
-                        'volume.id', 'volume.name', 'package.id', 'package.name',
-                        'package.name || \'-\' || build.version || \'-\' || build.release',
-                        'tag_listing.create_event']
-        self.fields = [('tag.id', 'tag_id'), ('tag.name', 'tag_name'), ('build.id', 'id'),
-                       ('build.id', 'build_id'), ('build.version', 'version'),
-                       ('build.release', 'release'), ('build.epoch', 'epoch'),
-                       ('build.state', 'state'), ('build.completion_time', 'completion_time'),
-                       ('build.start_time', 'start_time'), ('build.task_id', 'task_id'),
-                       ('build.draft', 'draft'),
-                       ('users.id', 'owner_id'), ('users.name', 'owner_name'),
-                       ('events.id', 'creation_event_id'), ('events.time', 'creation_time'),
-                       ('volume.id', 'volume_id'), ('volume.name', 'volume_name'),
-                       ('package.id', 'package_id'), ('package.name', 'package_name'),
-                       ('package.name', 'name'),
-                       ("package.name || '-' || build.version || '-' || build.release", 'nvr'),
-                       ('tag_listing.create_event', 'create_event')]
+        self.columns = ['build.id', 'build.completion_time', 'tag_listing.create_event',
+                        'events.id', 'events.time', 'build.draft', 'build.epoch', 'build.id',
+                        'package.name',
+                        "package.name || '-' || build.version || '-' || build.release",
+                        'users.id', 'users.name', 'package.id', 'package.name', 'promoter.id',
+                        'promoter.name', 'build.promotion_time', 'build.release',
+                        'build.start_time', 'build.state', 'tag.id', 'tag.name', 'build.task_id',
+                        'build.version', 'volume.id', 'volume.name']
+        self.values = {'owner': None,
+                       'package': None,
+                       'st_complete': 1,
+                       'tagid': self.tag_name,
+                      }
         self.joins = ['tag ON tag.id = tag_listing.tag_id',
                       'build ON build.id = tag_listing.build_id',
                       'events ON events.id = build.create_event',
                       'package ON package.id = build.pkg_id',
                       'volume ON volume.id = build.volume_id',
-                      'users ON users.id = build.owner', ]
-        self.aliases = ['tag_id', 'tag_name', 'id', 'build_id', 'version', 'release', 'epoch',
-                        'state', 'completion_time', 'start_time', 'task_id', 'draft', 'owner_id',
-                        'owner_name', 'creation_event_id', 'creation_time', 'volume_id',
-                        'volume_name', 'package_id', 'package_name', 'name', 'nvr', 'create_event']
+                      'users ON users.id = build.owner',
+                      'LEFT JOIN users AS promoter ON promoter.id = build.promoter',
+                      ]
+        self.aliases = ['build_id', 'completion_time', 'create_event', 'creation_event_id',
+                        'creation_time', 'draft', 'epoch', 'id', 'name', 'nvr', 'owner_id',
+                        'owner_name', 'package_id', 'package_name', 'promoter_id',
+                        'promoter_name', 'promotion_time', 'release', 'start_time', 'state',
+                        'tag_id', 'tag_name', 'task_id', 'version', 'volume_id', 'volume_name']
         self.clauses = ['(tag_listing.active = TRUE)',
                         'tag_id = %(tagid)s',
                         'build.state = %(st_complete)i']
@@ -79,19 +78,14 @@ class TestReadTaggedBuilds(unittest.TestCase):
         self.assertEqual(len(self.queries), 1)
         query = self.queries[0]
 
-        values = {'clauses': self.clauses, 'event': None, 'extra': False, 'fields': self.fields,
-                  'inherit': False, 'joins': self.joins, 'latest': False, 'owner': None,
-                  'package': None, 'packages': self.package_list,
-                  'queryOpts': {'order': '-create_event'}, 'st_complete': 1, 'tables': self.tables,
-                  'tag': self.tag_name, 'tagid': self.tag_name, 'taglist': [self.tag_name],
-                  'type': None, 'draft': None
-                  }
+        values = self.values.copy()
         self.assertEqual(query.tables, self.tables)
         self.assertEqual(query.joins, self.joins)
         self.assertEqual(set(query.columns), set(self.columns))
         self.assertEqual(set(query.aliases), set(self.aliases))
         self.assertEqual(set(query.clauses), set(self.clauses))
-        self.assertEqual(query.values, values)
+        # function passes values=locals(), so we only check the relevant values
+        self.assertEqual(dslice(query.values, values.keys()), values)
 
     def test_get_tagged_builds_package_owner_type_maven_extra(self):
         self.readPackageList.return_value = self.package_list
@@ -106,27 +100,21 @@ class TestReadTaggedBuilds(unittest.TestCase):
                        'maven_builds.version', 'build.extra'])
         aliases = copy.deepcopy(self.aliases)
         aliases.extend(['maven_group_id', 'maven_artifact_id', 'maven_version', 'extra'])
-        fields = copy.deepcopy(self.fields)
-        fields.extend([('maven_builds.group_id', 'maven_group_id'),
-                      ('maven_builds.artifact_id', 'maven_artifact_id'),
-                      ('maven_builds.version', 'maven_version'), ('build.extra', 'extra')])
         clauses = copy.deepcopy(self.clauses)
         clauses.extend(['package.name = %(package)s', 'users.name = %(owner)s'])
         joins = copy.deepcopy(self.joins)
         joins.append('maven_builds ON maven_builds.build_id = tag_listing.build_id')
 
-        values = {'clauses': clauses, 'event': None, 'extra': True, 'fields': fields,
-                  'inherit': False, 'joins': joins, 'latest': False, 'owner': self.username,
-                  'package': self.pkg_name, 'packages': self.package_list,
-                  'queryOpts': {'order': '-create_event'}, 'st_complete': 1, 'tables': self.tables,
-                  'tag': self.tag_name, 'tagid': self.tag_name, 'taglist': [self.tag_name],
-                  'type': 'maven', 'draft': None}
+        values = self.values.copy()
+        values['owner'] = self.username
+        values['package'] = self.pkg_name
         self.assertEqual(query.tables, self.tables)
         self.assertEqual(query.joins, joins)
         self.assertEqual(set(query.columns), set(columns))
         self.assertEqual(set(query.aliases), set(aliases))
         self.assertEqual(set(query.clauses), set(clauses))
-        self.assertEqual(query.values, values)
+        # function passes values=locals(), so we only check the relevant values
+        self.assertEqual(dslice(query.values, values.keys()), values)
 
     def test_get_tagged_builds_type_win_latest(self):
         self.readPackageList.return_value = self.package_list
@@ -139,23 +127,17 @@ class TestReadTaggedBuilds(unittest.TestCase):
         columns.append('win_builds.platform')
         aliases = copy.deepcopy(self.aliases)
         aliases.append('platform')
-        fields = copy.deepcopy(self.fields)
-        fields.append(('win_builds.platform', 'platform'))
         joins = copy.deepcopy(self.joins)
         joins.append('win_builds ON win_builds.build_id = tag_listing.build_id')
 
-        values = {'clauses': self.clauses, 'event': None, 'extra': False, 'fields': fields,
-                  'inherit': False, 'joins': joins, 'latest': True, 'owner': None,
-                  'package': None, 'packages': self.package_list,
-                  'queryOpts': {'order': '-create_event'}, 'st_complete': 1, 'tables': self.tables,
-                  'tag': self.tag_name, 'tagid': self.tag_name, 'taglist': [self.tag_name],
-                  'type': 'win', 'draft': None}
+        values = self.values.copy()
         self.assertEqual(query.tables, self.tables)
         self.assertEqual(query.joins, joins)
         self.assertEqual(set(query.columns), set(columns))
         self.assertEqual(set(query.aliases), set(aliases))
         self.assertEqual(set(query.clauses), set(self.clauses))
-        self.assertEqual(query.values, values)
+        # function passes values=locals(), so we only check the relevant values
+        self.assertEqual(dslice(query.values, values.keys()), values)
 
     def test_get_tagged_builds_type_image(self):
         self.readPackageList.return_value = self.package_list
@@ -168,23 +150,17 @@ class TestReadTaggedBuilds(unittest.TestCase):
         columns.append('image_builds.build_id')
         aliases = copy.deepcopy(self.aliases)
         aliases.append('build_id')
-        fields = copy.deepcopy(self.fields)
-        fields.append(('image_builds.build_id', 'build_id'))
         joins = copy.deepcopy(self.joins)
         joins.append('image_builds ON image_builds.build_id = tag_listing.build_id')
 
-        values = {'clauses': self.clauses, 'event': None, 'extra': False, 'fields': fields,
-                  'inherit': False, 'joins': joins, 'latest': False, 'owner': None,
-                  'package': None, 'packages': self.package_list,
-                  'queryOpts': {'order': '-create_event'}, 'st_complete': 1, 'tables': self.tables,
-                  'tag': self.tag_name, 'tagid': self.tag_name, 'taglist': [self.tag_name],
-                  'type': 'image', 'draft': None}
+        values = self.values.copy()
         self.assertEqual(query.tables, self.tables)
         self.assertEqual(query.joins, joins)
         self.assertEqual(set(query.columns), set(columns))
         self.assertEqual(set(query.aliases), set(aliases))
         self.assertEqual(set(query.clauses), set(self.clauses))
-        self.assertEqual(query.values, values)
+        # function passes values=locals(), so we only check the relevant values
+        self.assertEqual(dslice(query.values, values.keys()), values)
 
     def test_get_tagged_builds_type_non_exist(self):
         self.readPackageList.return_value = self.package_list
@@ -207,19 +183,14 @@ class TestReadTaggedBuilds(unittest.TestCase):
         joins = copy.deepcopy(self.joins)
         joins.append('build_types ON build.id = build_types.build_id AND btype_id = %(btype_id)s')
 
-        values = {'btype': typeinfo, 'btype_id': typeinfo['id'], 'clauses': self.clauses,
-                  'event': None, 'extra': False, 'fields': self.fields,
-                  'inherit': False, 'joins': joins, 'latest': False, 'owner': None,
-                  'package': None, 'packages': self.package_list,
-                  'queryOpts': {'order': '-create_event'}, 'st_complete': 1, 'tables': self.tables,
-                  'tag': self.tag_name, 'tagid': self.tag_name, 'taglist': [self.tag_name],
-                  'type': type, 'draft': None}
+        values = self.values.copy()
         self.assertEqual(query.tables, self.tables)
         self.assertEqual(query.joins, joins)
         self.assertEqual(set(query.columns), set(self.columns))
         self.assertEqual(set(query.aliases), set(self.aliases))
         self.assertEqual(set(query.clauses), set(self.clauses))
-        self.assertEqual(query.values, values)
+        # function passes values=locals(), so we only check the relevant values
+        self.assertEqual(dslice(query.values, values.keys()), values)
     
     def test_get_tagged_builds_draft(self):
         self.readPackageList.return_value = self.package_list
@@ -231,17 +202,11 @@ class TestReadTaggedBuilds(unittest.TestCase):
         clauses = copy.deepcopy(self.clauses)
         clauses.extend(['draft IS TRUE'])
 
-        values = {'clauses': clauses, 'event': None, 'extra': False, 'fields': self.fields,
-                  'inherit': False, 'joins': self.joins, 'latest': False, 'owner': None,
-                  'package': None, 'packages': self.package_list,
-                  'queryOpts': {'order': '-create_event'}, 'st_complete': 1, 'tables': self.tables,
-                  'tag': self.tag_name, 'tagid': self.tag_name, 'taglist': [self.tag_name],
-                  'type': None, 'draft': True
-                  }
-
+        values = self.values.copy()
         self.assertEqual(query.tables, self.tables)
         self.assertEqual(query.joins, self.joins)
         self.assertEqual(set(query.columns), set(self.columns))
         self.assertEqual(set(query.aliases), set(self.aliases))
         self.assertEqual(set(query.clauses), set(clauses))
-        self.assertEqual(query.values, values)
+        # function passes values=locals(), so we only check the relevant values
+        self.assertEqual(dslice(query.values, values.keys()), values)