From 2e9fa0e4b4a3068f90571b4aae56c445cc3b8f45 Mon Sep 17 00:00:00 2001 From: jasquat Date: Wed, 15 Mar 2023 12:15:48 -0400 Subject: [PATCH] pyl and cleaned up debug code w/ burnettk --- spiffworkflow-backend/migrations/env.py | 2 - .../models/bpmn_process.py | 2 +- .../src/spiffworkflow_backend/models/task.py | 5 +- .../services/process_instance_processor.py | 136 +++++++++++------- .../services/task_service.py | 67 ++++++--- .../services/workflow_execution_service.py | 14 +- .../unit/test_error_handling_service.py | 1 - .../unit/test_process_instance_processor.py | 27 ++-- 8 files changed, 158 insertions(+), 96 deletions(-) diff --git a/spiffworkflow-backend/migrations/env.py b/spiffworkflow-backend/migrations/env.py index 68feded2..630e381a 100644 --- a/spiffworkflow-backend/migrations/env.py +++ b/spiffworkflow-backend/migrations/env.py @@ -1,5 +1,3 @@ -from __future__ import with_statement - import logging from logging.config import fileConfig diff --git a/spiffworkflow-backend/src/spiffworkflow_backend/models/bpmn_process.py b/spiffworkflow-backend/src/spiffworkflow_backend/models/bpmn_process.py index faae68c1..f7e301e4 100644 --- a/spiffworkflow-backend/src/spiffworkflow_backend/models/bpmn_process.py +++ b/spiffworkflow-backend/src/spiffworkflow_backend/models/bpmn_process.py @@ -1,7 +1,7 @@ from __future__ import annotations -from sqlalchemy.orm import relationship from sqlalchemy import ForeignKey +from sqlalchemy.orm import relationship from spiffworkflow_backend.models.db import db from spiffworkflow_backend.models.db import SpiffworkflowBaseDBModel diff --git a/spiffworkflow-backend/src/spiffworkflow_backend/models/task.py b/spiffworkflow-backend/src/spiffworkflow_backend/models/task.py index 14746d6f..99ccb61b 100644 --- a/spiffworkflow-backend/src/spiffworkflow_backend/models/task.py +++ b/spiffworkflow-backend/src/spiffworkflow_backend/models/task.py @@ -1,8 +1,5 @@ """Task.""" import enum - -from sqlalchemy.orm import relationship -from spiffworkflow_backend.models.task_definition import TaskDefinitionModel from dataclasses import dataclass from typing import Any from typing import Optional @@ -13,10 +10,12 @@ from marshmallow import Schema from marshmallow_enum import EnumField # type: ignore from SpiffWorkflow.task import TaskStateNames # type: ignore from sqlalchemy import ForeignKey +from sqlalchemy.orm import relationship from spiffworkflow_backend.models.bpmn_process import BpmnProcessModel from spiffworkflow_backend.models.db import db from spiffworkflow_backend.models.db import SpiffworkflowBaseDBModel +from spiffworkflow_backend.models.task_definition import TaskDefinitionModel class MultiInstanceType(enum.Enum): diff --git a/spiffworkflow-backend/src/spiffworkflow_backend/services/process_instance_processor.py b/spiffworkflow-backend/src/spiffworkflow_backend/services/process_instance_processor.py index 17180137..6b80fbcf 100644 --- a/spiffworkflow-backend/src/spiffworkflow_backend/services/process_instance_processor.py +++ b/spiffworkflow-backend/src/spiffworkflow_backend/services/process_instance_processor.py @@ -53,7 +53,6 @@ from SpiffWorkflow.task import TaskState from SpiffWorkflow.util.deep_merge import DeepMerge # type: ignore from spiffworkflow_backend.exceptions.api_error import ApiError -from spiffworkflow_backend.models import task_definition from spiffworkflow_backend.models.bpmn_process import BpmnProcessModel from spiffworkflow_backend.models.bpmn_process_definition import ( BpmnProcessDefinitionModel, @@ -457,7 +456,7 @@ class ProcessInstanceProcessor: self.process_instance_model = process_instance_model self.process_model_service = ProcessModelService() bpmn_process_spec = None - self.full_bpmn_process_dict = {} + self.full_bpmn_process_dict: dict = {} # this caches the bpmn_process_definition_identifier and task_identifier back to the bpmn_process_id # in the database. This is to cut down on database queries while adding new tasks to the database. @@ -465,7 +464,7 @@ class ProcessInstanceProcessor: # { "bpmn_process_definition_identifier": { "task_identifier": task_definition } } # To use from a spiff_task: # [spiff_task.workflow.spec.name][spiff_task.task_spec.name] - self.bpmn_definition_to_task_definitions_mappings = {} + self.bpmn_definition_to_task_definitions_mappings: dict = {} subprocesses: Optional[IdToBpmnProcessSpecMapping] = None if process_instance_model.bpmn_process_definition_id is None: @@ -482,13 +481,15 @@ class ProcessInstanceProcessor: ) try: - (self.bpmn_process_instance, self.full_bpmn_process_dict, self.bpmn_definition_to_task_definitions_mappings) = ( - self.__get_bpmn_process_instance( - process_instance_model, - bpmn_process_spec, - validate_only, - subprocesses=subprocesses, - ) + ( + self.bpmn_process_instance, + self.full_bpmn_process_dict, + self.bpmn_definition_to_task_definitions_mappings, + ) = self.__get_bpmn_process_instance( + process_instance_model, + bpmn_process_spec, + validate_only, + subprocesses=subprocesses, ) self.set_script_engine(self.bpmn_process_instance) @@ -549,18 +550,27 @@ class ProcessInstanceProcessor: @classmethod def _update_bpmn_definition_mappings( - cls, bpmn_definition_to_task_definitions_mappings: dict, bpmn_process_definition_identifier: str, task_definition: TaskDefinitionModel + cls, + bpmn_definition_to_task_definitions_mappings: dict, + bpmn_process_definition_identifier: str, + task_definition: TaskDefinitionModel, ) -> None: - # import pdb; pdb.set_trace() - # if bpmn_process_definition_identifier == 'test_process_to_call' and task_definition.bpmn_identifier == "Root": - # import pdb; pdb.set_trace() - if bpmn_process_definition_identifier not in bpmn_definition_to_task_definitions_mappings: - bpmn_definition_to_task_definitions_mappings[bpmn_process_definition_identifier] = {} - bpmn_definition_to_task_definitions_mappings[bpmn_process_definition_identifier][task_definition.bpmn_identifier] = task_definition + if ( + bpmn_process_definition_identifier + not in bpmn_definition_to_task_definitions_mappings + ): + bpmn_definition_to_task_definitions_mappings[ + bpmn_process_definition_identifier + ] = {} + bpmn_definition_to_task_definitions_mappings[ + bpmn_process_definition_identifier + ][task_definition.bpmn_identifier] = task_definition @classmethod def _get_definition_dict_for_bpmn_process_definition( - cls, bpmn_process_definition: BpmnProcessDefinitionModel, bpmn_definition_to_task_definitions_mappings: dict + cls, + bpmn_process_definition: BpmnProcessDefinitionModel, + bpmn_definition_to_task_definitions_mappings: dict, ) -> dict: task_definitions = TaskDefinitionModel.query.filter_by( bpmn_process_definition_id=bpmn_process_definition.id @@ -571,7 +581,11 @@ class ProcessInstanceProcessor: bpmn_process_definition_dict["task_specs"][ task_definition.bpmn_identifier ] = task_definition.properties_json - cls._update_bpmn_definition_mappings(bpmn_definition_to_task_definitions_mappings, bpmn_process_definition.bpmn_identifier, task_definition) + cls._update_bpmn_definition_mappings( + bpmn_definition_to_task_definitions_mappings, + bpmn_process_definition.bpmn_identifier, + task_definition, + ) return bpmn_process_definition_dict @classmethod @@ -618,7 +632,11 @@ class ProcessInstanceProcessor: task_definition.bpmn_process_definition_id ] ) - cls._update_bpmn_definition_mappings(bpmn_definition_to_task_definitions_mappings, bpmn_subprocess_definition_bpmn_identifier, task_definition) + cls._update_bpmn_definition_mappings( + bpmn_definition_to_task_definitions_mappings, + bpmn_subprocess_definition_bpmn_identifier, + task_definition, + ) spiff_bpmn_process_dict["subprocess_specs"][ bpmn_subprocess_definition_bpmn_identifier ]["task_specs"][ @@ -667,7 +685,9 @@ class ProcessInstanceProcessor: @classmethod def _get_full_bpmn_process_dict( - cls, process_instance_model: ProcessInstanceModel, bpmn_definition_to_task_definitions_mappings: dict + cls, + process_instance_model: ProcessInstanceModel, + bpmn_definition_to_task_definitions_mappings: dict, ) -> dict: if process_instance_model.bpmn_process_definition_id is None: return {} @@ -682,11 +702,14 @@ class ProcessInstanceProcessor: if bpmn_process_definition is not None: spiff_bpmn_process_dict["spec"] = ( cls._get_definition_dict_for_bpmn_process_definition( - bpmn_process_definition, bpmn_definition_to_task_definitions_mappings + bpmn_process_definition, + bpmn_definition_to_task_definitions_mappings, ) ) cls._set_definition_dict_for_bpmn_subprocess_definitions( - bpmn_process_definition, spiff_bpmn_process_dict, bpmn_definition_to_task_definitions_mappings + bpmn_process_definition, + spiff_bpmn_process_dict, + bpmn_definition_to_task_definitions_mappings, ) bpmn_process = process_instance_model.bpmn_process @@ -755,8 +778,7 @@ class ProcessInstanceProcessor: subprocesses: Optional[IdToBpmnProcessSpecMapping] = None, ) -> Tuple[BpmnWorkflow, dict, dict]: full_bpmn_process_dict = {} - bpmn_definition_to_task_definitions_mappings = {} - # print("GET BPMN PROCESS INSTANCE") + bpmn_definition_to_task_definitions_mappings: dict = {} if process_instance_model.bpmn_process_definition_id is not None: # turn off logging to avoid duplicated spiff logs spiff_logger = logging.getLogger("spiff") @@ -766,10 +788,10 @@ class ProcessInstanceProcessor: try: full_bpmn_process_dict = ( ProcessInstanceProcessor._get_full_bpmn_process_dict( - process_instance_model, bpmn_definition_to_task_definitions_mappings + process_instance_model, + bpmn_definition_to_task_definitions_mappings, ) ) - # print("WE GOT FULL BPMN PROCESS DICT") bpmn_process_instance = ( ProcessInstanceProcessor._serializer.workflow_from_dict( full_bpmn_process_dict @@ -782,17 +804,19 @@ class ProcessInstanceProcessor: ProcessInstanceProcessor.set_script_engine(bpmn_process_instance) else: - # print("WE NO HAVE FULL BPMN YET") bpmn_process_instance = ( ProcessInstanceProcessor.get_bpmn_process_instance_from_workflow_spec( spec, subprocesses ) ) - # import pdb; pdb.set_trace() bpmn_process_instance.data[ ProcessInstanceProcessor.VALIDATION_PROCESS_KEY ] = validate_only - return (bpmn_process_instance, full_bpmn_process_dict, bpmn_definition_to_task_definitions_mappings) + return ( + bpmn_process_instance, + full_bpmn_process_dict, + bpmn_definition_to_task_definitions_mappings, + ) def slam_in_data(self, data: dict) -> None: """Slam_in_data.""" @@ -1063,13 +1087,7 @@ class ProcessInstanceProcessor: bpmn_process_definition: Optional[BpmnProcessDefinitionModel] = ( BpmnProcessDefinitionModel.query.filter_by(hash=new_hash_digest).first() ) - # print(f"process_bpmn_properties: {process_bpmn_properties}") - # import pdb; pdb.set_trace() - # if process_bpmn_identifier == "test_process_to_call": - # import pdb; pdb.set_trace() - # # print("HEY22") - # print(f"self.process_instance_model.id: {self.process_instance_model.id}") if bpmn_process_definition is None: task_specs = process_bpmn_properties.pop("task_specs") bpmn_process_definition = BpmnProcessDefinitionModel( @@ -1088,13 +1106,23 @@ class ProcessInstanceProcessor: ) db.session.add(task_definition) if store_bpmn_definition_mappings: - self._update_bpmn_definition_mappings(self.bpmn_definition_to_task_definitions_mappings, process_bpmn_identifier, task_definition) + self._update_bpmn_definition_mappings( + self.bpmn_definition_to_task_definitions_mappings, + process_bpmn_identifier, + task_definition, + ) elif store_bpmn_definition_mappings: # this should only ever happen when new process instances use a pre-existing bpmn process definitions # otherwise this should get populated on processor initialization - task_definitions = TaskDefinitionModel.query.filter_by(bpmn_process_definition_id=bpmn_process_definition.id).all() + task_definitions = TaskDefinitionModel.query.filter_by( + bpmn_process_definition_id=bpmn_process_definition.id + ).all() for task_definition in task_definitions: - self._update_bpmn_definition_mappings(self.bpmn_definition_to_task_definitions_mappings, process_bpmn_identifier, task_definition) + self._update_bpmn_definition_mappings( + self.bpmn_definition_to_task_definitions_mappings, + process_bpmn_identifier, + task_definition, + ) if bpmn_process_definition_parent is not None: bpmn_process_definition_relationship = ( @@ -1113,16 +1141,19 @@ class ProcessInstanceProcessor: def _add_bpmn_process_definitions(self, bpmn_spec_dict: dict) -> None: # store only if mappings is currently empty. this also would mean this is a new instance that has never saved before - # print("WE STORE BPM PROCESS DEF") - store_bpmn_definition_mappings = not self.bpmn_definition_to_task_definitions_mappings + store_bpmn_definition_mappings = ( + not self.bpmn_definition_to_task_definitions_mappings + ) bpmn_process_definition_parent = self._store_bpmn_process_definition( - bpmn_spec_dict["spec"], store_bpmn_definition_mappings=store_bpmn_definition_mappings + bpmn_spec_dict["spec"], + store_bpmn_definition_mappings=store_bpmn_definition_mappings, ) for process_bpmn_properties in bpmn_spec_dict["subprocess_specs"].values(): self._store_bpmn_process_definition( - process_bpmn_properties, bpmn_process_definition_parent, store_bpmn_definition_mappings=store_bpmn_definition_mappings + process_bpmn_properties, + bpmn_process_definition_parent, + store_bpmn_definition_mappings=store_bpmn_definition_mappings, ) - # import pdb; pdb.set_trace() self.process_instance_model.bpmn_process_definition = ( bpmn_process_definition_parent ) @@ -1132,7 +1163,6 @@ class ProcessInstanceProcessor: Expects the save method to commit it. """ - # print("WE SAVE THINGS") bpmn_dict = self.serialize() bpmn_dict_keys = ("spec", "subprocess_specs", "serializer_version") process_instance_data_dict = {} @@ -1143,12 +1173,9 @@ class ProcessInstanceProcessor: else: process_instance_data_dict[bpmn_key] = bpmn_dict[bpmn_key] - # FIXME: always save new hash until we get updated Spiff without loopresettask - # if self.process_instance_model.bpmn_process_definition_id is None: - self._add_bpmn_process_definitions(bpmn_spec_dict) - # import pdb; pdb.set_trace() - # print("WE NOW STORE BPMN PROCESS STUFFS") - # print(f"bpmn_definition_to_task_definitions_mappings: {self.bpmn_definition_to_task_definitions_mappings}") + # we may have to already process bpmn_defintions if we ever care about the Root task again + if self.process_instance_model.bpmn_process_definition_id is None: + self._add_bpmn_process_definitions(bpmn_spec_dict) subprocesses = process_instance_data_dict.pop("subprocesses") bpmn_process_parent, new_task_models, new_json_data_dicts = ( @@ -1156,7 +1183,7 @@ class ProcessInstanceProcessor: bpmn_process_dict=process_instance_data_dict, process_instance=self.process_instance_model, bpmn_definition_to_task_definitions_mappings=self.bpmn_definition_to_task_definitions_mappings, - spiff_workflow=self.bpmn_process_instance + spiff_workflow=self.bpmn_process_instance, ) ) for subprocess_task_id, subprocess_properties in subprocesses.items(): @@ -1170,7 +1197,7 @@ class ProcessInstanceProcessor: bpmn_process_parent=bpmn_process_parent, bpmn_process_guid=subprocess_task_id, bpmn_definition_to_task_definitions_mappings=self.bpmn_definition_to_task_definitions_mappings, - spiff_workflow=self.bpmn_process_instance + spiff_workflow=self.bpmn_process_instance, ) new_task_models.update(subprocess_new_task_models) new_json_data_dicts.update(subprocess_new_json_data_models) @@ -1180,7 +1207,6 @@ class ProcessInstanceProcessor: def save(self) -> None: """Saves the current state of this processor to the database.""" - # print("WE IN SAVE") self._add_bpmn_json_records() self.process_instance_model.spiff_serializer_version = self.SERIALIZER_VERSION @@ -1308,7 +1334,7 @@ class ProcessInstanceProcessor: try: self.bpmn_process_instance.catch(event_definition) except Exception as e: - print(e) + print(e) # TODO: do_engine_steps without a lock self.do_engine_steps(save=True) diff --git a/spiffworkflow-backend/src/spiffworkflow_backend/services/task_service.py b/spiffworkflow-backend/src/spiffworkflow_backend/services/task_service.py index 76a957b2..1d81bc59 100644 --- a/spiffworkflow-backend/src/spiffworkflow_backend/services/task_service.py +++ b/spiffworkflow-backend/src/spiffworkflow_backend/services/task_service.py @@ -3,6 +3,7 @@ from hashlib import sha256 from typing import Optional from typing import Tuple from typing import TypedDict +from uuid import UUID from flask import current_app from SpiffWorkflow.bpmn.serializer.workflow import BpmnWorkflow # type: ignore @@ -11,7 +12,6 @@ from SpiffWorkflow.task import Task as SpiffTask # type: ignore from SpiffWorkflow.task import TaskStateNames from sqlalchemy.dialects.mysql import insert as mysql_insert from sqlalchemy.dialects.postgresql import insert as postgres_insert -from uuid import UUID from spiffworkflow_backend.models.bpmn_process import BpmnProcessModel from spiffworkflow_backend.models.db import db @@ -88,13 +88,21 @@ class TaskService: new_json_data_dicts: dict[str, JsonDataDict] = {} if task_model is None: bpmn_process, new_task_models, new_json_data_dicts = cls.task_bpmn_process( - spiff_task, process_instance, serializer, bpmn_definition_to_task_definitions_mappings=bpmn_definition_to_task_definitions_mappings + spiff_task, + process_instance, + serializer, + bpmn_definition_to_task_definitions_mappings=bpmn_definition_to_task_definitions_mappings, ) task_model = TaskModel.query.filter_by(guid=spiff_task_guid).first() if task_model is None: - task_definition = bpmn_definition_to_task_definitions_mappings[spiff_task.workflow.spec.name][spiff_task.task_spec.name] + task_definition = bpmn_definition_to_task_definitions_mappings[ + spiff_task.workflow.spec.name + ][spiff_task.task_spec.name] task_model = TaskModel( - guid=spiff_task_guid, bpmn_process_id=bpmn_process.id, process_instance_id=process_instance.id, task_definition_id=task_definition.id + guid=spiff_task_guid, + bpmn_process_id=bpmn_process.id, + process_instance_id=process_instance.id, + task_definition_id=task_definition.id, ) return (bpmn_process, task_model, new_task_models, new_json_data_dicts) @@ -135,9 +143,7 @@ class TaskService: spiff_workflow = spiff_task.workflow._get_outermost_workflow() bpmn_process, new_task_models, new_json_data_dicts = ( cls.add_bpmn_process( - bpmn_process_dict=serializer.workflow_to_dict( - spiff_workflow - ), + bpmn_process_dict=serializer.workflow_to_dict(spiff_workflow), process_instance=process_instance, bpmn_definition_to_task_definitions_mappings=bpmn_definition_to_task_definitions_mappings, spiff_workflow=spiff_workflow, @@ -157,7 +163,6 @@ class TaskService: bpmn_process_guid=subprocess_guid, bpmn_definition_to_task_definitions_mappings=bpmn_definition_to_task_definitions_mappings, spiff_workflow=spiff_workflow, - ) ) return (bpmn_process, new_task_models, new_json_data_dicts) @@ -195,9 +200,12 @@ class TaskService: if bpmn_process is None: bpmn_process_is_new = True bpmn_process = BpmnProcessModel(guid=bpmn_process_guid) + + # Point the root id to the Start task instead of the Root task + # since we are ignoring the Root task. for task_id, task_properties in tasks.items(): - if task_properties['task_spec'] == 'Start': - bpmn_process_dict['root'] = task_id + if task_properties["task_spec"] == "Start": + bpmn_process_dict["root"] = task_id bpmn_process.properties_json = bpmn_process_dict @@ -223,21 +231,26 @@ class TaskService: if bpmn_process_is_new: for task_id, task_properties in tasks.items(): - if task_properties['task_spec'] == 'Root': + # The Root task is added to the spec by Spiff when the bpmn process is instantiated + # within Spiff. We do not actually need it and it's missing from our initial + # bpmn process defintion so let's avoid using it. + if task_properties["task_spec"] == "Root": continue - if task_properties['task_spec'] == 'Start': - task_properties['parent'] = None - process_dict = bpmn_process.properties_json - process_dict['root'] = task_id - bpmn_process.properties_json = process_dict - db.session.add(bpmn_process) + if task_properties["task_spec"] == "Start": + task_properties["parent"] = None + task_data_dict = task_properties.pop("data") state_int = task_properties["state"] task_model = TaskModel.query.filter_by(guid=task_id).first() if task_model is None: spiff_task = spiff_workflow.get_task(UUID(task_id)) - task_model = cls._create_task(bpmn_process, process_instance, spiff_task, bpmn_definition_to_task_definitions_mappings) + task_model = cls._create_task( + bpmn_process, + process_instance, + spiff_task, + bpmn_definition_to_task_definitions_mappings, + ) task_model.state = TaskStateNames[state_int] task_model.properties_json = task_properties @@ -263,10 +276,20 @@ class TaskService: return json_data_dict @classmethod - def _create_task(cls, bpmn_process: BpmnProcessModel, process_instance: ProcessInstanceModel, spiff_task: SpiffTask, bpmn_definition_to_task_definitions_mappings: dict) -> TaskModel: - - task_definition = bpmn_definition_to_task_definitions_mappings[spiff_task.workflow.spec.name][spiff_task.task_spec.name] + def _create_task( + cls, + bpmn_process: BpmnProcessModel, + process_instance: ProcessInstanceModel, + spiff_task: SpiffTask, + bpmn_definition_to_task_definitions_mappings: dict, + ) -> TaskModel: + task_definition = bpmn_definition_to_task_definitions_mappings[ + spiff_task.workflow.spec.name + ][spiff_task.task_spec.name] task_model = TaskModel( - guid=str(spiff_task.id), bpmn_process_id=bpmn_process.id, process_instance_id=process_instance.id, task_definition_id=task_definition.id + guid=str(spiff_task.id), + bpmn_process_id=bpmn_process.id, + process_instance_id=process_instance.id, + task_definition_id=task_definition.id, ) return task_model diff --git a/spiffworkflow-backend/src/spiffworkflow_backend/services/workflow_execution_service.py b/spiffworkflow-backend/src/spiffworkflow_backend/services/workflow_execution_service.py index c1db70d9..be13342a 100644 --- a/spiffworkflow-backend/src/spiffworkflow_backend/services/workflow_execution_service.py +++ b/spiffworkflow-backend/src/spiffworkflow_backend/services/workflow_execution_service.py @@ -62,7 +62,9 @@ class TaskModelSavingDelegate(EngineStepDelegate): ) -> None: self.secondary_engine_step_delegate = secondary_engine_step_delegate self.process_instance = process_instance - self.bpmn_definition_to_task_definitions_mappings = bpmn_definition_to_task_definitions_mappings + self.bpmn_definition_to_task_definitions_mappings = ( + bpmn_definition_to_task_definitions_mappings + ) self.current_task_model: Optional[TaskModel] = None self.task_models: dict[str, TaskModel] = {} @@ -80,7 +82,10 @@ class TaskModelSavingDelegate(EngineStepDelegate): if self.should_update_task_model(): _bpmn_process, task_model, new_task_models, new_json_data_dicts = ( TaskService.find_or_create_task_model_from_spiff_task( - spiff_task, self.process_instance, self.serializer, bpmn_definition_to_task_definitions_mappings=self.bpmn_definition_to_task_definitions_mappings + spiff_task, + self.process_instance, + self.serializer, + bpmn_definition_to_task_definitions_mappings=self.bpmn_definition_to_task_definitions_mappings, ) ) self.current_task_model = task_model @@ -123,7 +128,10 @@ class TaskModelSavingDelegate(EngineStepDelegate): ): _bpmn_process, task_model, new_task_models, new_json_data_dicts = ( TaskService.find_or_create_task_model_from_spiff_task( - waiting_spiff_task, self.process_instance, self.serializer, bpmn_definition_to_task_definitions_mappings=self.bpmn_definition_to_task_definitions_mappings + waiting_spiff_task, + self.process_instance, + self.serializer, + bpmn_definition_to_task_definitions_mappings=self.bpmn_definition_to_task_definitions_mappings, ) ) self.task_models.update(new_task_models) diff --git a/spiffworkflow-backend/tests/spiffworkflow_backend/unit/test_error_handling_service.py b/spiffworkflow-backend/tests/spiffworkflow_backend/unit/test_error_handling_service.py index 4566625a..9d481788 100644 --- a/spiffworkflow-backend/tests/spiffworkflow_backend/unit/test_error_handling_service.py +++ b/spiffworkflow-backend/tests/spiffworkflow_backend/unit/test_error_handling_service.py @@ -33,7 +33,6 @@ class TestErrorHandlingService(BaseTest): process_instance = ProcessInstanceService.create_process_instance_from_process_model_identifier( process_model.id, user ) - print(f"process_instance.id: {process_instance.id}") pip = ProcessInstanceProcessor(process_instance) with pytest.raises(ApiError) as e: pip.do_engine_steps(save=True) diff --git a/spiffworkflow-backend/tests/spiffworkflow_backend/unit/test_process_instance_processor.py b/spiffworkflow-backend/tests/spiffworkflow_backend/unit/test_process_instance_processor.py index 6bd7a305..ac1a286e 100644 --- a/spiffworkflow-backend/tests/spiffworkflow_backend/unit/test_process_instance_processor.py +++ b/spiffworkflow-backend/tests/spiffworkflow_backend/unit/test_process_instance_processor.py @@ -378,24 +378,33 @@ class TestProcessInstanceProcessor(BaseTest): assert len(all_spiff_tasks) > 1 for spiff_task in all_spiff_tasks: assert spiff_task.state == TaskState.COMPLETED - if spiff_task.task_spec.name == 'test_process_to_call_script': + if spiff_task.task_spec.name == "test_process_to_call_script": task = TaskModel.query.filter_by(guid=str(spiff_task.id)).first() assert task.task_definition_id is not None task_definition = task.task_definition - assert task_definition.bpmn_identifier == 'test_process_to_call_script' - assert task_definition.bpmn_process_definition.bpmn_identifier == 'test_process_to_call' - elif spiff_task.task_spec.name == 'top_level_subprocess_script': + assert task_definition.bpmn_identifier == "test_process_to_call_script" + assert ( + task_definition.bpmn_process_definition.bpmn_identifier + == "test_process_to_call" + ) + elif spiff_task.task_spec.name == "top_level_subprocess_script": task = TaskModel.query.filter_by(guid=str(spiff_task.id)).first() assert task.task_definition_id is not None task_definition = task.task_definition - assert task_definition.bpmn_identifier == 'top_level_subprocess_script' - assert task_definition.bpmn_process_definition.bpmn_identifier == 'top_level_subprocess' - if spiff_task.task_spec.name == 'top_level_script': + assert task_definition.bpmn_identifier == "top_level_subprocess_script" + assert ( + task_definition.bpmn_process_definition.bpmn_identifier + == "top_level_subprocess" + ) + if spiff_task.task_spec.name == "top_level_script": task = TaskModel.query.filter_by(guid=str(spiff_task.id)).first() assert task.task_definition_id is not None task_definition = task.task_definition - assert task_definition.bpmn_identifier == 'top_level_script' - assert task_definition.bpmn_process_definition.bpmn_identifier == 'top_level_process' + assert task_definition.bpmn_identifier == "top_level_script" + assert ( + task_definition.bpmn_process_definition.bpmn_identifier + == "top_level_process" + ) # FIXME: Checking task data cannot work with the feature/remove-loop-reset branch # of SiffWorkflow. This is because it saves script data to the python_env and NOT # to task.data. We may need to either create a new column on TaskModel to put the python_env