wbcore 1.46.0__py2.py3-none-any.whl → 1.58.2__py2.py3-none-any.whl

wbcore/contrib/workflow/tests/test_dispatch.py

@@ -1,89 +1,94 @@
-from unittest.mock import patch
-
 import pytest
+from pytest_mock import MockerFixture
 
-from wbcore.contrib.directory.factories import PersonFactory
 from wbcore.contrib.workflow.dispatch import check_workflow_for_instance
-from wbcore.contrib.workflow.factories import UserStepFactory
-from wbcore.contrib.workflow.models import Process, ProcessStep
+from wbcore.contrib.workflow.models import Process, ProcessStep, Step, Workflow
 
 
-@pytest.mark.django_db
 class TestDispatch:
-    @patch("wbcore.contrib.workflow.models.step.Step.set_failed")
+    @pytest.fixture
+    def mocked_instance(self, mocker: MockerFixture):
+        return mocker.MagicMock()
+
+    # Fixture that automatically patches ContentType lookup in every test.
+    @pytest.fixture(autouse=True)
+    def patch_content_type(self, mocker: MockerFixture):
+        return mocker.patch(
+            "wbcore.contrib.workflow.dispatch.ContentType.objects.get_for_model",
+            return_value="dummy_content_type",
+        )
+
+    # Fixture for creating a fake process step with a mismatching status.
+    @pytest.fixture
+    def mocked_process_step(self, mocker: MockerFixture):
+        # Create the fake casted step.
+        mocked_casted_step = mocker.MagicMock(spec=Step)
+
+        # Create a fake workflow with a status field.
+        mocked_workflow = mocker.MagicMock(spec=Workflow)
+        mocked_workflow.status_field = "status_a"
+
+        # Create a fake process that uses the workflow.
+        mocked_process = mocker.MagicMock(spec=Process)
+        mocked_process.workflow = mocked_workflow
+
+        # Create a fake process step with a mismatching status.
+        mocked_process_step = mocker.MagicMock(spec=ProcessStep)
+        mocked_process_step.process = mocked_process
+        mocked_process_step.status = "status_b"
+        mocked_process_step.step.get_casted_step.return_value = mocked_casted_step
+
+        return mocked_process_step, mocked_casted_step
+
     def test_check_workflow_for_instance_fail_process_steps(
-        self, mock_failed, process_step_factory, random_child_step_factory
+        self, mocked_instance, mocked_process_step, mocker: MockerFixture
     ):
