wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/workflow/tests/test_filters.py

@@ -0,0 +1,104 @@
+import pytest
+from django.contrib.contenttypes.models import ContentType
+from rest_framework.test import APIRequestFactory
+
+from wbcore.contrib.workflow.models import Step
+from wbcore.contrib.workflow.viewsets import (
+    EmailStepModelViewSet,
+    StepModelViewSet,
+    TransitionModelViewSet,
+    WorkflowModelViewSet,
+)
+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:
+    @pytest.fixture()
+    def workflow_viewset(self):
+        return WorkflowModelViewSet()
+
+    def test_filter_attached_model(self, super_user_get_request, workflow_viewset, workflow_factory):
+        workflow_factory()
+        workflow_factory(model=ContentType.objects.first())
+        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, super_user_get_request, workflow_viewset, workflow_factory, data_factory):
+        workflow_factory()
+        data = data_factory()
+        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:
+    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={})
+        qs = mvs.get_queryset()
+        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, super_user_get_request, email_step_factory):
+        step = email_step_factory()
+        email_step_factory()
+        mvs = EmailStepModelViewSet(kwargs={})
+        qs = mvs.get_queryset()
+        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=super_user_get_request)()
+            .filter_template_name(qs, "", step.template.name)
+            .first()
+            == step
+        )
+
+
+@pytest.mark.django_db
+class TestTransition:
+    def test_filter_by_condition(self, super_user_get_request, condition_factory, transition_factory):
+        transition_factory()
+        condition = condition_factory()
+        mvs = TransitionModelViewSet(kwargs={})
+        qs = mvs.get_queryset()
+        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=super_user_get_request).filter_by_condition(qs, "", condition).first()
+            == condition.transition
+        )

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

@@ -0,0 +1,82 @@
+import pytest
+from pytest_mock import MockerFixture
+from wbcore.contrib.workflow.models import DecisionStep, Transition
+
+
+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,
+        mocker: MockerFixture,
+        mocked_process_step,
+        mocked_instances,
+        mocked_decision_step,
+    ):
+        # 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, mocker, mocked_process_step, mocked_instances, mocked_decision_step
+    ):
+        # 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)
+
+    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)
+
+    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()

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

