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)
