def test_run_job_instance(self):
server_service = ServerService(None, None, None)
job_activity = mock.MagicMock(spec=JobActivityBase)
job_activity.start = mock.MagicMock()
self.assertEqual(job_activity.start.call_count, 0)
server_service.run_job_instance(job_activity)
self.assertEqual(job_activity.start.call_count, 1)
def test_exists_enqueued_jobs(self):
fake_job_repository = types.SimpleNamespace()
fake_job_repository.exists_jobs_with_status = mock.MagicMock(
side_effect=[True, False])
server_service = ServerService(None, None, fake_job_repository)
self.assertTrue(server_service.exists_enqueued_jobs())
self.assertFalse(server_service.exists_enqueued_jobs())
def test_log_with_logger_injected(self):
fake_log_service = types.SimpleNamespace()
fake_log_service.log = mock.MagicMock()
server_service = ServerService(None, None, None, fake_log_service)
server_service.log('some log message')
self.assertEqual(fake_log_service.log.call_args[0][0],
'some log message')
def test_slots_empty(self):
server_configuration = ServerConfigurationDto(slots=2)
server_service = ServerService(server_configuration, None, None)
job_activity = mock.MagicMock(spec=JobActivityBase)
server_service.job_activities_assigned.append(job_activity)
self.assertFalse(server_service.slots_empty())
server_service.job_activities_assigned.clear()
self.assertTrue(server_service.slots_empty())
def test_get_job_activity_instance(self):
server_service = ServerService(None, None, None)
fake_job_activity = FakeJobActivity()
job = Job(fake_job_activity.__module__,
fake_job_activity.__class__.__name__)
job_instance = server_service.get_job_activity_instance(job)
self.assertIsInstance(job_instance, FakeJobActivity)
self.assertEqual(job_instance.set_job.call_count, 1)
def test_run_cycle_loop_cannot_set_lock_on_job(self, *args):
server_service = ServerService(None, None, None)
server_service.run_cycle_loop()
self.assertEqual(get_call_count('clear_finished_jobs', args), 1)
self.assertEqual(get_call_count('wait_until_slot_is_open', args), 1)
self.assertEqual(get_call_count('get_next_enqueued_job', args), 1)
self.assertEqual(get_call_count('try_set_lock_on_job', args), 1)
self.assertEqual(get_call_count('run_job', args), 0)
def test_run_job(self, *args):
server_service = ServerService(None, None, None)
job = get_fake_job()
server_service.run_job(job)
self.assertEqual(get_call_count('set_job_start_state', args), 1)
self.assertEqual(get_call_count('get_job_activity_instance', args), 1)
self.assertEqual(get_call_count('add_job_activity_assigned', args), 1)
self.assertEqual(get_call_count('run_job_instance', args), 1)
def test_get_next_enqueued_job(self):
fake_job_repository = types.SimpleNamespace()
fake_job_repository.get_job_by_status = mock.MagicMock(
return_value=get_fake_job())
server_service = ServerService(None, None, fake_job_repository)
enqueued_job = server_service.get_next_enqueued_job()
self.assertIsNotNone(enqueued_job)
self.assertIsInstance(enqueued_job, Job)
def test_try_set_lock_on_job(self):
fake_job_repository = types.SimpleNamespace()
fake_job_repository.try_set_lock_on_job = mock.MagicMock(
side_effect=[True, False])
server_service = ServerService(None, None, fake_job_repository)
job = get_fake_job()
self.assertTrue(server_service.try_set_lock_on_job(job))
self.assertFalse(server_service.try_set_lock_on_job(job))
def test_set_job_start_state(self):
fake_job_repository = types.SimpleNamespace()
fake_job_repository.update_job = mock.MagicMock()
job = get_fake_job()
server_service = ServerService(None, None, fake_job_repository)
server_service.set_job_start_state(job)
self.assertEqual(job.start_datetime, '1988-04-10T11:01:02.123456')
self.assertEqual(job.status, JobStatus.PROCESSING)
self.assertEqual(fake_job_repository.update_job.call_count, 1)
def test_run(self, *args):
server_service = ServerService(None, None, None)
server_service.run()
self.assertEqual(get_call_count('set_server_start_state', args), 1)
self.assertEqual(get_call_count('run_enabled', args), 3)
self.assertEqual(get_call_count('try_run_cycle', args), 2)
self.assertEqual(get_call_count('sleep_cycle', args), 2)
self.assertEqual(get_call_count('wait_until_slots_are_empty', args), 1)
self.assertEqual(get_call_count('set_server_stop_state', args), 1)
def test_sleep_cycle(self):
server_service = ServerService(ServerConfigurationDto(1000), None,
None)
time_start = datetime.datetime.now()
server_service.sleep_cycle()
time_stop = datetime.datetime.now()
total_milliseconds = (time_stop - time_start).seconds * 1000
total_milliseconds += (time_stop - time_start).microseconds / 1000
self.assertGreater(total_milliseconds, 1000)
def test_run_job_exception(self, *args):
server_service = ServerService(None, None, None)
job = get_fake_job()
server_service.run_job(job)
self.assertEqual(get_call_count('set_job_start_state', args), 1)
self.assertEqual(get_call_count('get_job_activity_instance', args), 1)
self.assertEqual(get_call_count('add_job_activity_assigned', args), 1)
self.assertEqual(get_call_count('run_job_instance', args), 1)
actual_log = str(get_mock('log', args).call_args[0][0])
self.assertTrue(actual_log.endswith('run_job_instance exception'))
def test_set_server_stop_state(self):
fake_server_repository = types.SimpleNamespace()
fake_server_repository.update_server = mock.MagicMock()
server_service = ServerService(ServerConfigurationDto(),
fake_server_repository, None)
self.assertIsNone(server_service.server.stop_datetime)
server_service.set_server_stop_state()
self.assertEqual(server_service.server.stop_datetime,
'1988-04-10T11:01:02.123456')
self.assertEqual(fake_server_repository.update_server.call_count, 1)
def test_must_run_cycle_loop(self, *args):
server_service = ServerService(None, None, None)
self.assertFalse(server_service.must_run_cycle_loop())
self.assertTrue(server_service.must_run_cycle_loop())
self.assertFalse(server_service.must_run_cycle_loop())
self.assertFalse(server_service.must_run_cycle_loop())
self.assertFalse(server_service.must_run_cycle_loop())
self.assertTrue(server_service.must_run_cycle_loop())
self.assertFalse(server_service.must_run_cycle_loop())
self.assertTrue(server_service.must_run_cycle_loop())
def test_save_finished_jobs(self):
jobs_updated = 0
def fake_update_jobs(jobs):
nonlocal jobs_updated
jobs_updated += len(jobs)
fake_job_repository = types.SimpleNamespace()
fake_job_repository.update_jobs = mock.MagicMock(
side_effect=fake_update_jobs)
server_service = ServerService(None, None, fake_job_repository)
job_activity_running = types.SimpleNamespace()
job_activity_running.is_finished = mock.MagicMock(return_value=False)
job_activity_running.get_job = mock.MagicMock(
return_value=get_fake_job())
job_activity_running.set_can_be_untracked = mock.MagicMock()
server_service.job_activities_assigned.append(job_activity_running)
server_service.save_finished_jobs()
self.assertEqual(fake_job_repository.update_jobs.call_count, 1)
self.assertEqual(jobs_updated, 0)
self.assertEqual(job_activity_running.set_can_be_untracked.call_count,
0)
job_activity_finished = types.SimpleNamespace()
job_activity_finished.is_finished = mock.MagicMock(return_value=True)
job_activity_finished.get_job = mock.MagicMock(
return_value=get_fake_job())
job_activity_finished.set_can_be_untracked = mock.MagicMock()
server_service.job_activities_assigned.append(job_activity_finished)
server_service.save_finished_jobs()
self.assertEqual(fake_job_repository.update_jobs.call_count, 2)
self.assertEqual(jobs_updated, 1)
self.assertEqual(job_activity_finished.set_can_be_untracked.call_count,
1)
def test_add_job_activity_assigned(self):
server_service = ServerService(None, None, None)
job_activity = types.SimpleNamespace()
self.assertEqual(len(server_service.job_activities_assigned), 0)
server_service.add_job_activity_assigned(job_activity)
self.assertEqual(len(server_service.job_activities_assigned), 1)
server_service.add_job_activity_assigned(job_activity)
self.assertEqual(len(server_service.job_activities_assigned), 2)
def test_untrack_jobs(self):
server_service = ServerService(None, None, None)
job_activity_running = types.SimpleNamespace()
job_activity_running.can_be_untracked = mock.MagicMock(
return_value=False)
server_service.job_activities_assigned.append(job_activity_running)
self.assertEqual(len(server_service.job_activities_assigned), 1)
server_service.untrack_jobs()
self.assertEqual(len(server_service.job_activities_assigned), 1)
job_activity_finished = types.SimpleNamespace()
job_activity_finished.can_be_untracked = mock.MagicMock(
return_value=True)
server_service.job_activities_assigned.append(job_activity_finished)
self.assertEqual(len(server_service.job_activities_assigned), 2)
server_service.untrack_jobs()
self.assertEqual(len(server_service.job_activities_assigned), 1)
def test_run_cycle(self, *args):
server_service = ServerService(None, None, None)
server_service.run_cycle()
self.assertEqual(get_call_count('set_server_cycle_state', args), 1)
self.assertEqual(get_call_count('must_run_cycle_loop', args), 2)
self.assertEqual(get_call_count('run_cycle_loop', args), 1)
def test_try_run_cycle_exception(self, *args):
server_service = ServerService(None, None, None)
server_service.try_run_cycle()
actual_log = str(get_mock('log', args).call_args[0][0])
self.assertTrue(actual_log.endswith('run_cycle exception'))
def test_try_run_cycle(self, *args):
server_service = ServerService(None, None, None)
server_service.try_run_cycle()
self.assertEqual(get_call_count('run_cycle', args), 1)
def test_run_enabled(self):
server_service = ServerService(None, None, None)
server_service.stop_signal = False
self.assertTrue(server_service.run_enabled())
server_service.stop_signal = True
self.assertFalse(server_service.run_enabled())
def test_clear_finished_jobs(self, *args):
server_service = ServerService(None, None, None)
server_service.clear_finished_jobs()
self.assertEqual(get_call_count('save_finished_jobs', args), 1)
self.assertEqual(get_call_count('untrack_jobs', args), 1)
def test_log_run(self, *args):
server_service = ServerService(ServerConfigurationDto(), None, None)
server_service.log_run()
self.assertEqual(get_call_count('log', args), 1)
def test_wait_until_slots_are_empty(self, *args):
server_service = ServerService(None, None, None)
server_service.wait_until_slots_are_empty()
self.assertEqual(get_call_count('slots_empty', args), 2)
self.assertEqual(get_call_count('clear_finished_jobs', args), 1)
def test_wait_until_slot_is_open(self, *args):
server_service = ServerService(None, None, None)
server_service.wait_until_slot_is_open()
self.assertEqual(get_call_count('slots_limit_reached', args), 2)
self.assertEqual(get_call_count('clear_finished_jobs', args), 1)
def test_log_join(self, *args):
server_service = ServerService(None, None, None)
server_service.log_join()
self.assertEqual(get_call_count('log', args), 1)
def test_stop(self, *args):
server_service = ServerService(None, None, None)
self.assertFalse(server_service.stop_signal)
server_service.stop()
self.assertTrue(server_service.stop_signal)