@@ -0,0 +1,85 @@
+import pytest
+from django.conf import settings
+from django.template import TemplateSyntaxError
+from pytest_mock import MockerFixture
+from wbcore.contrib.workflow.models import EmailStep, ProcessStep
+
+
+class TestEmailStep:
+    @pytest.fixture
+    def mocked_email_step(self, mocker: MockerFixture):
+        mocked_email_step = mocker.MagicMock(spec=EmailStep)
+        mocked_email_step.subject = "Test Subject"
+        mocked_email_step.template.file = "<html>Email content</html>"
+        mocked_email_step.to.values_list.return_value = ["to@example.com"]
+        mocked_email_step.cc.values_list.return_value = [
+            "cc1@example.com",
+            "cc2@example.com",
+        ]
+        mocked_email_step.bcc.values_list.return_value = []
+        return mocked_email_step
+
+    @pytest.fixture
+    def mocked_process_step(self, mocker: MockerFixture):
+        mocked_process_step = mocker.MagicMock(spec=ProcessStep)
+        mocked_process_step.get_endpoint_basename.return_value = "process-step"
+        mocked_process_step.id = 123
+        return mocked_process_step
+
+    @pytest.fixture(autouse=True)
+    def patching(self, mocker: MockerFixture):
+        mocker.patch(
+            "wbcore.contrib.workflow.models.step.base_domain",
+            return_value="https://testserver.com",
+        )
+        mocker.patch(
+            "wbcore.contrib.workflow.models.step.reverse",
+            return_value="/api/process-step/123/",
+        )
+
+    def test_run(self, mocker: MockerFixture, mocked_process_step, mocked_email_step):
+        # Arrange
+        mocked_template_render = mocker.patch(
+            "django.template.Template.render",
+            return_value="<html>Rendered content</html>",
+        )
+        mocked_email_init = mocker.patch("django.core.mail.EmailMultiAlternatives.__init__", return_value=None)
+        mocked_email_send = mocker.patch("django.core.mail.EmailMultiAlternatives.send")
+        mocked_attach_alternative = mocker.patch("django.core.mail.EmailMultiAlternatives.attach_alternative")
+        mocker.patch(
+            "wbcore.contrib.workflow.models.step.convert_html2text",
+            return_value="Rendered content",
+        )
+        mocked_execute_single_next_step = mocker.patch.object(mocked_email_step, "execute_single_next_step")
+        # Act
+        EmailStep.run(mocked_email_step, mocked_process_step)
+        # Assert
+        mocked_template_render.assert_called_once_with(mocker.ANY)
+        mocked_email_init.assert_called_once_with(
+            "Test Subject",
+            "Rendered content",
+            settings.DEFAULT_FROM_EMAIL,
+            to=["to@example.com"],
+            cc=["cc1@example.com", "cc2@example.com"],
+            bcc=[],
+        )
+        mocked_attach_alternative.assert_called_once_with("<html>Rendered content</html>", "text/html")
+        mocked_email_send.assert_called_once()
+        mocked_execute_single_next_step.assert_called_once_with(mocked_process_step)
+
+    def test_run_failed(self, mocker: MockerFixture, mocked_process_step, mocked_email_step):
+        # Arrange
+        mocked_template_render = mocker.patch(
+            "django.template.Template.render",
+            side_effect=TemplateSyntaxError("Invalid syntax"),
+        )
+        mocked_email_send = mocker.patch("django.core.mail.EmailMultiAlternatives.send")
+        mocked_execute_single_next_step = mocker.patch.object(mocked_email_step, "execute_single_next_step")
+        mocked_set_failed = mocker.patch.object(mocked_email_step, "set_failed")
+        # Act
+        EmailStep.run(mocked_email_step, mocked_process_step)
+        # Assert
+        mocked_template_render.assert_called_once_with(mocker.ANY)
+        mocked_email_send.assert_not_called()
+        mocked_execute_single_next_step.assert_not_called()
+        mocked_set_failed.assert_called_once_with(mocked_process_step, "Error in template syntax!")

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

