def test_assertion(self): result = {'a': 1, 'b': 2} r = AsyncResultMock(result=result) # monkey patch r._get_children = _get_children_asserts self.assertDictEqual(get_results(r, return_keys_only=False), result) self.assertDictEqual(get_results(r), {})
def process_sync(self, root_task_result_promise, chain_args): try: wait_on_async_results(root_task_result_promise) chain_results, unsuccessful_services = get_results(root_task_result_promise, return_keys=('chain_results', 'unsuccessful_services')) self.check_for_failures(root_task_result_promise, unsuccessful_services) except ChainRevokedException as e: logger.error(e) if isinstance(e, ChainRevokedPreRunException): # Only in this case do we do the shutdown here; in the regular sync revoke case we do # the shutdown in root_task post_run signal, so that we have time to cleanup (cleanup code # may still run in a finally: clause even when result is marked ready and state == REVOKED) self.main_error_exit_handler(chain_details=(root_task_result_promise, chain_args), reason='Sync run: ChainRevokedException from root task') logger.debug('Root task revoked; cleanup will be done on root task completion') self.copy_submission_log() sys.exit(-1) except Exception as e: logger.debug(e, exc_info=True) self.main_error_exit_handler(chain_details=(root_task_result_promise, chain_args), reason=str(e)) rc = e.firex_returncode if isinstance(e, FireXReturnCodeException) else -1 sys.exit(rc) else: return chain_results
def create_completed_run_json(uid, chain, root_id, submission_dir, argv, original_cli, json_file, run_revoked): data = FireXJsonReportGenerator.get_common_run_data( uid=uid, chain=chain, submission_dir=submission_dir, argv=argv, original_cli=original_cli) data['completed'] = True data['results'] = get_results(root_id) data['revoked'] = run_revoked report_file = os.path.join( uid.logs_dir, FireXJsonReportGenerator.reporter_dirname, FireXJsonReportGenerator.completion_report_filename) FireXJsonReportGenerator.write_report_file(data, report_file) report_link = os.path.join( uid.logs_dir, FireXJsonReportGenerator.report_link_filename) create_link(report_file, report_link, relative=True) if json_file: try: # This is typically not required, unless post_run ran before pre_run create_link(report_link, json_file, delete_link=False, relative=True) except FileExistsError: # This is expected for most cases pass
def test_return_keys(self): with self.subTest('return_keys'): return_keys = {RETURN_KEYS_KEY: ('a', 'b', 'c', 'd')} values = {'a': 1, 'b': 2, 'c': 3, 'd': 4} result = values.copy() result.update(**return_keys) r = AsyncResultMock(result=result) with self.subTest('string'): self.assertTupleEqual(get_results(r, return_keys='a'), (1, )) with self.subTest('tuple of one'): self.assertTupleEqual(get_results(r, return_keys=('a', )), (1, )) with self.subTest('tuple of two'): self.assertTupleEqual(get_results(r, return_keys=('b', 'd')), (2, 4)) with self.subTest('None'): self.assertDictEqual(get_results(r, return_keys=None), values) with self.subTest('Non-existent key'): self.assertTupleEqual(get_results(r, return_keys=('b', 'z')), (2, None))
def RunTests(self, uid): ut_promise = self.enqueue_child(RunUnitTests.s(uid)) it_promise = self.enqueue_child(RunAllIntegrationTests.s(uid)) self.wait_for_children() unit_tests_xunit, unit_tests_coverage_dat = get_results( ut_promise, return_keys=('unit_tests_xunit', 'unit_tests_coverage_dat')) integration_tests_xunits, integration_tests_coverage_dats = get_results( it_promise, return_keys=('integration_tests_xunits', 'integration_tests_coverage_dats')) xunit_result_files = [unit_tests_xunit] + integration_tests_xunits coverage_files = [unit_tests_coverage_dat ] + integration_tests_coverage_dats self.enqueue_child( AggregateXunit.s(uid=uid, xunit_result_files=xunit_result_files)) self.enqueue_child( AggregateCoverage.s(uid=uid, coverage_files=coverage_files) | GenerateHtmlCoverage.s(coverage_dat_file='@aggregated_coverage_dat')) self.wait_for_children()
def test_extract_with_dynamic_return(self): with self.subTest( 'return keys is the string FireXTask.DYNAMIC_RETURN'): result = {'a': 1, 'b': 2, 'c': 3, RETURN_KEYS_KEY: ('a', 'b')} r = AsyncResultMock(result=result) self.assertDictEqual( get_results(r, return_keys=FireXTask.DYNAMIC_RETURN), { 'a': 1, 'b': 2 }) with self.subTest( 'return keys is the tuple (FireXTask.DYNAMIC_RETURN, )'): result = {'a': 1, 'b': 2, 'c': 3, RETURN_KEYS_KEY: ('a', 'b')} r = AsyncResultMock(result=result) self.assertDictEqual( get_results(r, return_keys=(FireXTask.DYNAMIC_RETURN, )), { 'a': 1, 'b': 2 }) with self.subTest( 'return keys is the tuple (FireXTask.DYNAMIC_RETURN, "a")'): result = {'a': 1, 'b': 2, 'c': 3, RETURN_KEYS_KEY: ('a', 'b')} r = AsyncResultMock(result=result) v1, v2 = get_results(r, return_keys=(FireXTask.DYNAMIC_RETURN, "a")) self.assertDictEqual(v1, {'a': 1, 'b': 2}) self.assertEqual(v2, 1) with self.subTest( 'return keys is the tuple ("a", FireXTask.DYNAMIC_RETURN)'): result = {'a': 1, 'b': 2, 'c': 3, RETURN_KEYS_KEY: ('a', 'b')} r = AsyncResultMock(result=result) v1, v2 = get_results(r, return_keys=("a", FireXTask.DYNAMIC_RETURN)) self.assertEqual(v1, 1) self.assertDictEqual(v2, {'a': 1, 'b': 2})
def test_extract_task_returns_only(self): with self.subTest('plain case'): return_keys = ('a', 'b') result = {'a': 1, 'b': 2, 'c': 3, RETURN_KEYS_KEY: return_keys} r = AsyncResultMock(result=result) self.assertDictEqual(get_results(r, merge_children_results=True), {k: result[k] for k in return_keys}) with self.subTest('return keys is None'): result = {'a': 1, 'b': 2, 'c': 3, RETURN_KEYS_KEY: None} r = AsyncResultMock(result=result) self.assertDictEqual(get_results(r, merge_children_results=True), {}) with self.subTest('some of the return keys are non-existent'): result = {'a': 1, 'b': 2, 'c': 3, RETURN_KEYS_KEY: ('a', 'd')} r = AsyncResultMock(result=result) self.assertDictEqual(get_results(r, merge_children_results=True), {}) with self.subTest('child has a return key'): result = {'a': 1, 'b': 2} c1_result = {'c': 3, 'd': 4, 'a': 5, RETURN_KEYS_KEY: ('d', )} c2_result = {'e': 6, 'c': 7} c1 = AsyncResultMock(result=c1_result) c2 = AsyncResultMock(result=c2_result) r = AsyncResultMock(result=result, children=[c1, c2]) self.assertDictEqual(get_results(r, merge_children_results=True), {'d': 4}) with self.subTest('parent and child have return keys'): return_keys = ('a', ) result = {'a': 1, 'b': 2, RETURN_KEYS_KEY: return_keys} c1_result = {'c': 3, 'd': 4, 'a': 5, RETURN_KEYS_KEY: ('d', )} c2_result = {'e': 6, 'c': 7} c1 = AsyncResultMock(result=c1_result) c2 = AsyncResultMock(result=c2_result) r = AsyncResultMock(result=result, children=[c1, c2]) self.assertDictEqual(get_results(r, merge_children_results=True), { 'a': 1, 'd': 4 }) with self.subTest('parent and child have empty return keys'): result = {'a': 1, 'b': 2, RETURN_KEYS_KEY: tuple()} c1_result = {'c': 3, 'd': 4, 'a': 5, RETURN_KEYS_KEY: ('d', )} c2_result = {'e': 6, 'c': 7, RETURN_KEYS_KEY: None} c1 = AsyncResultMock(result=c1_result) c2 = AsyncResultMock(result=c2_result) r = AsyncResultMock(result=result, children=[c1, c2]) self.assertDictEqual(get_results(r, merge_children_results=True), {'d': 4})
def test_result_with_children_with_unsuccessful(self): result = {'a': 1, 'b': 2} c1_result = {'c': 3, 'd': 4, 'a': 5} c2_result = {'e': 6, 'c': 7} c1 = AsyncResultMock(result=c1_result) c2 = AsyncResultMock(result=c2_result) with self.subTest('Parent not successful'): r = AsyncResultMock(result=result, children=[c1, c2], successful=False) expected = c1_result.copy() expected.update(c2_result) self.assertDictEqual( get_results(r, return_keys_only=False, merge_children_results=True), expected) self.assertDictEqual(get_results(r, merge_children_results=True), {}) with self.subTest('Child not successful'): c3 = AsyncResultMock(result=c2_result, successful=False) r = AsyncResultMock(result=result, children=[c1, c3]) expected = result.copy() expected.update(c1_result) self.assertDictEqual( get_results(r, return_keys_only=False, merge_children_results=True), expected) self.assertDictEqual(get_results(r, merge_children_results=True), {}) with self.subTest('Child asserts'): c4 = AsyncResultMock(result=c2_result) c4._get_children = _get_children_asserts r = AsyncResultMock(result=result, children=[c1, c4]) expected = result.copy() expected.update(c1_result) expected.update(c2_result) self.assertDictEqual( get_results(r, return_keys_only=False, merge_children_results=True), expected) self.assertDictEqual(get_results(r, merge_children_results=True), {})
def test_result_with_children(self): result = {'a': 1, 'b': 2} c1_result = {'c': 3, 'd': 4, 'a': 5} c2_result = {'e': 6, 'c': 7} c1 = AsyncResultMock(result=c1_result) c2 = AsyncResultMock(result=c2_result) r = AsyncResultMock(result=result, children=[c1, c2]) with self.subTest('Merging results from children'): expected = result.copy() expected.update(c1_result) expected.update(c2_result) self.assertDictEqual( get_results(r, return_keys_only=False, merge_children_results=True), expected) self.assertDictEqual(get_results(r, merge_children_results=True), {}) with self.subTest('No extraction from children'): self.assertDictEqual(get_results( r, return_keys_only=False, ), result) self.assertDictEqual(get_results(r, merge_children_results=True), {}) with self.subTest('Order of children does matter'): r = AsyncResultMock(result=result, children=[c2, c1]) expected = result.copy() expected.update(c2_result) expected.update(c1_result) self.assertDictEqual( get_results(r, return_keys_only=False, merge_children_results=True), expected) self.assertDictEqual(get_results(r, merge_children_results=True), {})
def test_unsucessful_result(self): result = {'a': 1, 'b': 2} r = AsyncResultMock(result=result, successful=False) self.assertDictEqual(get_results(r, return_keys_only=False), {}) self.assertDictEqual(get_results(r), {})
def test_none_case(self): result = None r = AsyncResultMock(result) self.assertEqual(get_results(r, return_keys_only=False), {}) self.assertDictEqual(get_results(r), {})
def test_empty_case(self): result = {} r = AsyncResultMock(result=result) self.assertEqual(get_results(r), result)
def test_plain_case(self): result = {'a': 1, 'b': 2} r = AsyncResultMock(result=result) self.assertDictEqual(get_results(r, return_keys_only=False), result) self.assertDictEqual(get_results(r), {})
def test_extract_from_parents(self): bb_child = AsyncResultMock(result={ 'bb': 9, 'b': 3, 'bbb': 0, RETURN_KEYS_KEY: ('bb', 'b') }) a = AsyncResultMock(result={ 'a': 1, 'aa': 11, 'aaa': 111, RETURN_KEYS_KEY: ('a', 'aa') }) b = AsyncResultMock(result={ 'b': 2, 'aa': 22, RETURN_KEYS_KEY: ('b', 'aa') }, parent=a, children=[bb_child]) c = AsyncResultMock(result={ 'c': 3, RETURN_KEYS_KEY: ('c', ) }, parent=b) with self.subTest('extract_from_parents=True (default)'): self.assertDictEqual(get_results(c), { 'a': 1, 'b': 2, 'c': 3, 'aa': 22 }) with self.subTest('merge_children_results=True'): self.assertDictEqual(get_results(c, merge_children_results=True), { 'a': 1, 'b': 3, 'c': 3, 'aa': 22, 'bb': 9 }) with self.subTest( 'merge_children_results=True, return_keys_only=False'): self.assertDictEqual( get_results(c, merge_children_results=True, return_keys_only=False), { 'aaa': 111, 'a': 1, 'b': 3, 'c': 3, 'aa': 22, 'bb': 9, 'bbb': 0 }) with self.subTest('return_keys_only=False'): self.assertDictEqual(get_results(c, return_keys_only=False), { 'a': 1, 'b': 2, 'c': 3, 'aa': 22, 'aaa': 111 }) with self.subTest('parent_id'): self.assertDictEqual(get_results(c, parent_id=b.id), { 'b': 2, 'aa': 22, 'c': 3 }) with self.subTest('extract_from_parents=False'): self.assertDictEqual(get_results(c, extract_from_parents=False), {'c': 3})