def test_results_for_module_returns_correct_results(self):
TR1_MODULE1_A = create_test_results(module_name='module1')
TR1_MODULE1_B = create_test_results(module_name='module1')
TESTS_RESULTS1 = TestsResults([
TR1_MODULE1_A,
TR1_MODULE1_B,
create_test_results(module_name='module2'),
])
TESTS_RESULTS2 = TestsResults(
[create_test_results(module_name='module3')])
TR3_MODULE1 = create_test_results(module_name='module1')
TESTS_RESULTS3 = TestsResults([TR3_MODULE1])
COMMIT1 = create_commit()
COMMIT2 = create_commit()
COMMIT3 = create_commit()
commits_results = CommitsResults([
CommitResults(COMMIT1, TESTS_RESULTS1),
CommitResults(COMMIT2, TESTS_RESULTS2),
CommitResults(COMMIT3, TESTS_RESULTS3)
])
rfm1 = commits_results.results_for_module('module1')
self.assertEqual(len(rfm1), len(commits_results))
self.assertEqual(len(rfm1[0].results), 2)
self.assertEqual(rfm1[0].commit, COMMIT1)
self.assertEqual(rfm1[0].results[0], TR1_MODULE1_A)
self.assertEqual(rfm1[0].results[1], TR1_MODULE1_B)
self.assertEqual(len(rfm1[1].results), 0)
self.assertEqual(rfm1[1].commit, COMMIT2)
self.assertEqual(len(rfm1[2].results), 1)
self.assertEqual(rfm1[2].commit, COMMIT3)
self.assertEqual(rfm1[2].results[0], TR3_MODULE1)
def test_module_names_sorts_them_so_external_and_integration_tests_are_put_first(
self):
commits_results = CommitsResults([
CommitResults(
create_commit(),
TestsResults([
create_test_results(module_name='bugs.1537'),
create_test_results(module_name='tools.fileinfo.sample')
])),
CommitResults(
create_commit(),
TestsResults([
create_test_results(module_name='integration.current.ack'),
create_test_results(
module_name='integration.2015-03-30.ack')
])),
CommitResults(
create_commit(),
TestsResults([
create_test_results(module_name='external.unit-tests'),
]))
])
self.assertEqual(commits_results.module_names, [
'external.unit-tests', 'integration.current.ack',
'integration.2015-03-30.ack', 'bugs.1537', 'tools.fileinfo.sample'
])
def test_module_names_returns_correct_names(self):
TESTS_RESULTS = TestsResults([
create_test_results(module_name='module2'),
create_test_results(module_name='module1'),
create_test_results(
module_name='module2') # same as the first name
])
commit_results = CommitResults(create_commit(), TESTS_RESULTS)
self.assertEqual(commit_results.module_names, ['module1', 'module2'])
def test_has_results_for_non_critical_tests_returns_true_when_there_are_non_critical_results(
self):
commit_results = CommitResults(
create_commit(),
TestsResults([
create_test_results(critical=False),
create_test_results(critical=True),
create_test_results(critical=False)
]))
self.assertTrue(commit_results.has_results_for_non_critical_tests())
def test_results_returns_correct_results(self):
TESTS_RESULTS1 = TestsResults(
[create_test_results(module_name='module1')])
TESTS_RESULTS2 = TestsResults(
[create_test_results(module_name='module2')])
commits_results = CommitsResults([
CommitResults(create_commit(), TESTS_RESULTS1),
CommitResults(create_commit(), TESTS_RESULTS2)
])
self.assertEqual(commits_results.results,
[TESTS_RESULTS1, TESTS_RESULTS2])
def test_get_commit_for_non_critical_tests_returns_none_when_no_commit_in_max_depth(self):
commit1 = create_commit()
self.db.insert_commit(commit1)
test_results1 = create_test_results(critical=True)
self.db.insert_test_results(test_results1, commit1)
commit2 = create_commit()
self.db.insert_commit(commit2)
test_results2 = create_test_results(critical=False, run_tests=2, failed_tests=0)
self.db.insert_test_results(test_results2, commit2)
self.assertIsNone(self.db.get_commit_for_non_critical_tests(1))
def test_get_commit_for_non_critical_tests_returns_correct_commit_when_topmost_not_passed_non_critical_tests(self):
commit1 = create_commit()
self.db.insert_commit(commit1)
test_results1 = create_test_results(critical=True)
self.db.insert_test_results(test_results1, commit1)
commit2 = create_commit()
self.db.insert_commit(commit2)
test_results2 = create_test_results(critical=False, run_tests=2, failed_tests=1)
self.db.insert_test_results(test_results2, commit2)
self.assertEqual(self.db.get_commit_for_non_critical_tests(), commit1)
def test_get_results_for_commit_returns_correct_results_when_there_are_results(self):
commit = create_commit()
self.db.insert_commit(commit)
test_results1 = create_test_results(module_name='module1', run_tests=1)
self.db.insert_test_results(test_results1, commit)
test_results2 = create_test_results(module_name='module2', run_tests=3)
self.db.insert_test_results(test_results2, commit)
commit_results = self.db.get_results_for_commit(commit)
self.assertEqual(commit_results.commit, commit)
self.assertEqual(commit_results.results.run_tests, 4)
self.assertEqual(commit_results.results.module_names, ['module1', 'module2'])
def test_get_commit_for_non_critical_tests_returns_none_when_all_commits_have_run_non_critical_tests(self):
commit = create_commit()
self.db.insert_commit(commit)
test_results = create_test_results(critical=False, run_tests=2, failed_tests=1)
self.db.insert_test_results(test_results, commit)
self.assertIsNone(self.db.get_commit_for_non_critical_tests())
def test_has_test_run_for_commit_returns_true_if_has_run(self):
commit = create_commit()
self.db.insert_commit(commit)
test_results = create_test_results(module_name='module',
case_name='case')
self.db.insert_test_results(test_results, commit)
self.assertTrue(
self.db.has_test_run_for_commit('module', 'case', commit))
def test_has_test_run_for_commit_returns_false_if_case_has_not_run_commit_does_not_match(self):
commit1 = create_commit()
self.db.insert_commit(commit1)
test_results = create_test_results(module_name='module', case_name='case')
self.db.insert_test_results(test_results, commit1)
commit2 = create_commit()
self.db.insert_commit(commit2)
self.assertFalse(self.db.has_test_run_for_commit('module', 'case', commit2))
def test_failed_module_names_returns_correct_value(self):
commit_results = CommitResults(
create_commit(),
TestsResults([
create_test_results(module_name='module',
run_tests=2,
failed_tests=1)
]))
self.assertEqual(commit_results.failed_module_names, ['module'])
def test_initialize_commit_records_clears_results_when_results_are_present(self):
commit = create_commit()
self.db.insert_commit(commit)
test_results = create_test_results(module_name='module', run_tests=1)
self.db.insert_test_results(test_results, commit)
self.db.initialize_commit_records(commit)
commit_results = self.db.get_results_for_commit(commit)
self.assertFalse(commit_results.has_results())
def test_initialize_commit_records_does_not_clear_results_when_forced_not_to(self):
commit = create_commit()
self.db.insert_commit(commit)
test_results = create_test_results(module_name='module', run_tests=1)
self.db.insert_test_results(test_results, commit)
self.db.initialize_commit_records(commit, remove_test_results=False)
commit_results = self.db.get_results_for_commit(commit)
self.assertTrue(commit_results.has_results())
def test_topmost_commit_has_succeeded_returns_true_if_succeeded(self):
commit1 = create_commit()
self.db.insert_commit(commit1)
build_id = self.db.insert_build_started_info(commit1, datetime.now())
self.db.insert_build_ended_info(build_id, create_build_info())
test_results1 = create_test_results(
module_name='module', run_tests=1, failed_tests=1)
self.db.insert_test_results(test_results1, commit1)
# Topmost commit.
commit2 = create_commit()
self.db.insert_commit(commit2)
build_id = self.db.insert_build_started_info(commit2, datetime.now())
self.db.insert_build_ended_info(build_id, create_build_info())
test_results2 = create_test_results(
module_name='module', run_tests=1, failed_tests=0)
self.db.insert_test_results(test_results2, commit2)
self.assertTrue(self.db.topmost_commit_has_succeeded())
def test_module_names_returns_correct_names(self):
commits_results = CommitsResults([
CommitResults(
create_commit(),
TestsResults([
create_test_results(module_name='module2'),
create_test_results(module_name='module1'),
create_test_results(
module_name='module2') # same as the first name
])),
CommitResults(
create_commit(),
TestsResults([
create_test_results(module_name='module3'),
create_test_results(module_name='module1')
]))
])
self.assertEqual(commits_results.module_names,
['module1', 'module2', 'module3'])
def test_topmost_commit_has_succeeded_returns_false_if_test_failed(self):
commit = create_commit()
self.db.insert_commit(commit)
build_id = self.db.insert_build_started_info(commit, datetime.now())
self.db.insert_build_ended_info(build_id, create_build_info())
test_results = create_test_results(
module_name='module', run_tests=2, failed_tests=1)
self.db.insert_test_results(test_results, commit)
self.assertFalse(self.db.topmost_commit_has_succeeded())
def test_creates_correct_email_when_no_test_failed(self):
commit_results = CommitResults(
self.commit,
TestsResults([create_test_results(run_tests=3, failed_tests=0)]),
create_build_info(succeeded=True))
email = prepare_email(commit_results, self.subject_prefix,
self.web_url, self.wiki_page_url)
self.assertRegex(email.body, r'unknown failure')
def test_creates_correct_email_when_two_tests_failed_in_two_modules(self):
commit_results = CommitResults(
self.commit,
TestsResults([
create_test_results(module_name='module1',
case_name='Test (input.exe)',
run_tests=3,
failed_tests=1),
create_test_results(module_name='module2',
case_name='Test (input.exe)',
run_tests=1,
failed_tests=1)
]), create_build_info(succeeded=True))
email = prepare_email(commit_results, self.subject_prefix,
self.web_url, self.wiki_page_url)
self.assertRegex(email.body,
r'2 tests failed in the following modules:')
self.assertRegex(email.body, r'module1')
self.assertRegex(email.body, r'module2')
def test_results_for_case_returns_correct_results(self):
TR1_MODULE1_CASEA = create_test_results(module_name='module1',
case_name='caseA')
TESTS_RESULTS1 = TestsResults([
TR1_MODULE1_CASEA,
create_test_results(module_name='module1', case_name='caseB'),
create_test_results(module_name='module2', case_name='caseC')
])
TESTS_RESULTS2 = TestsResults(
[create_test_results(module_name='module2', case_name='caseD')])
TR3_MODULE1_CASEA = create_test_results(module_name='module1',
case_name='caseA')
TESTS_RESULTS3 = TestsResults([
TR3_MODULE1_CASEA,
create_test_results(module_name='module2', case_name='caseF')
])
COMMIT1 = create_commit()
COMMIT2 = create_commit()
COMMIT3 = create_commit()
commits_results = CommitsResults([
CommitResults(COMMIT1, TESTS_RESULTS1),
CommitResults(COMMIT2, TESTS_RESULTS2),
CommitResults(COMMIT3, TESTS_RESULTS3)
])
rfm1cA = commits_results.results_for_case('module1', 'caseA')
self.assertEqual(len(rfm1cA), 3)
self.assertEqual(rfm1cA[0].results, TR1_MODULE1_CASEA)
self.assertEqual(rfm1cA[0].commit, COMMIT1)
self.assertIsInstance(rfm1cA[1].results, NoTestResults)
self.assertEqual(rfm1cA[1].commit, COMMIT2)
self.assertEqual(rfm1cA[2].results, TR3_MODULE1_CASEA)
self.assertEqual(rfm1cA[2].commit, COMMIT3)
def test_case_names_for_module_returns_correct_names(self):
commits_results = CommitsResults([
CommitResults(
create_commit(),
TestsResults([
create_test_results(module_name='module1',
case_name='caseA'),
create_test_results(module_name='module1',
case_name='caseB'),
create_test_results(module_name='module2',
case_name='caseC')
])),
CommitResults(
create_commit(),
TestsResults([
create_test_results(module_name='module1',
case_name='caseD'),
create_test_results(module_name='module2',
case_name='caseE')
]))
])
self.assertEqual(commits_results.case_names_for_module('module1'),
['caseA', 'caseB', 'caseD'])
def test_creates_correct_body_when_one_test_failed_in_one_module(self):
commit_results = CommitResults(
self.commit,
TestsResults([
create_test_results(module_name='module1',
run_tests=3,
failed_tests=1)
]), create_build_info(succeeded=True))
email = prepare_email(commit_results, self.subject_prefix,
self.web_url, self.wiki_page_url)
self.assertRegex(email.body, r'1 test failed in the following module:')
self.assertRegex(email.body, r'module1')
def test_insert_test_results_raises_invalid_commit_error_when_no_such_commit(
self):
commit = create_commit()
with self.assertRaises(InvalidCommitError):
self.db.insert_test_results(create_test_results(), commit)
def test_failed_tests_returns_correct_value(self):
commit_results = CommitResults(
create_commit(),
TestsResults([create_test_results(run_tests=3, failed_tests=2)]))
self.assertEqual(commit_results.failed_tests, 2)
def test_has_failed_tests_returns_false_if_no_test_failed(self):
commit_results = CommitResults(
create_commit(),
TestsResults([create_test_results(run_tests=1, failed_tests=0)]))
self.assertFalse(commit_results.has_failed_tests())
def test_has_results_returns_true_when_there_are_results(self):
commit_results = CommitResults(create_commit(),
TestsResults([create_test_results()]))
self.assertTrue(commit_results.has_results())
