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))