-        instance = PersonFactory()
-        step = random_child_step_factory(exclude_factories=[UserStepFactory])
-        process_step1 = process_step_factory(
-            step=step,
-            state=ProcessStep.StepState.WAITING,
-            process__state=Process.ProcessState.ACTIVE,
-            process__instance=instance,
-        )
-        process_step2 = process_step_factory(
-            step=step,
-            state=ProcessStep.StepState.ACTIVE,
-            process__state=Process.ProcessState.ACTIVE,
-            process__instance=instance,
-        )
-        process_step_factory(
-            step=step,
-            state=ProcessStep.StepState.ACTIVE,
-            process__state=Process.ProcessState.ACTIVE,
-            process__instance=instance,
-            status=instance.first_name,
-        )
-        process_step_factory(
-            step=step,
-            state=ProcessStep.StepState.CANCELED,
-            process__state=Process.ProcessState.ACTIVE,
-            process__instance=instance,
-        )
-        process_step_factory(
-            step=step,
-            state=ProcessStep.StepState.FAILED,
-            process__state=Process.ProcessState.ACTIVE,
-            process__instance=instance,
-        )
-        process_step_factory(
-            step=step,
-            state=ProcessStep.StepState.FINISHED,
-            process__state=Process.ProcessState.ACTIVE,
-            process__instance=instance,
+        # Arrange
+        mocked_process_step, mocked_casted_step = mocked_process_step
+
+        # Patch ProcessStep.objects.filter to return a fake process step.
+        mocker.patch(
+            "wbcore.contrib.workflow.models.ProcessStep.objects.filter",
+            return_value=[mocked_process_step],
         )
-        process_step_factory(
-            step=step,
-            state=ProcessStep.StepState.ACTIVE,
-            process__state=Process.ProcessState.FAILED,
-            process__instance=instance,
+        # Patch get_start_steps_for_instance to return an empty list.
+        mocker.patch(
+            "wbcore.contrib.workflow.models.Workflow.get_start_steps_for_instance",
+            return_value=[],
         )
-        process_step_factory(
-            step=step,
-            state=ProcessStep.StepState.ACTIVE,
-            process__state=Process.ProcessState.FINISHED,
-            process__instance=instance,
+
+        # Act
+        check_workflow_for_instance(sender=None, instance=mocked_instance, created=True)
+
+        # Assert: Ensure set_failed was called with the correct arguments.
+        mocked_casted_step.set_failed.assert_called_once_with(mocked_process_step, "Invalid status detected!")
+
+    def test_check_workflow_for_instance_start_workflow(self, mocked_instance, mocker: MockerFixture):
+        # Arrange: Create two fake start steps, each with its own workflow.
+        fake_start_step1 = mocker.MagicMock()
+        fake_workflow1 = mocker.MagicMock(spec=Workflow)
+        fake_start_step1.workflow = fake_workflow1
+
+        fake_start_step2 = mocker.MagicMock()
+        fake_workflow2 = mocker.MagicMock(spec=Workflow)
+        fake_start_step2.workflow = fake_workflow2
+
+        # Patch get_start_steps_for_instance to return our fake start steps.
+        get_start_steps_patch = mocker.patch(
+            "wbcore.contrib.workflow.models.Workflow.get_start_steps_for_instance",
+            return_value=[fake_start_step1, fake_start_step2],
         )
-        process_step_factory(
-            step=step,
-            state=ProcessStep.StepState.ACTIVE,
-            process__state=Process.ProcessState.ACTIVE,
-            process__instance=PersonFactory(),
+        # Patch ProcessStep.objects.filter to return an empty list.
+        mocker.patch(
+            "wbcore.contrib.workflow.models.ProcessStep.objects.filter",
+            return_value=[],
         )
-        check_workflow_for_instance(instance.__class__, instance, False)
-        assert len(mock_failed.call_args_list) == 2
-        assert str(mock_failed.call_args_list[0][0][0].pk) == process_step1.pk
-        assert str(mock_failed.call_args_list[1][0][0].pk) == process_step2.pk
-
-    @patch("wbcore.contrib.workflow.models.workflow.Workflow.start_workflow")
-    @patch("wbcore.contrib.workflow.models.workflow.Workflow.get_start_steps_for_instance")
-    def test_check_workflow_for_instance_start_workflow(self, mock_start_steps, mock_start, start_step_factory):
-        instance = PersonFactory()
-        start_step1 = start_step_factory()
-        start_step2 = start_step_factory()
-        start_step_factory()
-        mock_start_steps.return_value = [start_step1, start_step2]
-        check_workflow_for_instance(instance.__class__, instance, False)
-        assert mock_start_steps.call_args.args == (instance,)
-        assert mock_start.call_args_list == [((start_step1, instance),), ((start_step2, instance),)]
+
+        # Act
+        check_workflow_for_instance(sender=None, instance=mocked_instance, created=True)
+
+        # Assert: Verify that get_start_steps_for_instance was called with our instance.
+        get_start_steps_patch.assert_called_once_with(mocked_instance)
+        # Verify that each fake workflow's start_workflow was called with its corresponding start step and the instance.
+        fake_workflow1.start_workflow.assert_called_once_with(fake_start_step1, mocked_instance)
+        fake_workflow2.start_workflow.assert_called_once_with(fake_start_step2, mocked_instance)

wbcore/contrib/workflow/tests/test_displays.py

@@ -1,4 +1,3 @@
-import pytest
 from rest_framework.test import APIRequestFactory
 
 from wbcore.contrib.color.enums import WBColor
@@ -9,7 +8,6 @@ from wbcore.contrib.workflow.viewsets.display.process import (
 )
 
 
-@pytest.mark.django_db
 class TestProcessStep:
     api_factory = APIRequestFactory()
 
@@ -19,8 +17,16 @@ class TestProcessStep:
             (ProcessStep.StepState.CANCELED, WBColor.BLUE_LIGHT.value),
         ]
         assert set((y.icon, y.label, y.value) for y in get_state_legend(color_map)[0].items) == {
-            (WBColor.GREEN_LIGHT.value, ProcessStep.StepState.FAILED.label, ProcessStep.StepState.FAILED.value),
-            (WBColor.BLUE_LIGHT.value, ProcessStep.StepState.CANCELED.label, ProcessStep.StepState.CANCELED.value),
+            (
+                WBColor.GREEN_LIGHT.value,
+                ProcessStep.StepState.FAILED.label,
+                ProcessStep.StepState.FAILED.value,
+            ),
+            (
+                WBColor.BLUE_LIGHT.value,
+                ProcessStep.StepState.CANCELED.label,
+                ProcessStep.StepState.CANCELED.value,
+            ),
         }
 
     def test_get_state_formatting(self):
@@ -34,87 +40,3 @@ class TestProcessStep:
             (WBColor.GREY.value, ProcessStep.StepState.WAITING.value),
             (WBColor.YELLOW_DARK.value, ProcessStep.StepState.ACTIVE.value),
         }
-
-    # @patch("wbcore.contrib.workflow.viewsets.display.process.split_list_into_grid_template_area_sublists")
-    # def test_process_step_display_instance_injection(
-    #     self, mock_split, data_factory, user_step_factory, process_step_factory
-    # ):
-    #     request = self.api_factory.get("")
-    #     request.user = get_or_create_superuser()
-    #     request.query_params = {}
-    #     step = user_step_factory()
-    #     process_step = process_step_factory(step=step)
-    #     data_factory(workflow=process_step.step.workflow)
-    #     mvs = ProcessStepModelViewSet(request=request, kwargs={"pk": process_step.pk})
-    #     display = mvs.display_config_class(mvs, request).get_instance_display()
-    #     assert display.pages[0].layouts["default"].grid_template_areas == step.display.grid_template_areas
-    #     assert not mock_split.called
-
-    # @patch("wbcore.contrib.workflow.viewsets.display.process.split_list_into_grid_template_area_sublists")
-    # def test_process_step_display_no_userstep(self, mock_split, random_child_step_factory, process_step_factory):
-    #     request = self.api_factory.get("")
-    #     request.user = get_or_create_superuser()
-    #     request.query_params = {}
-    #     step = random_child_step_factory(exclude_factories=[UserStepFactory])
-    #     process_step = process_step_factory(step=step)
-    #     mvs = ProcessStepModelViewSet(request=request, kwargs={"pk": process_step.pk})
-    #     display = mvs.display_config_class(mvs, request).get_instance_display()
-    #     display_fields = set(itertools.chain.from_iterable(display.pages[0].layouts["default"].grid_template_areas))
-    #     person_fields = set(PersonModelSerializer.Meta.fields)
-    #     assert not mock_split.called
-    #     assert display_fields.intersection(person_fields) == {"id"}
-
-    # @patch("wbcore.contrib.workflow.viewsets.display.process.split_list_into_grid_template_area_sublists")
-    # def test_process_step_display_no_display(self, mock_split, user_step_factory, process_step_factory):
-    #     request = self.api_factory.get("")
-    #     request.user = get_or_create_superuser()
-    #     request.query_params = {}
-    #     step = user_step_factory(display=None)
-    #     process_step = process_step_factory(step=step)
-    #     mvs = ProcessStepModelViewSet(request=request, kwargs={"pk": process_step.pk})
-    #     display = mvs.display_config_class(mvs, request).get_instance_display()
-    #     display_fields = set(itertools.chain.from_iterable(display.pages[0].layouts["default"].grid_template_areas))
-    #     person_fields = set(PersonModelSerializer.Meta.fields)
-    #     assert not mock_split.called
-    #     assert display_fields.intersection(person_fields) == {"id"}
-
-    # @patch("wbcore.contrib.workflow.viewsets.display.process.split_list_into_grid_template_area_sublists")
-    # def test_process_step_display_data_injection(
-    #     self, mock_split, data_factory, user_step_factory, process_step_factory
-    # ):
-    #     request = self.api_factory.get("")
-    #     request.user = get_or_create_superuser()
-    #     request.query_params = {}
-    #     step = user_step_factory(display=None)
-    #     process_step = process_step_factory(step=step)
-    #     data1 = data_factory(workflow=process_step.process.workflow)
-    #     data2 = data_factory(workflow=process_step.process.workflow)
-    #     data_factory()
-    #     data_sublist = ["a", "b", "c"]
-    #     mock_split.return_value = data_sublist
-    #     mvs = ProcessStepModelViewSet(request=request, kwargs={"pk": process_step.pk})
-    #     display = mvs.display_config_class(mvs, request).get_instance_display()
-    #     display_fields = set(itertools.chain.from_iterable(display.pages[0].layouts["default"].grid_template_areas))
-    #     person_fields = set(PersonModelSerializer.Meta.fields)
-    #     assert display_fields.intersection(person_fields) == {"id"}
-    #     assert mock_split.call_args.args[0] == [f"data__{str(data1.pk)}", f"data__{str(data2.pk)}"]
-    #     for key in data_sublist:
-    #         assert key in display_fields
-
-    # @patch("wbcore.contrib.workflow.viewsets.display.process.split_list_into_grid_template_area_sublists")
-    # def test_process_step_display_no_display_no_data(
-    #     self, mock_split, data_factory, user_step_factory, process_step_factory
-    # ):
-    #     request = self.api_factory.get("")
-    #     request.user = get_or_create_superuser()
-    #     request.query_params = {}
-    #     step = user_step_factory(display=None)
-    #     process_step = process_step_factory(step=step)
-    #     data_factory()
-    #     data_factory()
-    #     mvs = ProcessStepModelViewSet(request=request, kwargs={"pk": process_step.pk})
-    #     display = mvs.display_config_class(mvs, request).get_instance_display()
-    #     display_fields = set(itertools.chain.from_iterable(display.pages[0].layouts["default"].grid_template_areas))
-    #     person_fields = set(PersonModelSerializer.Meta.fields)
-    #     assert display_fields.intersection(person_fields) == {"id"}
-    #     assert not mock_split.called

wbcore/contrib/workflow/tests/test_filters.py

@@ -12,76 +12,93 @@ from wbcore.contrib.workflow.viewsets import (
 from wbcore.test.utils import get_or_create_superuser
 
 
+@pytest.fixture()
+def super_user_get_request():
+    request = APIRequestFactory().get("")
+    request.user = get_or_create_superuser()
+
+
 @pytest.mark.django_db
 class TestWorkflow:
-    api_factory = APIRequestFactory()
+    @pytest.fixture()
+    def workflow_viewset(self):
+        return WorkflowModelViewSet()
 
-    def test_filter_attached_model(self, workflow_factory):
+    def test_filter_attached_model(self, super_user_get_request, workflow_viewset, workflow_factory):
         workflow_factory()
         workflow_factory(model=ContentType.objects.first())
-        mvs = WorkflowModelViewSet()
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
-        qs = mvs.get_queryset()
-        assert mvs.filterset_class(request=request).filter_attached_model(qs, "", None) == qs
-        assert mvs.filterset_class(request=request).filter_attached_model(qs, "", "person").count() == 1
-        assert not mvs.filterset_class(request=request).filter_attached_model(qs, "", "company").exists()
+        qs = workflow_viewset.get_queryset()
+        assert (
+            workflow_viewset.filterset_class(request=super_user_get_request).filter_attached_model(qs, "", None) == qs
+        )
+        assert (
+            workflow_viewset.filterset_class(request=super_user_get_request)
+            .filter_attached_model(qs, "", "person")
+            .count()
+            == 1
+        )
+        assert (
+            not workflow_viewset.filterset_class(request=super_user_get_request)
+            .filter_attached_model(qs, "", "company")
+            .exists()
+        )
 
-    def test_filter_by_data(self, workflow_factory, data_factory):
+    def test_filter_by_data(self, super_user_get_request, workflow_viewset, workflow_factory, data_factory):
         workflow_factory()
         data = data_factory()
-        mvs = WorkflowModelViewSet()
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
-        qs = mvs.get_queryset()
-        assert mvs.filterset_class(request=request).filter_by_data(qs, "", None) == qs
-        assert mvs.filterset_class(request=request).filter_by_data(qs, "", data).count() == 1
-        assert mvs.filterset_class(request=request).filter_by_data(qs, "", data).first() == data.workflow
+        qs = workflow_viewset.get_queryset()
+        assert workflow_viewset.filterset_class(request=super_user_get_request).filter_by_data(qs, "", None) == qs
+        assert (
+            workflow_viewset.filterset_class(request=super_user_get_request).filter_by_data(qs, "", data).count() == 1
+        )
+        assert (
+            workflow_viewset.filterset_class(request=super_user_get_request).filter_by_data(qs, "", data).first()
+            == data.workflow
+        )
 
 
 @pytest.mark.django_db
 class TestStep:
-    api_factory = APIRequestFactory()
-
-    def test_filter_by_transition(self, transition_factory, random_child_step_factory):
+    def test_filter_by_transition(self, super_user_get_request, transition_factory, random_child_step_factory):
         transition = transition_factory()
         random_child_step_factory()
         mvs = StepModelViewSet(kwargs={})
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
         qs = mvs.get_queryset()
-        assert mvs.get_filterset_class(request=request)().filter_by_transition(qs, "", None) == qs
-        assert set(mvs.get_filterset_class(request=request)().filter_by_transition(qs, "", transition)) == set(
-            Step.objects.filter(id__in=[transition.from_step.pk, transition.to_step.pk])
-        )
+        assert mvs.get_filterset_class(request=super_user_get_request)().filter_by_transition(qs, "", None) == qs
+        assert set(
+            mvs.get_filterset_class(request=super_user_get_request)().filter_by_transition(qs, "", transition)
+        ) == set(Step.objects.filter(id__in=[transition.from_step.pk, transition.to_step.pk]))
 
-    def test_email_filter_template_name(self, email_step_factory):
+    def test_email_filter_template_name(self, super_user_get_request, email_step_factory):
         step = email_step_factory()
         email_step_factory()
         mvs = EmailStepModelViewSet(kwargs={})
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
         qs = mvs.get_queryset()
-        assert mvs.get_filterset_class(request=request)().filter_template_name(qs, "", None) == qs
-        assert mvs.get_filterset_class(request=request)().filter_template_name(qs, "", step.template.name).count() == 1
+        assert mvs.get_filterset_class(request=super_user_get_request)().filter_template_name(qs, "", None) == qs
+        assert (
+            mvs.get_filterset_class(request=super_user_get_request)()
+            .filter_template_name(qs, "", step.template.name)
+            .count()
+            == 1
+        )
         assert (
-            mvs.get_filterset_class(request=request)().filter_template_name(qs, "", step.template.name).first() == step
+            mvs.get_filterset_class(request=super_user_get_request)()
+            .filter_template_name(qs, "", step.template.name)
+            .first()
+            == step
         )
 
 
 @pytest.mark.django_db
 class TestTransition:
-    api_factory = APIRequestFactory()
-
-    def test_filter_by_condition(self, condition_factory, transition_factory):
+    def test_filter_by_condition(self, super_user_get_request, condition_factory, transition_factory):
         transition_factory()
         condition = condition_factory()
         mvs = TransitionModelViewSet(kwargs={})
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
         qs = mvs.get_queryset()
-        assert mvs.filterset_class(request=request).filter_by_condition(qs, "", None) == qs
-        assert mvs.filterset_class(request=request).filter_by_condition(qs, "", condition).count() == 1
+        assert mvs.filterset_class(request=super_user_get_request).filter_by_condition(qs, "", None) == qs
+        assert mvs.filterset_class(request=super_user_get_request).filter_by_condition(qs, "", condition).count() == 1
         assert (
-            mvs.filterset_class(request=request).filter_by_condition(qs, "", condition).first() == condition.transition
+            mvs.filterset_class(request=super_user_get_request).filter_by_condition(qs, "", condition).first()
+            == condition.transition
         )

wbcore/contrib/workflow/tests/test_models/step/test_decision_step.py

@@ -1,79 +1,82 @@
-from unittest.mock import patch
-
 import pytest
-from wbcore.contrib.directory.factories import PersonFactory
-from wbcore.contrib.workflow.models import Condition
+from pytest_mock import MockerFixture
+from wbcore.contrib.workflow.models import DecisionStep, Transition
 
 
-@pytest.mark.django_db
 class TestDecisionStep:
+    @pytest.fixture
+    def mocked_instances(self, mocker: MockerFixture):
+        return mocker.MagicMock(first_name="John")
+
+    @pytest.fixture
+    def mocked_decision_step(self, mocker: MockerFixture):
+        return mocker.MagicMock(spec=DecisionStep)
+
     def test_get_first_valid_transition(
-        self, process_step_factory, decision_step_factory, transition_factory, condition_factory
+        self,
+        mocker: MockerFixture,
+        mocked_process_step,
+        mocked_instances,
+        mocked_decision_step,
     ):
-        attached_instance = PersonFactory()
-        step = decision_step_factory()
-        process_step = process_step_factory(process__instance=attached_instance, step=step)
-        valid_transition1 = transition_factory(from_step=step)
-        valid_transition2 = transition_factory(from_step=step)
-        invalid_transition = transition_factory(from_step=step)
-        transition_factory()
-        condition_factory(
-            transition=invalid_transition,
-            attribute_name="first_name",
-            expected_value=attached_instance.first_name,
-            operator=Condition.Operator.EQ,
-            negate_operator=True,
-        )
-        assert step.get_first_valid_transition(process_step) in [valid_transition1, valid_transition2]
+        # Arrange
+        mocked_process_step.get_instance.return_value = mocked_instances
+        mocked_process_step.step = mocked_decision_step
+        valid_transition1 = mocker.MagicMock(spec=Transition)
+        valid_transition2 = mocker.MagicMock(spec=Transition)
+        invalid_transition = mocker.MagicMock(spec=Transition)
+        mocked_decision_step.get_outgoing_transitions.return_value = [
+            invalid_transition,
+            valid_transition1,
+            valid_transition2,
+        ]
+        invalid_transition.all_conditions_satisfied.return_value = False
+        valid_transition1.all_conditions_satisfied.return_value = True
+        valid_transition2.all_conditions_satisfied.return_value = True
+        # Act
+        result = DecisionStep.get_first_valid_transition(mocked_decision_step, mocked_process_step)
+        # Assert
+        assert result in [valid_transition1, valid_transition2]
+        invalid_transition.all_conditions_satisfied.assert_called_once_with(mocked_process_step)
+        valid_transition1.all_conditions_satisfied.assert_called_once_with(mocked_process_step)
+        valid_transition2.all_conditions_satisfied.assert_not_called()
 
     def test_get_first_valid_transition_no_transitions(
-        self, process_step_factory, decision_step_factory, transition_factory, condition_factory
+        self, mocker, mocked_process_step, mocked_instances, mocked_decision_step
     ):
-        attached_instance = PersonFactory()
-        step = decision_step_factory()
-        process_step = process_step_factory(process__instance=attached_instance, step=step)
-        invalid_transition = transition_factory(from_step=step)
-        transition_factory()
-        condition_factory(
-            transition=invalid_transition,
-            attribute_name="first_name",
-            expected_value=attached_instance.first_name,
-            operator=Condition.Operator.EQ,
-            negate_operator=True,
-        )
-        assert step.get_first_valid_transition(process_step) is None
+        # Arrange
+        mocked_process_step.get_instance.return_value = mocked_instances
+        mocked_process_step.step = mocked_decision_step
+        invalid_transition = mocker.MagicMock(spec=Transition)
+        mocked_decision_step.get_outgoing_transitions.return_value = [invalid_transition]
+        invalid_transition.all_conditions_satisfied.return_value = False
+        # Act
+        result = DecisionStep.get_first_valid_transition(mocked_decision_step, mocked_process_step)
+        # Assert
+        assert result is None
+        invalid_transition.all_conditions_satisfied.assert_called_once_with(mocked_process_step)
 
-    @patch("wbcore.contrib.workflow.models.step.DecisionStep.get_first_valid_transition")
-    @patch("wbcore.contrib.workflow.models.step.Step.start_next_step")
-    def test_run(
-        self,
-        mock_next,
-        mock_transition,
-        process_step_factory,
-        transition_factory,
-        decision_step_factory,
-    ):
-        transition = transition_factory()
-        mock_transition.return_value = transition
-        step = decision_step_factory()
-        process_step = process_step_factory(step=step)
-        step.run(process_step)
-        assert mock_next.call_args.args == (process_step, transition)
+    def test_run(self, mocker: MockerFixture, mocked_process_step, mocked_decision_step):
+        # Arrange
+        mocked_start_next_step = mocker.patch("wbcore.contrib.workflow.models.step.Step.start_next_step")
+        mocked_transition = mocker.MagicMock(spec=Transition)
+        mocked_decision_step.get_first_valid_transition.return_value = mocked_transition
+        # Act
+        DecisionStep.run(mocked_decision_step, mocked_process_step)
+        # Assert
+        mocked_decision_step.get_first_valid_transition.assert_called_once_with(mocked_process_step)
+        mocked_start_next_step.assert_called_once_with(mocked_process_step, mocked_transition)
 
-    @patch("wbcore.contrib.workflow.models.step.Step.set_failed")
-    @patch("wbcore.contrib.workflow.models.step.activate_step.delay")
-    @patch("wbcore.contrib.workflow.models.step.DecisionStep.get_first_valid_transition")
-    def test_run_failed(
-        self,
-        mock_transition,
-        mock_activate,
-        mock_failed,
-        process_step_factory,
-        decision_step_factory,
-    ):
-        mock_transition.return_value = None
-        step = decision_step_factory()
-        process_step = process_step_factory(step=step)
-        step.run(process_step)
-        assert mock_failed.call_args.args[0] == process_step
-        assert not mock_activate.called
+    def test_run_failed(self, mocker: MockerFixture, mocked_process_step, mocked_decision_step):
+        # Arrange
+        mocked_activate_step = mocker.patch("wbcore.contrib.workflow.models.step.activate_step.delay")
+        mocked_decision_step.get_first_valid_transition.return_value = None
+        mocked_set_failed = mocker.patch.object(mocked_decision_step, "set_failed")
+        # Act
+        DecisionStep.run(mocked_decision_step, mocked_process_step)
+        # Assert
+        mocked_decision_step.get_first_valid_transition.assert_called_once_with(mocked_process_step)
+        mocked_set_failed.assert_called_once_with(
+            mocked_process_step, "No valid outgoing transition found for this step!"
+        )
+        mocked_activate_step.assert_not_called()