Пример #1
0
    def test_write_record_new(self):
        """Test that we can create a new record."""
        entity = TaskConnectionEntity.get_mock_object()

        TaskConnectionRepository.write_record(
            TaskConnectionMapper.to_record(entity)
        )

        connections = TaskConnectionRepository.fetch_connections_for_pipeline(entity.pipeline_id)
        self.assertEquals(connections[0].id, entity.id)
Пример #2
0
    def to_entity(record):
        """Converts record into a TaskConnectionEntity.

        :param TaskConnectionStore record:
        :returns TaskConnectionEntity:
        """
        return TaskConnectionEntity({
            'id': record.id,
            'from_task_id': record.from_task_id,
            'pipeline_id': record.pipeline_id,
            'to_task_id': record.to_task_id,
        })
Пример #3
0
    def test_write_task_connection(self):
        """Test that the provided entity gets written to the repository."""
        entity = TaskConnectionEntity.get_mock_object()

        self.assertEquals(
            TaskConnectionService.fetch_task_connections_for_pipeline(entity.pipeline_id),
            [],
        )

        TaskConnectionService.write_task_connection(entity)

        self.assertEquals(
            TaskConnectionService.fetch_task_connections_for_pipeline(entity.pipeline_id),
            [
                entity,
            ],
        )
Пример #4
0
    def import_pipeline(cls, pipeline_data):
        if not pipeline_data.get('pipeline'):
            raise Exception('pipeline data is required')

        if not pipeline_data.get('pipeline_schedule'):
            raise Exception('pipeline schedule data is required')

        if not pipeline_data.get('tasks'):
            raise Exception('task data is required')

        if not pipeline_data.get('task_connections'):
            raise Exception('task connections are required')

        # Create Pipeline
        pipeline_entity = PipelineEntity(pipeline_data['pipeline'])
        pipeline_entity.validate()

        # Create PipelineSchedule
        pipeline_schedule_entity = PipelineScheduleEntity(pipeline_data['pipeline_schedule'])
        pipeline_schedule_entity.pipeline_id = pipeline_entity.id
        pipeline_schedule_entity.next_run_at = (
            PipelineScheduleService.calculate_next_run_at_for_schedule(
                pipeline_schedule_entity
            )
        )
        pipeline_schedule_entity.validate()

        # Create Tasks
        task_entities = []
        task_alias_to_id = {}

        for task_alias, task_data in pipeline_data['tasks'].items():
            task_entity = TaskEntity(task_data)
            task_entity.validate()

            task_entities.append(task_entity)
            task_alias_to_id[task_alias] = task_entity.id

        # Create TaskConnections
        task_connection_entities = []

        for from_alias, to_aliases in pipeline_data['task_connections'].items():
            from_task_id = task_alias_to_id[from_alias]

            for to_alias in to_aliases:
                task_connection_entity = TaskConnectionEntity({
                    'from_task_id': from_task_id,
                    'to_task_id': task_alias_to_id[to_alias],
                    'pipeline_id': pipeline_entity.id,
                })
                task_connection_entity.validate()

                task_connection_entities.append(task_connection_entity)

        # Save Pipeline
        PipelineService.write_pipeline(pipeline_entity)

        # Save PipelineSchedule (enabled = False)
        PipelineScheduleService.write_pipeline_schedule(pipeline_schedule_entity)

        # Save Tasks
        for task_entity in task_entities:
            TaskService.write_task(task_entity)

        # Save TaskConnections
        for task_connection_entity in task_connection_entities:
            TaskConnectionService.write_task_connection(task_connection_entity)

        return pipeline_entity