예제 #1
0
    def test_serialize_after_finish(self):
        """
        Tests serializing a job's state to a RunningJob instance.
        """
        task_name = 'task-1'
        state = JobState(task_name)
        state.save_state()
        expected_events = [
            {
                'name': 'event-1',
                'arguments': ['a', 'b'],
            },
            {
                'name': 'event-2',
                'arguments': None,
            }
        ]
        mock_task = self.create_mock_task(task_name, expected_events)

        state.add_processed_task(mock_task)
        state.save_state()
        state.mark_as_complete()

        # Stil only one running job instance
        self.assertEqual(RunningJob.objects.count(), 1)
        job = RunningJob.objects.all()[0]
        self.assertSequenceEqual(job.state['events'], expected_events)
        self.assertSequenceEqual(job.state['processed_tasks'], [task_name])
        self.assertTrue(job.is_complete)
예제 #2
0
    def test_serialize_start(self):
        """
        Tests serializing a job's state to a RunningJob instance.
        """
        state = JobState('initial-task-name')
        state.save_state()

        # A running job was created.
        self.assertEqual(RunningJob.objects.count(), 1)
        job = RunningJob.objects.all()[0]
        self.assertEqual(job.initial_task_name, 'initial-task-name')
        self.assertIsNone(job.additional_parameters)
        self.assertFalse(job.is_complete)
예제 #3
0
    def test_continue_job_finished(self):
        """
        Tests continuing a job from a job state where the job was finished.
        """
        task1 = self.create_task_class(('a',), (), ('a',))
        job_state = JobState(task1.task_name())
        task1_instance = task1()
        task1_instance.execute()
        job_state.add_processed_task(task1_instance)
        job_state.save_state()

        self.clear_executed_tasks_list()
        continue_task_from_state(job_state)

        # No tasks were ran from the continue
        self.assertEqual(len(self.execution_list), 0)
예제 #4
0
    def test_continue_job_some_finished(self):
        """
        Tests continuing a job from a job state where a task has finished.
        """
        task1 = self.create_task_class(('a',), (), ('a',))
        task2 = self.create_task_class((), ('a',), ())
        job_state = JobState(task1.task_name())
        task1_instance = task1()
        task1_instance.execute()
        job_state.add_processed_task(task1_instance)
        job_state.save_state()

        self.clear_executed_tasks_list()
        continue_task_from_state(job_state)

        # Only one task ran
        self.assertEqual(len(self.execution_list), 1)
        # It was the one that was not completed before the continue
        self.assert_task_ran(task2)
예제 #5
0
    def test_deserialize(self):
        """
        Tests deserializing a RunningJob instance to a JobState.
        """
        initial_task_name = 'initial-task'
        additional_parameters = {
            'param1': 1
        }
        job = RunningJob.objects.create(
            initial_task_name=initial_task_name,
            additional_parameters=additional_parameters)
        processed_tasks = ['initial-task', 'task-1']
        job.state = {
            'events': [
                {
                    'name': 'event-1',
                },
                {
                    'name': 'event-2',
                    'arguments': {
                        'a': 1,
                        'b': '2'
                    }
                }
            ],
            'processed_tasks': processed_tasks
        }
        job.save()

        state = JobState.deserialize_running_job_state(job)

        self.assertEqual(state.initial_task_name, 'initial-task')
        self.assertEqual(state.additional_parameters, additional_parameters)
        self.assertEqual(state.processed_tasks, processed_tasks)

        self.assertEqual(len(state.events), 2)
        self.assertEqual(state.events[0].name, 'event-1')
        self.assertIsNone(state.events[0].arguments)
        self.assertEqual(state.events[1].arguments, {
            'a': 1,
            'b': '2'
        })
        self.assertEqual(state._running_job, job)
예제 #6
0
    def test_serialize_after_update(self):
        """
        Tests serializing a job's state after multiple tasks have finished.
        """
        task_names = ['task-1', 'task-2']
        state = JobState(task_names[0])
        state.save_state()
        expected_events = [
            {
                'name': 'event-1',
                'arguments': {
                    'a': 1,
                    'b': '2'
                },
            },
            {
                'name': 'event-2',
                'arguments': None,
            }
        ]
        mock_task_1 = self.create_mock_task(task_names[0], [expected_events[0]])
        state.add_processed_task(mock_task_1)
        state.save_state()

        mock_task_2 = self.create_mock_task(task_names[1], [expected_events[1]])
        state.add_processed_task(mock_task_2)
        state.save_state()

        # Stil only one running job instance
        self.assertEqual(RunningJob.objects.count(), 1)
        job = RunningJob.objects.all()[0]
        # All events found now
        self.assertSequenceEqual(job.state['events'], expected_events)
        # Both tasks processed
        self.assertSequenceEqual(job.state['processed_tasks'], task_names)
        self.assertFalse(job.is_complete)