@@ -0,0 +1,167 @@
+import pytest
+from django.utils.translation import gettext
+from pytest_mock import MockerFixture
+from wbcore.contrib.workflow.models import FinishStep, Process, ProcessStep, Step
+
+
+class TestFinishStep:
+    @pytest.fixture(autouse=True)
+    def patch_super_finish(self, mocker: MockerFixture):
+        mocker.patch("wbcore.contrib.workflow.models.step.Step.finish", autospec=True)
+
+    @pytest.fixture
+    def mocked_finish_step(self, mocker: MockerFixture):
+        return mocker.MagicMock(spec=FinishStep)
+
+    @pytest.fixture
+    def mocked_instance(self, mocker: MockerFixture):
+        return mocker.MagicMock(first_name="Original")
+
+    @pytest.fixture
+    def mocked_process(self, mocker: MockerFixture, mocked_instance):
+        mocked_process = mocker.MagicMock(
+            finished=None,
+            instance=mocked_instance,
+            save=mocker.MagicMock(),
+            spec=Process,
+            state=Process.ProcessState.ACTIVE,
+        )
+        return mocked_process
+
+    @pytest.fixture
+    def mocked_process_step(self, mocker: MockerFixture, mocked_process):
+        return mocker.MagicMock(spec=ProcessStep, process=mocked_process)
+
+    def test_run(self, mocker: MockerFixture, mocked_process_step, mocked_finish_step):
+        # Arrange
+        mocked_qs = mocker.patch("wbcore.contrib.workflow.models.step.ProcessStep.objects.filter")
+        mocked_qs.return_value.exclude.return_value.exists.return_value = False
+        mocked_set_finished = mocker.patch.object(mocked_finish_step, "set_finished")
+        # Act
+        FinishStep.run(mocked_finish_step, mocked_process_step)
+        # Assert
+        mocked_set_finished.assert_called_once_with(mocked_process_step)
+
+    def test_run_failed(self, mocker: MockerFixture, mocked_process_step, mocked_finish_step):
+        # Arrange
+        mocked_qs = mocker.patch("wbcore.contrib.workflow.models.step.ProcessStep.objects.filter")
+        mocked_qs.return_value.exclude.return_value.exists.return_value = True
+        mocked_set_failed = mocker.patch.object(mocked_finish_step, "set_failed")
+        # Act
+        FinishStep.run(mocked_finish_step, mocked_process_step)
+        # Assert
+        mocked_set_failed.assert_called_once_with(
+            mocked_process_step,
+            gettext("There are process steps still running for this workflow!"),
+        )
+
+    @pytest.mark.parametrize(
+        "unfinished_state",
+        [
+            ProcessStep.StepState.ACTIVE,
+            ProcessStep.StepState.WAITING,
+            ProcessStep.StepState.CANCELED,
+            ProcessStep.StepState.FAILED,
+        ],
+    )
+    def test_finish_not_finished(
+        self,
+        mocker: MockerFixture,
+        mocked_process,
+        mocked_process_step,
+        unfinished_state,
+    ):
+        # Arrange
+        mocked_process.preserved_instance = {"first_name": "Test"}
+        mocked_process_step.state = unfinished_state
+
+        finish_step = FinishStep()
+        mock_serializer = mocker.patch("wbcore.contrib.workflow.models.step.get_model_serializer_class_for_instance")
+        # Act
+        finish_step.finish(mocked_process_step)
+        # Assert
+        mock_serializer.assert_not_called()
+        mocked_process_step.process.save.assert_not_called()
+        assert mocked_process.finished is None
+        assert mocked_process.state == Process.ProcessState.ACTIVE
+
+    def test_finish_write_preserved_instance(
+        self,
+        mocker: MockerFixture,
+        mocked_process,
+        mocked_process_step,
+    ):
+        # Arrange
+        preserved_data = {"first_name": "Updated"}
+
+        mocked_serializer = mocker.MagicMock()
+        mocked_serializer.validated_data = preserved_data
+        mocked_serializer_class = mocker.MagicMock()
+        mocked_serializer_class.return_value = mocked_serializer
+        mocker.patch(
+            "wbcore.contrib.workflow.models.step.get_model_serializer_class_for_instance",
+            return_value=mocked_serializer_class,
+        )
+        mocked_serializer.is_valid.return_value = True
+        mocked_serializer.update = mocker.MagicMock()
+
+        mocked_process.preserved_instance = preserved_data
+
+        mocked_step = mocker.MagicMock(spec=Step, write_preserved_instance=True)
+        mocked_step.workflow.preserve_instance = True
+
+        mocked_process_step.state = ProcessStep.StepState.FINISHED
+        mocked_process_step.step = mocked_step
+
+        finish_step = FinishStep()
+        mocker.patch.object(finish_step, "write_preserved_instance", True)
+        # Act
+        finish_step.finish(mocked_process_step)
+        # Assert
+        mocked_serializer.is_valid.assert_called_once()
+        mocked_serializer.update.assert_called_once_with(mocked_process.instance, preserved_data)
+        mocked_process.save.assert_called_once()
+        assert mocked_process.finished is not None
+        assert mocked_process.state == Process.ProcessState.FINISHED
+
+    def test_finish_do_not_write_mocker(self, mocker: MockerFixture, mocked_process, mocked_process_step):
+        # Arrange
+        mocked_process.preserved_instance = {"first_name": "Updated"}
+        mocked_process.state = Process.ProcessState.ACTIVE
+
+        mocked_process_step.state = ProcessStep.StepState.FINISHED
+
+        finish_step = FinishStep()
+        mocker.patch.object(finish_step, "write_preserved_instance", False)
+
+        mock_serializer = mocker.patch("wbcore.contrib.workflow.models.step.get_model_serializer_class_for_instance")
+
+        # Act
+        finish_step.finish(mocked_process_step)
+
+        # Assert
+        mock_serializer.assert_not_called()
+        mocked_process.save.assert_called_once()
+        assert mocked_process.finished is not None
+        assert mocked_process.state == Process.ProcessState.FINISHED
+
+    def test_finish_no_preserved_instance_mocker(self, mocker: MockerFixture, mocked_process, mocked_process_step):
+        # Arrange
+        mocked_process.preserved_instance = None
+        mocked_process.state = Process.ProcessState.ACTIVE
+
+        mocked_process_step.state = ProcessStep.StepState.FINISHED
+
+        finish_step = FinishStep()
+        mocker.patch.object(finish_step, "write_preserved_instance", True)
+
+        mock_serializer = mocker.patch("wbcore.contrib.workflow.models.step.get_model_serializer_class_for_instance")
+
+        # Act
+        finish_step.finish(mocked_process_step)
+
+        # Assert
+        mock_serializer.assert_not_called()
+        mocked_process.save.assert_called_once()
+        assert mocked_process.finished is not None
+        assert mocked_process.state == Process.ProcessState.FINISHED

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

