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

wbcore/contrib/workflow/tests/test_serializers.py

@@ -1,8 +1,9 @@
 import pytest
+from pytest_mock import MockerFixture
 from rest_framework.test import APIRequestFactory
 
-from wbcore.contrib.authentication.factories import GroupFactory, UserFactory
-from wbcore.contrib.workflow.models import ProcessStep, Step
+from wbcore.contrib.authentication.models import Group, User
+from wbcore.contrib.workflow.models import ProcessStep, Step, Transition, UserStep
 from wbcore.contrib.workflow.serializers import (
     AssignedProcessStepSerializer,
     ProcessStepModelSerializer,
@@ -10,169 +11,190 @@ from wbcore.contrib.workflow.serializers import (
 from wbcore.test.utils import get_or_create_superuser
 
 
-@pytest.mark.django_db
-class TestProcessStep:
-    api_factory = APIRequestFactory()
+@pytest.fixture
+def process_step(mocker: MockerFixture):
+    mocked_process_step = mocker.MagicMock(spec=ProcessStep)
+    mocked_process_step.pk = 1
+    mocked_process_step.state = ProcessStep.StepState.ACTIVE
+    return mocked_process_step
 
-    def test_next_process_step_buttons_superuser(self, transition_factory, process_step_factory, user_step_factory):
-        step = user_step_factory()
-        transition1 = transition_factory(
-            from_step=step,
-        )
-        transition2 = transition_factory(
-            from_step=step,
-        )
-        transition_factory(to_step=step)
-        transition_factory()
-        process_step = process_step_factory(step=step, state=ProcessStep.StepState.ACTIVE)
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
-        serializer = ProcessStepModelSerializer(process_step, context={"request": request})
-        assert serializer.data
-        transition_labels = {x["label"] for x in serializer.data["_buttons"]}
-        assert transition_labels == {transition1.name, transition2.name}
 
-    def test_next_process_step_buttons_assignee(self, transition_factory, process_step_factory, user_step_factory):
-        step = user_step_factory()
-        transition = transition_factory(
-            from_step=step,
-        )
-        user = UserFactory()
-        process_step = process_step_factory(assignee=user, step=step, state=ProcessStep.StepState.ACTIVE)
-        request = self.api_factory.get("")
-        request.user = user
-        serializer = ProcessStepModelSerializer(process_step, context={"request": request})
-        assert serializer.data
-        assert serializer.data["_buttons"][0]["label"] == transition.name
-
-    def test_next_process_step_buttons_group(self, transition_factory, process_step_factory, user_step_factory):
-        step = user_step_factory(assignee_method=None)
-        transition = transition_factory(
-            from_step=step,
-        )
-        group = GroupFactory()
-        user = UserFactory(groups=[group])
-        process_step = process_step_factory(group=group, step=step, state=ProcessStep.StepState.ACTIVE)
-        request = self.api_factory.get("")
-        request.user = user
-        serializer = ProcessStepModelSerializer(process_step, context={"request": request})
-        assert serializer.data
-        assert serializer.data["_buttons"][0]["label"] == transition.name
-
-    @pytest.mark.parametrize(
-        "state",
-        [
-            ProcessStep.StepState.CANCELED,
-            ProcessStep.StepState.FAILED,
-            ProcessStep.StepState.FINISHED,
-            ProcessStep.StepState.WAITING,
-        ],
-    )
-    def test_next_process_step_buttons_not_active(
-        self, state, transition_factory, process_step_factory, user_step_factory
-    ):
-        step = user_step_factory()
-        transition_factory(
-            from_step=step,
+class TestProcessStep:
+    @pytest.fixture
+    def transitions(self, mocker: MockerFixture):
+        transition_1 = mocker.MagicMock(spec=Transition)
+        transition_1.pk = 101
+        transition_1.name = "Transition One"
+        transition_1.icon = "icon_1"
+
+        transition_2 = mocker.MagicMock(spec=Transition)
+        transition_2.pk = 102
+        transition_2.name = "Transition Two"
+        transition_2.icon = "icon_2"
+
+        return (transition_1, transition_2)
+
+    @pytest.fixture
+    def casted_step(self, mocker: MockerFixture):
+        mocked_casted_step = mocker.MagicMock(spec=Step, assignee_method=False)
+        return mocked_casted_step
+
+    @pytest.fixture
+    def user_step(self, mocker: MockerFixture, casted_step, transitions):
+        mocked_user_step = mocker.MagicMock(spec=UserStep)
+        mocked_user_step.step_type = Step.StepType.USERSTEP
+        mocked_user_step.get_casted_step.return_value = casted_step
+        mocked_user_step.get_all_valid_outgoing_transitions.return_value = [*transitions]
+        return mocked_user_step
+
+    @pytest.fixture(autouse=True)
+    def mocked_patch_path(self, mocker: MockerFixture):
+        mocker.patch(
+            "wbcore.contrib.workflow.models.workflow",
+            return_value="/dummy-url/",
         )
-        process_step = process_step_factory(step=step, state=state)
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
-        serializer = ProcessStepModelSerializer(process_step, context={"request": request})
-        assert serializer.data
-        assert serializer.data["_buttons"] == []
-
-    @pytest.mark.parametrize(
-        "step_type",
-        [
-            Step.StepType.DECISIONSTEP,
-            Step.StepType.EMAILSTEP,
-            Step.StepType.FINISHSTEP,
-            Step.StepType.JOINSTEP,
-            Step.StepType.SCRIPTSTEP,
-            Step.StepType.SPLITSTEP,
-        ],
-    )
-    def test_next_process_step_buttons_not_user_step(
-        self, step_type, transition_factory, process_step_factory, step_factory
-    ):
-        step = step_factory(step_type=step_type)
-        transition_factory(
-            from_step=step,
+        mocker.patch(
+            "wbcore.contrib.workflow.dispatch.ContentType.objects.get_for_model",
+            return_value="content_type",
         )
-        process_step = process_step_factory(step=step, state=ProcessStep.StepState.ACTIVE)
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
-        serializer = ProcessStepModelSerializer(process_step, context={"request": request})
-        assert serializer.data
-        assert serializer.data["_buttons"] == []
 
-    def test_next_process_step_buttons_not_assigned(self, transition_factory, process_step_factory, user_step_factory):
-        step = user_step_factory()
-        transition_factory(
-            from_step=step,
-        )
-        process_step = process_step_factory(step=step, state=ProcessStep.StepState.ACTIVE)
-        request = self.api_factory.get("")
-        request.user = UserFactory()
-        serializer = ProcessStepModelSerializer(process_step, context={"request": request})
-        assert serializer.data
-        assert serializer.data["_buttons"] == []
-
-    def test_next_process_step_buttons_assigned_group_with_method(
-        self, transition_factory, process_step_factory, user_step_factory
+    @pytest.mark.parametrize("user", ["super_user", "user", "group"])
+    def test_next_process_step_buttons(self, mocker: MockerFixture, user, process_step, user_step):
+        """
+        This test verifies that the method next_process_step_buttons returns buttons when:
+        - "super_user": The user is a superuser.
+        - "user": The user is the assignee of the process step.
+        - "group": The user belongs to the group assigned to the process step.
+        """
+        # Arrange
+        mocked_process_step = process_step
+        mocked_process_step.step = user_step
+
+        request_user = mocker.MagicMock(spec=User, is_superuser=(user == "super_user"))
+        if user == "user":
+            mocked_process_step.assignee = request_user
+        elif user == "group":
+            mocked_group = mocker.MagicMock(spec=Group)
+            mocked_group.user_set.all.return_value = [request_user]
+            mocked_process_step.group = mocked_group
+        request = mocker.MagicMock(user=request_user)
+
+        # Act
+        serializer = ProcessStepModelSerializer(mocked_process_step, context={"request": request})
+        data = serializer.data
+        button_labels = {button["label"] for button in data["_buttons"]}
+
+        # Assert
+        assert len(data["_buttons"]) == 2
+        assert button_labels == {"Transition One", "Transition Two"}
+
+    @pytest.mark.parametrize("reason", ["finished_state", "not_user_step"])
+    def test_no_transition_buttons_when_step_is_not_eligible(
+        self, mocker: MockerFixture, reason, process_step, user_step
     ):
-        step = user_step_factory()
-        transition_factory(
-            from_step=step,
-        )
-        group = GroupFactory()
-        user = UserFactory(groups=[group])
-        process_step = process_step_factory(group=group, step=step, state=ProcessStep.StepState.ACTIVE)
-        request = self.api_factory.get("")
-        request.user = user
-        serializer = ProcessStepModelSerializer(process_step, context={"request": request})
-        assert serializer.data
-        assert serializer.data["_buttons"] == []
+        """
+        Test that no transition buttons appear if:
+        - The process step is in a non-active state, OR
+        - The step is not a UserStep type.
+        """
+        # Arrange
+        mocked_process_step = process_step
+        if reason == "inactive_state":
+            mocked_process_step.state = ProcessStep.StepState.FINISHED
+        else:
+            user_step.step_type = Step.StepType.SPLITSTEP
+
+        super_user = mocker.MagicMock(spec=User, is_superuser=True)
+        request = mocker.MagicMock(user=super_user)
+        # Act
+        serializer = ProcessStepModelSerializer(mocked_process_step, context={"request": request})
+        data = serializer.data
+
+        # Assert
+        assert len(data["_buttons"]) == 0
+
+    def test_next_process_step_buttons_not_assigned(self, mocker: MockerFixture, process_step, user_step, casted_step):
+        """
+        No buttons when there is a assignee_method
+        """
+        # Arrange
+        request_user = mocker.MagicMock(spec=User, is_superuser=False)
+        request = mocker.MagicMock(user=request_user)
+
+        mocked_group = mocker.MagicMock(spec=Group)
+        mocked_group.user_set.all.return_value = [request_user]
+
+        mocked_casted_step = casted_step
+        mocked_casted_step.assignee_method = True
+
+        mocked_user_step = user_step
+        mocked_user_step.get_casted_step.return_value = casted_step
+
+        mocked_process_step = process_step
+        mocked_process_step.step = mocked_user_step
+        mocked_process_step.group = mocked_group
+
+        # Act
+        serializer = ProcessStepModelSerializer(mocked_process_step, context={"request": request})
+        data = serializer.data
+        # Assert
+        assert len(data["_buttons"]) == 0
 
     def test_next_process_step_buttons_no_transitions(
-        self, transition_factory, process_step_factory, user_step_factory
+        self, mocker: MockerFixture, process_step, user_step, casted_step
     ):
-        step = user_step_factory()
-        transition_factory()
-        transition_factory(to_step=step)
-        transition_factory()
-        process_step = process_step_factory(step=step, state=ProcessStep.StepState.ACTIVE)
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
-        serializer = ProcessStepModelSerializer(process_step, context={"request": request})
-        assert serializer.data
-        assert serializer.data["_buttons"] == []
+        """
+        No transitions no buttons
+        """
+        # Arrange
+        request_user = mocker.MagicMock(spec=User, is_superuser=True)
+        request = mocker.MagicMock(user=request_user)
 
+        mocked_user_step = user_step
+        mocked_user_step.get_all_valid_outgoing_transitions.return_value = []
 
-@pytest.mark.django_db
-class TestAssignedProcessStep:
-    api_factory = APIRequestFactory()
+        mocked_process_step = process_step
+        mocked_process_step.step = user_step
 
-    def test_get_instance_endpoint_no_request(self, process_step_factory):
-        process_step = process_step_factory()
-        serializer = AssignedProcessStepSerializer(process_step)
-        assert serializer.data
-        assert serializer.data["instance_endpoint"] == ""
+        # Act
+        serializer = ProcessStepModelSerializer(mocked_process_step, context={"request": request})
+        data = serializer.data
+        # Assert
+        assert len(data["_buttons"]) == 0
 
-    def test_get_instance_endpoint_no_attached_instance(self, process_step_factory):
-        process_step = process_step_factory(process__instance=None, process__instance_id=None)
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
-        serializer = AssignedProcessStepSerializer(process_step, context={"request": request})
+
+class TestAssignedProcessStep:
+    @pytest.fixture
+    def process_step_with_assignee(self, mocker: MockerFixture, process_step):
+        mocked_step = mocker.MagicMock(spec=Step)
+        mocked_step.id = 42
+        mocked_user = mocker.MagicMock(spec=User)
+        mocked_user.id = 3
+        process_step.step = mocked_step
+        process_step.assignee = mocked_user
+        return process_step
+
+    def test_get_instance_endpoint_no_request(self, mocker: MockerFixture, process_step_with_assignee):
+        serializer = AssignedProcessStepSerializer(process_step_with_assignee)
         assert serializer.data
-        assert "processstep" in serializer.data["instance_endpoint"]
+        assert serializer.data["instance_endpoint"] == ""
 
-    def test_get_instance_endpoint_attached_instance(self, process_step_factory):
-        process_step = process_step_factory()
-        request = self.api_factory.get("")
+    @pytest.mark.django_db
+    @pytest.mark.with_db
+    @pytest.mark.parametrize("with_instance", [True, False])
+    def test_get_instance_endpoint_no_attached_instance(self, process_step_factory, with_instance):
+        api_factory = APIRequestFactory()
+        process_step = (
+            process_step_factory()
+            if with_instance
+            else process_step_factory(process__instance=None, process__instance_id=None)
+        )
+        request = api_factory.get("")
         request.user = get_or_create_superuser()
         serializer = AssignedProcessStepSerializer(process_step, context={"request": request})
         assert serializer.data
-        assert "processstep" not in serializer.data["instance_endpoint"]
-        assert "person" in serializer.data["instance_endpoint"]
+        if with_instance:
+            assert "processstep" not in serializer.data["instance_endpoint"]
+            assert "person" in serializer.data["instance_endpoint"]
+        else:
+            assert "processstep" in serializer.data["instance_endpoint"]