def test_get_baselineid(self, mock_sql):
"""Ensure get_baselineid() returns baseline_id."""
testdb = skt_db(self.database_file)
mock_sql.connect().cursor().fetchone.return_value = [1]
result = testdb.get_baselineid('baserepo_id', 'abcdef')
self.assertEqual(result, 1)
def test_get_baselineid_empty(self, mock_sql):
"""Ensure get_baselineid() returns None when no baseline_id exists."""
testdb = skt_db(self.database_file)
mock_sql.connect().cursor().fetchone.return_value = None
result = testdb.get_baselineid('baserepo_id', 'abcdef')
self.assertIsNone(result)
def test_create_repoid(self, mock_sql):
"""Ensure create_repoid() inserts into DB and retrieves a repoid."""
testdb = skt_db(self.database_file)
mock_sql.connect().cursor().lastrowid = 1
result = testdb.create_repoid('git://example.com/repo')
self.assertEqual(result, 1)
def test_get_series_result_empty(self, mock_sql):
"""Ensure None is returned when the results list is empty."""
testdb = skt_db(self.database_file)
mock_sql.connect().cursor().fetchone.return_value = None
result = testdb.get_series_result(1)
self.assertIsNone(result)
def test_commit_series_without_id(self, mock_sql, mock_get_sourceid,
mock_commit_patch, mock_log):
"""Ensure commit_series() creates patch records without series_id."""
testdb = skt_db(self.database_file)
mock_get_sourceid.return_value = '1'
mock_commit_patch.return_value = None
mock_sql.connect().cursor().fetchone.return_value = [10]
patches = [(['patch_id'], 'patch_name', 'patch_url', 'base_url',
'project_id', 'patch_date')]
result = testdb.commit_series(patches, None)
self.assertEqual(result, 11)
# Check if we have a proper SELECT query executed for the series_id
# lookup
execute_call_args = mock_sql.connect().cursor().execute.call_args[0]
self.assertIn('SELECT series_id FROM patch', execute_call_args[0])
mock_get_sourceid.assert_called_once()
mock_commit_patch.assert_called_once()
mock_log.assert_called()
# Ensure the data was committed to the database
mock_sql.connect().commit.assert_called()
def test_last_pending_patch(self, mock_sql):
"""Ensure get_last_pending_patch() returns a patch id."""
testdb = skt_db(self.database_file)
mock_sql.connect().cursor().fetchone.return_value = [1]
result = testdb.get_last_pending_patch('baseurl', 'project_id')
self.assertEqual(result, 1)
def test_get_series_result(self, mock_sql):
"""Ensure a testrun.result_id is returned."""
testdb = skt_db(self.database_file)
mock_sql.connect().cursor().fetchone.return_value = [1]
result = testdb.get_series_result(1)
self.assertEqual(result, 1)
def test_last_pending_patch_missing(self, mock_sql):
"""Ensure None is returned when no patches match."""
testdb = skt_db(self.database_file)
mock_sql.connect().cursor().fetchone.return_value = None
result = testdb.get_last_pending_patch('baseurl', 'project_id')
self.assertIsNone(result)
def test_get_sourceid(self, mock_sql):
"""Ensure get_sourceid() retrieves a patchsource id."""
testdb = skt_db(self.database_file)
mock_sql.connect().cursor().fetchone.return_value = [1]
result = testdb.get_sourceid('git://example.com/repo', 10)
self.assertEqual(result, 1)
def test_get_sourceid_missing(self, mock_sql):
"""Ensure get_sourceid() creates patchsource when it doesn't exist."""
testdb = skt_db(self.database_file)
mock_sql.connect().cursor().fetchone.return_value = None
mock_sql.connect().cursor().lastrowid = 1
result = testdb.get_sourceid('git://example.com/repo', 10)
self.assertEqual(result, 1)
def test_get_baselineresult_empty(self, mock_sql, mock_get_repoid):
"""Ensure get_baselineresult() returns None for empty results."""
testdb = skt_db(self.database_file)
mock_get_repoid.return_value = 1
mock_sql.connect().cursor().fetchone.return_value = None
result = testdb.get_baselineresult('baserepo_id', 'abcdef')
self.assertIsNone(result)
def test_get_stable(self, mock_sql, mock_get_repoid):
"""Ensure get_stable() returns baseline_id."""
testdb = skt_db(self.database_file)
mock_get_repoid.return_value = 1
mock_sql.connect().cursor().fetchone.return_value = [1]
result = testdb.get_stable('baserepo_id')
self.assertEqual(result, 1)
def test_get_stable_empty(self, mock_sql, mock_get_repoid):
"""Ensure get_stable() returns None when results are empty."""
testdb = skt_db(self.database_file)
mock_get_repoid.return_value = 1
mock_sql.connect().cursor().fetchone.return_value = None
result = testdb.get_stable('baserepo_id')
self.assertIsNone(result)
def test_get_commitdate_empty(self, mock_sql, mock_get_repoid):
"""Ensure get_commitdate() returns None when no baselines match."""
testdb = skt_db(self.database_file)
mock_get_repoid.return_value = 1
mock_sql.connect().cursor().fetchone.return_value = None
result = testdb.get_commitdate('baserepod', 'abcdef')
self.assertIsNone(result)
def test_expired_pending_patches_empty(self, mock_sql, mock_get_sourceid):
"""Test with an empty list of expired pending patches."""
# pylint: disable=invalid-name
testdb = skt_db(self.database_file)
mock_get_sourceid.return_value = '1'
mock_sql.connect().cursor().fetchall.return_value = []
result = testdb.get_expired_pending_patches('baseurl', 'project_id')
self.assertEqual(result, [])
def test_set_patchset_pending(self, mock_sql, mock_log):
"""Ensure patches are added to the pendingpatch table."""
testdb = skt_db(self.database_file)
testdb.set_patchset_pending('baseurl', '1', [('1', '2018-06-04')])
mock_sql.connect().cursor().executemany.assert_called_once()
mock_sql.connect().commit.assert_called()
mock_log.assert_called_once()
# Check if we have a proper INSERT query executed
execute_call_args = mock_sql.connect().cursor().executemany.\
call_args[0]
self.assertIn('INSERT OR REPLACE INTO pendingpatches',
execute_call_args[0])
def test_commit_patch(self, mock_sql, mock_get_sourceid, mock_log):
"""Ensure commit_patch() creates/updates a patch record."""
testdb = skt_db(self.database_file)
mock_get_sourceid.return_value = '1'
testdb.commit_patch('1', '2', '3', '4', '5', '6', '7')
# Check if we have a proper INSERT query executed
execute_call_args = mock_sql.connect().cursor().execute.call_args[0]
self.assertIn('INSERT OR REPLACE INTO patch', execute_call_args[0])
self.assertTupleEqual(('1', '2', '3', '1', '4', '7'),
execute_call_args[1])
mock_log.assert_called()
# Ensure the data was committed to the database
mock_sql.connect().commit.assert_called()
def test_unset_patchset_pending(self, mock_sql, mock_get_sourceid,
mock_log):
"""Ensure patches are removed from the pendingpatch table."""
testdb = skt_db(self.database_file)
mock_get_sourceid.return_value = 1
testdb.unset_patchset_pending('baseurl', '1', ['1'])
# Ensure a debug log was written
mock_log.assert_called_once()
# Check if we have a proper DELETE query executed
execute_call_args = mock_sql.connect().cursor().executemany.\
call_args[0]
self.assertIn('DELETE FROM pendingpatches', execute_call_args[0])
self.assertEqual([('1', 1)], execute_call_args[1])
# Ensure the data was committed to the database
mock_sql.connect().commit.assert_called()
def test_commit_series_with_id(self, mock_sql, mock_get_sourceid,
mock_commit_patch, mock_log):
"""Ensure commit_series() creates patch records with a series_id."""
testdb = skt_db(self.database_file)
mock_get_sourceid.return_value = '1'
mock_commit_patch.return_value = None
patches = [(['patch_id'], 'patch_name', 'patch_url', 'base_url',
'project_id', 'patch_date')]
result = testdb.commit_series(patches, 10)
self.assertEqual(result, 10)
mock_get_sourceid.assert_called_once()
mock_commit_patch.assert_called_once()
mock_log.assert_called()
# Ensure the data was committed to the database
mock_sql.connect().commit.assert_called()
def test_update_baseline_not_newer(self, mock_sql, mock_get_repoid,
mock_commit_testrun,
mock_get_baselineresult, mock_log):
"""Ensure baseline is updated when current result is older."""
# pylint: disable=too-many-arguments
testdb = skt_db(self.database_file)
mock_sql.reset_mock()
mock_get_repoid.return_value = '1'
mock_commit_testrun.return_value = '1'
mock_get_baselineresult.return_value = 2
testdb.update_baseline('baserepo', 'abcdef', '2018-06-01', 1, '1')
# Ensure a debug log was written
mock_log.assert_called()
# Ensure we didn't execute any SQL queries or run a commit
mock_sql.connect().cursor().execute.assert_not_called()
mock_sql.connect().commit.assert_not_called()
def test_commit_testrun(self, mock_sql, mock_log):
"""Ensure commit_testrun() creates a testrun record."""
testdb = skt_db(self.database_file)
result = mock.Mock()
result.value = 'ok'
mock_sql.connect().cursor().lastrowid = 1
result = testdb.commit_testrun(result, '2')
self.assertEqual(result, 1)
# Check if we have a proper INSERT query executed
execute_call_args = mock_sql.connect().cursor().execute.call_args[0]
self.assertIn('INSERT INTO testrun', execute_call_args[0])
self.assertTupleEqual(('ok', '2'), execute_call_args[1])
mock_log.assert_called()
# Ensure the data was committed to the database
mock_sql.connect().commit.assert_called()
def test_update_baseline(self, mock_sql, mock_get_repoid,
mock_commit_testrun, mock_get_baselineresult,
mock_log):
"""Ensure baseline is updated when current result is newer."""
# pylint: disable=too-many-arguments
testdb = skt_db(self.database_file)
mock_get_repoid.return_value = '1'
mock_commit_testrun.return_value = '1'
mock_get_baselineresult.return_value = 1
testdb.update_baseline('baserepo', 'abcdef', '2018-06-01', '2', '1')
# Ensure a debug log was written
mock_log.assert_called()
# Check if we have a proper INSERT query executed
execute_call_args = mock_sql.connect().cursor().execute.call_args[0]
self.assertIn('UPDATE baseline', execute_call_args[0])
self.assertTupleEqual(('1', 'abcdef', '1'), execute_call_args[1])
# Ensure the data was committed to the database
mock_sql.connect().commit.assert_called()
def test_commit_patchtest(self, mock_sql, mock_get_repoid,
mock_commit_testrun, mock_get_baselineid,
mock_commit_series, mock_unset_patchset_pending):
"""Ensure baseline is updated when current result is newer."""
# pylint: disable=too-many-arguments
testdb = skt_db(self.database_file)
mock_get_repoid.return_value = '1'
mock_commit_testrun.return_value = '2'
mock_get_baselineid.return_value = '3'
mock_commit_series.return_value = '4'
mock_unset_patchset_pending.return_value = None
patches = [(['patch_id'], 'patch_name', 'patch_url', 'base_url',
'project_id', 'patch_date')]
testdb.commit_patchtest('baserepo', 'abcdef', patches, '5', '6', '7')
# Check if we have a proper INSERT query executed
execute_call_args = mock_sql.connect().cursor().execute.call_args[0]
self.assertIn('INSERT INTO patchtest', execute_call_args[0])
self.assertTupleEqual(('4', '3', '2'), execute_call_args[1])
# Ensure the data was committed to the database
mock_sql.connect().commit.assert_called()
def test_db_create_already_exists(self):
"""Ensure skt_db() creates a database file when it doesn't exist."""
sqlite3.connect(self.database_file)
skt_db(self.database_file)
self.assertTrue(os.path.isfile(self.database_file))