@@ -0,0 +1,117 @@
+import pytest
+from django.db import models
+from pytest_mock import MockerFixture
+from wbcore.contrib.workflow.models import (
+    JoinStep,
+    ProcessStep,
+    Step,
+    Transition,
+)
+
+
+class TestJoinStep:
+    @pytest.fixture
+    def join_step(self):
+        return JoinStep()
+
+    @pytest.fixture
+    def mocked_step(self, mocker: MockerFixture):
+        return mocker.MagicMock(spec=Step, set_canceled=mocker.MagicMock())
+
+    @pytest.fixture
+    def mocked_process_step(self, mocker: MockerFixture, mocked_step):
+        return mocker.MagicMock(spec=ProcessStep, step=mocked_step)
+
+    @pytest.fixture
+    def mocked_transition(self, mocker: MockerFixture):
+        return mocker.MagicMock(spec=Transition)
+
+    @pytest.fixture
+    def mocked_execute_single_next_step(self, mocker: MockerFixture, join_step):
+        return mocker.patch.object(join_step, "execute_single_next_step")
+
+    def test_cancel_if_leading_to_self_transition_found(
+        self,
+        mocker: MockerFixture,
+        join_step,
+        mocked_step,
+        mocked_process_step,
+        mocked_transition,
+    ):
+        # Arrange
+        mocker.patch.object(join_step, "id", 1)
+        mocked_transition.to_step = join_step
+        mocked_step.outgoing_transitions.all.return_value = [mocked_transition]
+        # Act
+        join_step.cancel_if_leading_to_self(mocked_step, mocked_process_step)
+        # Assert
+        mocked_step.set_canceled.assert_called_once_with(mocked_process_step)
+
+    def test_cancel_if_leading_to_self_no_transition_found(
+        self,
+        mocker: MockerFixture,
+        join_step,
+        mocked_step,
+        mocked_process_step,
+        mocked_transition,
+    ):
+        # Arrange
+        mocked_step.outgoing_transitions.all.return_value = [mocked_transition]
+        # Act
+        join_step.cancel_if_leading_to_self(mocked_step, mocked_process_step)
+        # Assert
+        mocked_step.set_canceled.assert_not_called()
+
+    @pytest.mark.parametrize("with_transition_qs", [True, False])
+    def test_run_with_wait_for_all(
+        self,
+        mocker: MockerFixture,
+        join_step,
+        mocked_process_step,
+        with_transition_qs,
+        mocked_execute_single_next_step,
+    ):
+        # Arrange
+        mocker.patch.object(join_step, "wait_for_all", True)
+        mocked_process_step.save = mocker.MagicMock()
+        mocked_object_manager = mocker.patch("wbcore.contrib.workflow.models.transition.Transition.objects")
+        mocked_qs = mocker.MagicMock(spec=models.QuerySet)
+        mocked_qs.exists.return_value = with_transition_qs
+        mocked_object_manager.filter.return_value = mocked_qs
+        # Act
+        join_step.run(mocked_process_step)
+        # Assert
+        assert mocked_process_step.state == ProcessStep.StepState.WAITING
+        mocked_process_step.save.assert_called_once()
+        if with_transition_qs:
+            mocked_execute_single_next_step.assert_not_called()
+        else:
+            mocked_execute_single_next_step.assert_called_once_with(mocked_process_step)
+
+    def test_run_without_wait_for_all(
+        self,
+        mocker: MockerFixture,
+        join_step,
+        mocked_process_step,
+        mocked_execute_single_next_step,
+    ):
+        # Arrange
+        mocker.patch.object(join_step, "wait_for_all", False)
+
+        mocked_cancel_if_leading = mocker.patch.object(join_step, "cancel_if_leading_to_self")
+        mocked_process_step.save = mocker.MagicMock()
+        mocked_object_manager = mocker.patch("wbcore.contrib.workflow.models.step.ProcessStep.objects")
+        unfinished_step_a = mocker.MagicMock(spec=ProcessStep, pk=123, step=mocker.MagicMock(spec=Step))
+
+        unfinished_step_b = mocker.MagicMock(spec=ProcessStep, pk=456, step=mocker.MagicMock(spec=Step))
+
+        mocked_qs = mocker.MagicMock(spec=models.QuerySet)
+        mocked_qs.exclude.return_value = [unfinished_step_a, unfinished_step_b]
+        mocked_object_manager.filter.return_value = mocked_qs
+        # Act
+        join_step.run(mocked_process_step)
+        # Assert
+        assert mocked_process_step.state == ProcessStep.StepState.WAITING
+        assert mocked_cancel_if_leading.call_count == len(mocked_qs.exclude.return_value)
+        mocked_process_step.save.assert_called_once()
+        mocked_execute_single_next_step.assert_called_once()

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

