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)