def test_rename_case(self): cases = copy.deepcopy(self.cases1) subs.set_subscriptions(self.cases1) self.assertTrue(subs.rename_case('case1', 'renamed')) cases['renamed'] = cases.pop('case1') self.assertInMemoryCasesAreCorrect(cases) self.assertDatabaseCasesAreCorrect({'renamed', 'case2'})
def test_pause_resume_scheduler_execution(self): c = controller.Controller() c.load_playbook(resource=config.test_workflows_path + "testScheduler.playbook") subs = { 'controller': [ event.signal_name for event in WalkoffEvent if event.event_type == EventType.controller ] } case_subscription.set_subscriptions({'pauseResume': subs}) c.scheduler.start() c.scheduler.pause() time.sleep(0.1) c.scheduler.resume() time.sleep(0.1) c.scheduler.stop(wait=False) pause_resume_event_history = case_database.case_db.session.query(case_database.Case) \ .filter(case_database.Case.name == 'pauseResume').first().events.all() self.assertEqual( len(pause_resume_event_history), 4, 'Incorrect length of event history. ' 'Expected {0}, got {1}'.format(4, len(pause_resume_event_history)))
def test_sync_to_subscriptions(self): case1 = [{ 'uid': 'uid1', 'events': ['e1', 'e2', 'e3'] }, { 'uid': 'uid2', 'events': ['e1'] }] case2 = [{'uid': 'uid1', 'events': ['e2', 'e3']}] case3 = [{ 'uid': 'uid3', 'events': ['e', 'b', 'c'] }, { 'uid': 'uid4', 'events': ['d'] }] case4 = [{'uid': 'uid1', 'events': ['a', 'b']}] cases = {'case1': case1, 'case2': case2} set_subscriptions(cases) case_db_entry_1 = CaseSubscription('case3', subscriptions=case3) case_db_entry_2 = CaseSubscription('case4', subscriptions=case4) db.session.add(case_db_entry_1) db.session.add(case_db_entry_2) db.session.commit() CaseSubscription.sync_to_subscriptions() self.assertIn('case3', case_subs.subscriptions) self.assertIn('case4', case_subs.subscriptions) self.assertNotIn('case1', case_subs.subscriptions) self.assertNotIn('case2', case_subs.subscriptions) self.assertDictEqual(case_subs.subscriptions['case3'], {sub['uid']: sub['events'] for sub in case3}) self.assertDictEqual(case_subs.subscriptions['case4'], {sub['uid']: sub['events'] for sub in case4})
def setup_subscriptions_for_action(workflow_ids, action_ids, action_events=None, workflow_events=None): action_events = action_events if action_events is not None else [WalkoffEvent.ActionExecutionSuccess.signal_name] workflow_events = workflow_events if workflow_events is not None else [] subs = {str(workflow_id): workflow_events for workflow_id in workflow_ids} \ if isinstance(workflow_ids, list) else {str(workflow_ids): workflow_events} for action_id in action_ids: subs[str(action_id)] = action_events case_subscription.set_subscriptions({'case1': subs})
def test_delete_cases_some_existing(self): subs.set_subscriptions(self.cases1) subs.add_cases(self.cases2) subs.delete_cases(['case2', 'case3']) expected_cases = { 'case1': self.cases1['case1'], 'case4': self.cases2['case4'] } self.assertInMemoryCasesAreCorrect(expected_cases) self.assertDatabaseCasesAreCorrect(set(expected_cases.keys()))
def test_add_case_duplicate_case_in_sync(self): set_subscriptions({'case1': {}}) self.app.put('api/cases', headers=self.headers, data=json.dumps({'name': 'case1'}), content_type='application/json') self.put_with_status_check('api/cases', headers=self.headers, data=json.dumps({'name': 'case1'}), status_code=OBJECT_EXISTS_ERROR, content_type='application/json') cases = [ case.name for case in case_database.case_db.session.query( case_database.Case).all() ]
def test_add_case_existing_cases(self): set_subscriptions(self.cases1) response = self.put_with_status_check('api/cases', headers=self.headers, data=json.dumps( {'name': 'case3'}), status_code=OBJECT_CREATED, content_type='application/json') self.assertEqual(response, { 'id': 1, 'name': 'case3', 'note': '', 'subscriptions': [] }) cases = [ case.name for case in case_database.case_db.session.query( case_database.Case).all() ]
def test_delete_case_invalid_case(self): set_subscriptions(self.cases1) self.app.put('api/cases', headers=self.headers, data=json.dumps({'name': 'case1'}), content_type='application/json') self.app.put('api/cases', headers=self.headers, data=json.dumps({'name': 'case2'}), content_type='application/json') self.delete_with_status_check('api/cases/3', error='Case does not exist.', headers=self.headers, status_code=OBJECT_DNE_ERROR) db_cases = [ case.name for case in case_database.case_db.session.query( case_database.Case).all() ]
def test_start_stop_execution_loop(self): execution_db_help.load_playbook('testScheduler') subs = { 'controller': [ event.signal_name for event in WalkoffEvent if event.event_type == EventType.controller ] } case_subscription.set_subscriptions({'case1': subs}) scheduler.start() time.sleep(0.1) scheduler.stop(wait=False) start_stop_event_history = case_database.case_db.session.query(case_database.Case) \ .filter(case_database.Case.name == 'case1').first().events.all() self.assertEqual( len(start_stop_event_history), 2, 'Incorrect length of event history. ' 'Expected {0}, got {1}'.format(2, len(start_stop_event_history)))
def test_add_case_duplicate_case_out_of_sync(self): set_subscriptions({'case1': {}}) expected_json = { 'id': 1, 'name': 'case1', 'note': '', 'subscriptions': [] } response = self.put_with_status_check('api/cases', headers=self.headers, data=json.dumps( {'name': 'case1'}), status_code=OBJECT_CREATED, content_type='application/json') self.assertEqual(response, expected_json) cases = [ case.name for case in case_database.case_db.session.query( case_database.Case).all() ]
def test_workflow_execution_events(self): workflow = execution_db_help.load_workflow('multiactionWorkflowTest', 'multiactionWorkflow') subs = { 'case1': { str(workflow.id): [ WalkoffEvent.AppInstanceCreated.signal_name, WalkoffEvent.WorkflowShutdown.signal_name ] } } case_subscription.set_subscriptions(subs) self.executor.execute_workflow(workflow.id) self.executor.wait_and_reset(1) execution_events = case_database.case_db.session.query(case_database.Case) \ .filter(case_database.Case.name == 'case1').first().events.all() self.assertEqual( len(execution_events), 2, 'Incorrect length of event history. ' 'Expected {0}, got {1}'.format(2, len(execution_events)))
def test_action_execution_events(self): workflow = execution_db_help.load_workflow('basicWorkflowTest', 'helloWorldWorkflow') action_ids = [str(action.id) for action in workflow.actions] action_events = [ WalkoffEvent.ActionExecutionSuccess.signal_name, WalkoffEvent.ActionStarted.signal_name ] subs = { 'case1': {action_id: action_events for action_id in action_ids} } case_subscription.set_subscriptions(subs) self.executor.execute_workflow(workflow.id) self.executor.wait_and_reset(1) execution_events = case_database.case_db.session.query(case_database.Case) \ .filter(case_database.Case.name == 'case1').first().events.all() self.assertEqual( len(execution_events), 2, 'Incorrect length of event history. ' 'Expected {0}, got {1}'.format(2, len(execution_events)))
def test_remove_subscription_node_case_not_found(self): cases = copy.deepcopy(self.cases1) subs.set_subscriptions(self.cases1) subs.remove_subscription_node('invalid', 'uid1') self.assertInMemoryCasesAreCorrect(cases)
def test_rename_case_to_existing_case(self): cases = copy.deepcopy(self.cases1) subs.set_subscriptions(self.cases1) self.assertFalse(subs.rename_case('case1', 'case2')) self.assertInMemoryCasesAreCorrect(cases) self.assertDatabaseCasesAreCorrect({'case1', 'case2'})
def __basic_case_setup(self): set_subscriptions(self.cases_all)
def test_clear_subscriptions(self): subs.set_subscriptions(self.cases1) subs.clear_subscriptions() self.assertInMemoryCasesAreCorrect({}) self.assertDatabaseCasesAreCorrect(set())
def test_get_cases_subscribed_no_event_found(self): subs.set_subscriptions(self.cases1) self.assertSetEqual(set(subs.get_cases_subscribed('uid1', 'invalid')), set())
def test_get_cases_subscribed_one_case_one_case_found(self): subs.set_subscriptions(self.cases2) self.assertSetEqual(set(subs.get_cases_subscribed('uid4', 'd')), {'case3'})
def test_get_cases_subscribed_multiple_cases_one_event_found(self): subs.set_subscriptions(self.cases1) self.assertSetEqual(set(subs.get_cases_subscribed('uid1', 'e2')), {'case1', 'case2'})
def test_delete_cases_all_existing_cases_is_empty(self): subs.set_subscriptions(self.cases1) subs.delete_cases(['case1', 'case2']) self.assertInMemoryCasesAreCorrect({}) self.assertDatabaseCasesAreCorrect(set())
def test_add_case_with_existing_cases_sets(self): subs.set_subscriptions(self.cases1) subs.add_cases(self.cases2) self.assertInMemoryCasesAreCorrect(self.cases1) self.assertDatabaseCasesAreCorrect( {'case1', 'case2', 'case3', 'case4'})
def test_set_subscriptions_with_existing_cases_sets(self): subs.subscriptions = self.cases1 subs.set_subscriptions(self.cases_overlap) self.assertInMemoryCasesAreCorrect(self.cases_overlap) self.assertDatabaseCasesAreCorrect({'case2', 'case3'})
def test_set_subscriptions_no_existing_cases_sets(self): subs.set_subscriptions(self.cases1) self.assertInMemoryCasesAreCorrect(self.cases1) self.assertDatabaseCasesAreCorrect({'case1', 'case2'})
def test_remove_subscription_node(self): cases = copy.deepcopy(self.cases1) subs.set_subscriptions(self.cases1) subs.remove_subscription_node('case1', 'uid1') cases['case1'].pop('uid1') self.assertInMemoryCasesAreCorrect(cases)
def test_modify_subscriptions_new_subscriptions(self): cases = copy.deepcopy(self.cases1) subs.set_subscriptions(self.cases1) subs.modify_subscription('case1', 'uid1', ['e1', 'e3']) cases['case1']['uid1'] = ['e1', 'e3'] self.assertInMemoryCasesAreCorrect(cases)
def test_modify_subscriptions_case_not_found(self): cases = copy.deepcopy(self.cases1) subs.set_subscriptions(self.cases1) subs.modify_subscription('invalid', 'uid1', ['e1', 'e3']) self.assertInMemoryCasesAreCorrect(cases)