@@ -0,0 +1,24 @@
+from unittest.mock import patch
+
+import pytest
+
+
+@pytest.mark.django_db
+class TestScriptStep:
+    @patch("wbcore.contrib.workflow.models.step.Step.set_failed")
+    @patch("wbcore.contrib.workflow.models.step.Step.execute_single_next_step")
+    def test_run(self, mock_execute, mock_failed, script_step_factory, process_step_factory):
+        step = script_step_factory()
+        process_step = process_step_factory(step=step)
+        step.run(process_step)
+        assert not mock_failed.called
+        assert mock_execute.call_args.args == (process_step,)
+
+    @patch("wbcore.contrib.workflow.models.step.Step.set_failed")
+    @patch("wbcore.contrib.workflow.models.step.Step.execute_single_next_step")
+    def test_run_failed(self, mock_execute, mock_failed, script_step_factory, process_step_factory):
+        step = script_step_factory(script="Test")
+        process_step = process_step_factory(step=step)
+        step.run(process_step)
+        assert mock_failed.call_args.args[0] == process_step
+        assert not mock_execute.called

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

@@ -0,0 +1,49 @@
+from unittest.mock import patch
+
+import pytest
+
+
+@pytest.mark.django_db
+class TestSplitStep:
+    @patch("wbcore.contrib.workflow.models.step.activate_step.delay")
+    @patch("wbcore.contrib.workflow.models.step.Step.get_all_valid_outgoing_transitions")
+    @patch("wbcore.contrib.workflow.models.step.Step.set_finished")
+    def test_run(
+        self,
+        mock_finished,
+        mock_transitions,
+        mock_activate,
+        process_step_factory,
+        transition_factory,
+        split_step_factory,
+    ):
+        transition1 = transition_factory()
+        transition2 = transition_factory()
+        transition_factory()
+        mock_transitions.return_value = [transition1, transition2]
+        step = split_step_factory()
+        process_step = process_step_factory(step=step)
+        step.run(process_step)
+        assert mock_finished.call_args.args == (process_step,)
+        assert mock_activate.call_args_list == [
+            ((transition1.to_step.pk, process_step.process.pk),),
+            ((transition2.to_step.pk, process_step.process.pk),),
+        ]
+
+    @patch("wbcore.contrib.workflow.models.step.activate_step.delay")
+    @patch("wbcore.contrib.workflow.models.step.Step.get_all_valid_outgoing_transitions")
+    @patch("wbcore.contrib.workflow.models.step.Step.set_failed")
+    def test_run_failed(
+        self,
+        mock_failed,
+        mock_transitions,
+        mock_activate,
+        process_step_factory,
+        split_step_factory,
+    ):
+        mock_transitions.return_value = []
+        step = split_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