def test_execute_multiple_calls(self):
call_requests = [
call.CallRequest(dummy_call),
call.CallRequest(dummy_call)
]
call_reports = self.coordinator.execute_multiple_calls(call_requests)
self.assertTrue(len(call_requests) == len(call_reports))
self.assertTrue(self.coordinator._process_tasks.call_count == 1)
def test_execute_multiple_rejected(self):
call_request_1 = call.CallRequest(dummy_call)
call_request_2 = call.CallRequest(dummy_call)
call_report_list = self.coordinator.execute_multiple_calls(
[call_request_1, call_request_2])
self.assertEqual(self.coordinator._find_conflicts.call_count, 2)
self.assertEqual(call_report_list[0].response,
dispatch_constants.CALL_REJECTED_RESPONSE)
self.assertEqual(call_report_list[1].response,
dispatch_constants.CALL_REJECTED_RESPONSE)
def test_start_good_queued_call_collection(self):
request_1 = call.CallRequest(dummy_call)
request_2 = call.CallRequest(dummy_call)
request_1.group_id = request_2.group_id = 'my-group'
queued_request_1 = QueuedCall(request_1)
queued_request_2 = QueuedCall(request_2)
self.queued_call_collection.insert(queued_request_1)
self.queued_call_collection.insert(queued_request_2)
self.coordinator.start()
self.assertEqual(
self.coordinator.execute_call_asynchronously.call_count, 0)
self.assertEqual(self.coordinator.execute_multiple_calls.call_count, 1)
def test_execute_multiple_calls_dependencies(self):
call_request_1 = call.CallRequest(dummy_call)
call_request_2 = call.CallRequest(dummy_call)
call_request_3 = call.CallRequest(dummy_call)
# use the convenience api
call_request_3.depends_on(call_request_1.id)
call_request_3.depends_on(call_request_2.id)
call_request_2.depends_on(call_request_1.id)
call_requests = [call_request_3, call_request_2, call_request_1]
call_reports = self.coordinator.execute_multiple_calls(call_requests)
self.assertTrue(len(call_requests) == len(call_reports))
self.assertTrue(self.coordinator._process_tasks.call_count == 1)
def _generate_request_and_report(self):
def test_function():
pass
call_request = call.CallRequest(test_function)
call_report = call.CallReport.from_call_request(call_request)
return call_request, call_report
def test_execute_multiple_calls_circular_dependencies(self):
call_request_1 = call.CallRequest(dummy_call)
call_request_2 = call.CallRequest(dummy_call)
call_request_3 = call.CallRequest(dummy_call)
call_request_1.dependencies = {call_request_3.id: None}
call_request_2.dependencies = {call_request_1.id: None}
call_request_3.dependencies = {
call_request_1.id: None,
call_request_2.id: None
}
call_requests = [call_request_3, call_request_2, call_request_1]
self.assertRaises(CycleExists, self.coordinator.execute_multiple_calls,
call_requests)
self.assertTrue(self.coordinator._process_tasks.call_count == 0)
def test_find_by_call_request_id_list(self):
call_request = call.CallRequest(find_dummy_call)
task = Task(call_request)
self.set_task_queue([task])
call_report_list = self.coordinator.find_call_reports(
call_request_id_list=[call_request.id])
self.assertEqual(len(call_report_list), 1)
self.assertEqual(call_report_list[0].call_request_id, call_request.id)
def test_task_blockers_from_dependencies(self):
call_request_1 = call.CallRequest(dummy_call)
call_request_2 = call.CallRequest(dummy_call)
call_request_2.depends_on(call_request_1.id)
self.coordinator.execute_multiple_calls(
[call_request_2, call_request_1])
task_1 = self.coordinator._process_tasks.call_args_list[0][0][0][0]
task_2 = self.coordinator._process_tasks.call_args_list[0][0][0][1]
self.assertTrue(task_1.call_request is call_request_1)
self.assertTrue(task_2.call_request is call_request_2)
self.assertTrue(
task_1.call_request.id in task_2.call_request.dependencies)
self.assertFalse(
task_2.call_request.id in task_1.call_request.dependencies)
def test_start_good_queued_call(self):
request = call.CallRequest(dummy_call)
queued_request = QueuedCall(request)
self.queued_call_collection.insert(queued_request)
self.coordinator.start()
self.assertEqual(
self.coordinator.execute_call_asynchronously.call_count, 1)
self.assertEqual(self.coordinator.execute_multiple_calls.call_count, 0)
def test_execute_call(self):
call_request = call.CallRequest(dummy_call)
call_report = self.coordinator.execute_call(call_request)
self.assertTrue(isinstance(call_report, call.CallReport))
self.assertTrue(self.coordinator._process_tasks.call_count == 1)
task = self.coordinator._process_tasks.call_args[0][0][0]
self.assertTrue(isinstance(task, Task))
self.assertTrue(
call_report.call_request_id == task.call_request.id,
'"%s" != "%s"' %
(call_report.call_request_id, task.call_request.id))
def test_find_by_schedule_id(self):
schedule_id = str(ObjectId())
call_request = call.CallRequest(find_dummy_call)
call_report = call.CallReport.from_call_request(call_request)
call_report.schedule_id = schedule_id
task = Task(call_request, call_report)
self.set_task_queue([task])
call_report_list = self.coordinator.find_call_reports(
schedule_id=schedule_id)
self.assertEqual(len(call_report_list), 1)
self.assertEqual(call_report_list[0].schedule_id, schedule_id)
def test_run_task_async(self):
task = Task(call.CallRequest(dummy_call))
self.coordinator._process_tasks([task])
self.assertTrue(
len(task.call_request.execution_hooks[
dispatch_constants.CALL_ENQUEUE_LIFE_CYCLE_CALLBACK]) == 1)
self.assertTrue(
len(task.call_request.execution_hooks[
dispatch_constants.CALL_DEQUEUE_LIFE_CYCLE_CALLBACK]) == 2)
self.assertTrue(
coordinator.coordinator_dequeue_callback in
task.call_request.execution_hooks[
dispatch_constants.CALL_DEQUEUE_LIFE_CYCLE_CALLBACK])
def test_execute_call_asynchronously(self):
call_request = call.CallRequest(dummy_call)
self.coordinator.execute_call_asynchronously(call_request)
self.assertTrue(self.coordinator._process_tasks.call_count == 1)
self.assertTrue(self.coordinator._run_task.call_count == 0)
def test_run_task_sync_timeout(self):
task = Task(call.CallRequest(dummy_call))
timeout = datetime.timedelta(seconds=0.001)
self.assertRaises(OperationTimedOut, self.coordinator._run_task, task,
timeout)
def test_run_task_sync(self):
task = Task(call.CallRequest(dummy_call))
self.coordinator._process_tasks([task])
self.coordinator._run_task(task)
self.assertTrue(coordinator.wait_for_task.call_count == 2,
coordinator.wait_for_task.call_count)
