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

wbcore/contrib/workflow/tests/test_viewsets.py

@@ -1,359 +1,300 @@
 from unittest.mock import patch
 
 import pytest
+from pytest import FixtureRequest
 from rest_framework import status
-from rest_framework.test import APIRequestFactory
 
-from wbcore.contrib.authentication.factories import GroupFactory, UserFactory
-from wbcore.contrib.authentication.models import Permission
-from wbcore.contrib.directory.factories import EmailContactFactory, PersonFactory
-from wbcore.contrib.directory.models import Person
-from wbcore.contrib.workflow.models import EmailStep, ProcessStep, Step
-from wbcore.contrib.workflow.sites import workflow_site
+from wbcore.contrib.authentication.factories import (
+    GroupFactory,
+    UserFactory,
+)
+from wbcore.contrib.workflow.models import (
+    Condition,
+    Data,
+    DecisionStep,
+    Process,
+    ProcessStep,
+    Transition,
+    Workflow,
+)
 from wbcore.contrib.workflow.viewsets import (
     AssignedProcessStepModelViewSet,
-    EmailStepModelViewSet,
+    ConditionModelViewSet,
+    DataModelViewSet,
+    DecisionStepModelViewSet,
+    ProcessModelViewSet,
     ProcessStepModelViewSet,
+    TransitionModelViewSet,
     WorkflowModelViewSet,
 )
-from wbcore.test.utils import get_data_from_factory, get_kwargs, get_or_create_superuser
 
 
 @pytest.mark.django_db
-class TestWorkflow:
-    api_factory = APIRequestFactory()
-
-    def test_get(self, workflow_factory):
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
-        workflow_factory.create_batch(3)
-        vs = WorkflowModelViewSet.as_view({"get": "list"})
-        response = vs(request)
-        assert response.data.get("results")
-        assert not response.data.get("instance")
-        assert len(response.data.get("results")) == 3
-        assert response.status_code == status.HTTP_200_OK
-
-    def test_retrieve(self, workflow_factory):
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
-        obj = workflow_factory()
-        vs = WorkflowModelViewSet.as_view({"get": "retrieve"})
-        response = vs(request, pk=obj.id)
-        assert response.data.get("instance")
-        assert not response.data.get("results")
-        assert response.status_code == status.HTTP_200_OK
-
-    def test_post(self, workflow_factory):
-        obj = workflow_factory()
-        super_user = get_or_create_superuser()
-        data = get_data_from_factory(obj, WorkflowModelViewSet, superuser=super_user, delete=True)
-        request = self.api_factory.post("", data=data)
+class TestViewSets:
+    @pytest.mark.parametrize(
+        "viewset, entries",
+        [
+            (AssignedProcessStepModelViewSet, "assigned_process_steps"),
+            (ConditionModelViewSet, "conditions"),
+            (DataModelViewSet, "data"),
+            (DecisionStepModelViewSet, "decision_steps"),
+            (ProcessModelViewSet, "processes"),
+            (ProcessStepModelViewSet, "process_steps"),
+            (TransitionModelViewSet, "transitions"),
+            (WorkflowModelViewSet, "workflows"),
+        ],
+    )
+    def test_get(self, request_factory, super_user, viewset, entries, request: FixtureRequest):
+        # Arrange
+        entries = request.getfixturevalue(entries)
+        request = request_factory.get("")
         request.user = super_user
-        kwargs = get_kwargs(obj, WorkflowModelViewSet, request)
-        vs = WorkflowModelViewSet.as_view({"post": "create"})
-        workflow_site.registered_model_classes_serializer_map[Person] = (
-            "wbcore.contrib.directory.serializers.PersonModelSerializer"
-        )
-        response = vs(request, **kwargs)
-        assert response.status_code == status.HTTP_201_CREATED
-
-    def test_delete(self, workflow_factory):
-        request = self.api_factory.delete("")
-        request.user = get_or_create_superuser()
-        obj = workflow_factory()
-        kwargs = get_kwargs(obj, WorkflowModelViewSet, request)
-        vs = WorkflowModelViewSet.as_view({"delete": "destroy"})
-        response = vs(request, **kwargs, pk=obj.pk)
-        assert response.status_code == status.HTTP_204_NO_CONTENT
-
-    def test_put(self, workflow_factory):
-        old_obj = workflow_factory()
-        new_obj = workflow_factory()
-        user = get_or_create_superuser()
-        data = get_data_from_factory(new_obj, WorkflowModelViewSet, superuser=user, delete=True)
-        request = self.api_factory.put("", data=data)
-        request.user = user
-        vs = WorkflowModelViewSet.as_view({"put": "update"})
-        workflow_site.registered_model_classes_serializer_map[Person] = (
-            "wbcore.contrib.directory.serializers.PersonModelSerializer"
-        )
-        response = vs(request, pk=old_obj.id)
-        assert response.status_code == status.HTTP_200_OK
-
-    def test_patch(self, workflow_factory):
-        obj = workflow_factory()
-        request = self.api_factory.patch("", data={"name": "New Name"})
-        request.user = get_or_create_superuser()
-        vs = WorkflowModelViewSet.as_view({"patch": "partial_update"})
-        workflow_site.registered_model_classes_serializer_map[Person] = (
-            "wbcore.contrib.directory.serializers.PersonModelSerializer"
-        )
-        response = vs(request, pk=obj.id)
+        viewset = viewset.as_view({"get": "list"})
+        # Act
+        response = viewset(request)
+        # Assert
+        assert response.data["count"] == 3
         assert response.status_code == status.HTTP_200_OK
 
-    @patch("wbcore.contrib.workflow.models.workflow.Workflow.start_workflow")
-    def test_start_without_attached_instance(self, mock_start, workflow_factory, start_step_factory):
-        workflow = workflow_factory(model=None, status_field=None, preserve_instance=False)
-        start_step = start_step_factory(workflow=workflow)
-        request = self.api_factory.patch("")
-        request.GET = request.GET.copy()
-        request.GET["step_id"] = start_step.pk
-        user = get_or_create_superuser()
-        request.user = user
-        response = WorkflowModelViewSet().start(request, pk=workflow.pk)
-        assert response.status_code == status.HTTP_200_OK
-        assert mock_start.call_args.args == (start_step, None)
-
-    @patch("wbcore.contrib.workflow.models.workflow.Workflow.start_workflow")
-    def test_start_with_attached_instance(self, mock_start, workflow_factory, start_step_factory):
-        attached_person = PersonFactory()
-        workflow = workflow_factory(preserve_instance=True)
-        start_step = start_step_factory()
-        request = self.api_factory.patch("")
-        request.GET = request.GET.copy()
-        request.GET["step_id"] = start_step.pk
-        request.GET["instance_id"] = attached_person.pk
-        user = get_or_create_superuser()
-        request.user = user
-        response = WorkflowModelViewSet().start(request, pk=workflow.pk)
+    @pytest.mark.parametrize(
+        "viewset, model",
+        [
+            (AssignedProcessStepModelViewSet, "assigned_process_step"),
+            (ConditionModelViewSet, "condition"),
+            (DataModelViewSet, "singular_data"),
+            (DecisionStepModelViewSet, "decision_step"),
+            (ProcessModelViewSet, "process"),
+            (ProcessStepModelViewSet, "process_step"),
+            (TransitionModelViewSet, "transition"),
+            (WorkflowModelViewSet, "workflow"),
+        ],
+    )
+    def test_retrieve(self, request_factory, super_user, viewset, model, request: FixtureRequest):
+        # Arrange
+        entries = request.getfixturevalue(model)
+        request = request_factory.get("")
+        request.user = super_user
+        vs = viewset.as_view({"get": "retrieve"})
+        # Act
+        response = vs(request, pk=entries.id)
+        instance = response.data.get("instance")
+        # Assert
+        assert instance is not None
+        assert instance["id"] == entries.id
         assert response.status_code == status.HTTP_200_OK
-        assert mock_start.call_args.args == (
-            start_step,
-            attached_person,
-        )
 
-
-@pytest.mark.django_db
-class TestEmailStep:
-    api_factory = APIRequestFactory()
-
-    def test_get(self, email_step_factory):
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
-        email_step_factory.create_batch(3)
-        vs = EmailStepModelViewSet.as_view({"get": "list"})
+    @pytest.mark.parametrize(
+        "viewset, build_data, can_create",
+        [
+            (AssignedProcessStepModelViewSet, "assigned_process_steps_build", False),
+            (ConditionModelViewSet, "condition_build", True),
+            (DataModelViewSet, "data_build", True),
+            (DecisionStepModelViewSet, "decision_step_build", True),
+            (ProcessModelViewSet, "process_build", False),
+            (ProcessStepModelViewSet, "process_steps_build", False),
+            (TransitionModelViewSet, "transition_build", True),
+            (WorkflowModelViewSet, "workflow_build", True),
+        ],
+    )
+    def test_create(
+        self,
+        request_factory,
+        super_user,
+        viewset,
+        build_data,
+        can_create,
+        request: FixtureRequest,
+    ):
+        # Arrange
+        data = request.getfixturevalue(build_data)
+        request = request_factory.post("", data=data, format="json")
+        request.user = super_user
+        vs = viewset.as_view({"post": "create"})
+        # Act
         response = vs(request)
-        assert response.data.get("results")
-        assert not response.data.get("instance")
-        assert len(response.data.get("results")) == 3
-        assert response.status_code == status.HTTP_200_OK
+        expected_status_code = status.HTTP_201_CREATED if can_create else status.HTTP_405_METHOD_NOT_ALLOWED
+        # Assert
+        assert response.status_code == expected_status_code
 
-    def test_retrieve(self, email_step_factory):
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
-        obj = email_step_factory()
-        vs = EmailStepModelViewSet.as_view({"get": "retrieve"})
-        response = vs(request, pk=obj.id)
-        assert response.data.get("instance")
-        assert not response.data.get("results")
-        assert response.status_code == status.HTTP_200_OK
-
-    def test_post(self, email_step_factory):
-        super_user = get_or_create_superuser()
-        email_contact = EmailContactFactory()
-        obj = email_step_factory(to=[email_contact])
-        data = {
-            "name": obj.name,
-            "template": obj.template.open(mode="rb"),
-            "step_type": obj.step_type,
-            "subject": obj.subject,
-            "to": obj.to.all().values_list("id", flat=True),
-            "workflow": obj.workflow.id,
-            "code": obj.code,
-            "status": obj.status,
-        }
-        request = self.api_factory.post("", data=data)
+    @pytest.mark.parametrize(
+        "viewset, entries, model",
+        [
+            (AssignedProcessStepModelViewSet, "assigned_process_steps", ProcessStep),
+            (ConditionModelViewSet, "conditions", Condition),
+            (DataModelViewSet, "data", Data),
+            (DecisionStepModelViewSet, "decision_steps", DecisionStep),
+            (ProcessModelViewSet, "processes", Process),
+            (ProcessStepModelViewSet, "process_steps", ProcessStep),
+            (TransitionModelViewSet, "transitions", Transition),
+            (WorkflowModelViewSet, "workflows", Workflow),
+        ],
+    )
+    def test_delete(
+        self,
+        request_factory,
+        super_user,
+        viewset,
+        entries,
+        model,
+        request: FixtureRequest,
+    ):
+        # Arrange
+        entries = request.getfixturevalue(entries)
+        entry_id = entries[1].id
+        request = request_factory.delete("", args=entry_id)
         request.user = super_user
-        EmailStep.objects.filter(pk=obj.pk).delete()
-        kwargs = get_kwargs(obj, EmailStepModelViewSet, request)
-        vs = EmailStepModelViewSet.as_view({"post": "create"})
-        response = vs(request, **kwargs)
-        assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
-
-        kwargs.pop("workflow_id")
-        response = vs(request, **kwargs)
-        assert response.status_code == status.HTTP_201_CREATED
-
-    def test_delete(self, email_step_factory):
-        request = self.api_factory.delete("")
-        request.user = get_or_create_superuser()
-        obj = email_step_factory()
-        kwargs = get_kwargs(obj, EmailStepModelViewSet, request)
-        vs = EmailStepModelViewSet.as_view({"delete": "destroy"})
-        response = vs(request, **kwargs, pk=obj.pk)
+        vs = viewset.as_view({"delete": "destroy"})
+        # Act
+        response = vs(request, pk=entry_id)
+        # Assert
         assert response.status_code == status.HTTP_204_NO_CONTENT
+        assert model.objects.count() == 2
+        assert not model.objects.filter(id=entry_id).exists()
 
-    def test_put(self, email_step_factory):
-        email_contact1 = EmailContactFactory()
-        email_contact2 = EmailContactFactory()
-        old_obj = email_step_factory(to=[email_contact1])
-        new_obj = email_step_factory(to=[email_contact2])
-        user = get_or_create_superuser()
-        data = {
-            "name": new_obj.name,
-            "template": new_obj.template.open(mode="rb"),
-            "step_type": new_obj.step_type,
-            "subject": new_obj.subject,
-            "to": new_obj.to.all().values_list("id", flat=True),
-            "workflow": new_obj.workflow.id,
-            "code": new_obj.code,
-            "status": new_obj.status,
-        }
-        request = self.api_factory.put("", data=data)
-        request.user = user
-        EmailStep.objects.filter(pk=new_obj.pk).delete()
-        vs = EmailStepModelViewSet.as_view({"put": "update"})
-        response = vs(request, pk=old_obj.id)
-        assert response.status_code == status.HTTP_200_OK
-        assert response.data["instance"]["name"] == new_obj.name
-        assert not response.data["instance"]["name"] == old_obj.name
-
-    def test_patch(self, email_step_factory):
-        obj = email_step_factory()
-        request = self.api_factory.patch("", data={"name": "New Name"})
-        request.user = get_or_create_superuser()
-        vs = EmailStepModelViewSet.as_view({"patch": "partial_update"})
-        response = vs(request, pk=obj.id)
-        assert response.status_code == status.HTTP_200_OK
-
-
-@pytest.mark.django_db
-class TestProcessStep:
-    api_factory = APIRequestFactory()
-
-    def test_get(self, process_step_factory):
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
-        process_step_factory.create_batch(3)
-        vs = ProcessStepModelViewSet.as_view({"get": "list"})
-        response = vs(request)
-        assert response.data.get("results")
-        assert not response.data.get("instance")
-        assert len(response.data.get("results")) == 3
-        assert response.status_code == status.HTTP_200_OK
-
-    def test_retrieve(self, process_step_factory):
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
-        obj = process_step_factory()
-        vs = ProcessStepModelViewSet.as_view({"get": "retrieve"})
-        response = vs(request, pk=obj.id)
-        assert response.data.get("instance")
-        assert not response.data.get("results")
+    @pytest.mark.parametrize(
+        "viewset, entry, new_entry",
+        [
+            (
+                AssignedProcessStepModelViewSet,
+                "assigned_process_step",
+                "assigned_process_steps_build",
+            ),
+            (ConditionModelViewSet, "condition", "condition_build"),
+            (DataModelViewSet, "singular_data", "data_build"),
+            (DecisionStepModelViewSet, "decision_step", "decision_step_build"),
+            (ProcessModelViewSet, "process", "process_build"),
+            (ProcessStepModelViewSet, "process_step", "process_steps_build"),
+            (TransitionModelViewSet, "transition", "transition_build"),
+            (WorkflowModelViewSet, "workflow", "workflow_build"),
+        ],
+    )
+    def test_put(
+        self,
+        request_factory,
+        super_user,
+        viewset,
+        entry,
+        new_entry,
+        request: FixtureRequest,
+    ):
+        # Arrange
+        entry = request.getfixturevalue(entry)
+        new_data = request.getfixturevalue(new_entry)
+        new_data["id"] = entry.id
+        request = request_factory.put("", data=new_data, format="json")
+        request.user = super_user
+        vs = viewset.as_view({"put": "update"})
+        # Act
+        response = vs(request, pk=entry.id)
+        # Assert
         assert response.status_code == status.HTTP_200_OK
 
-    def test_post(self, process_step_factory):
-        obj = process_step_factory()
-        super_user = get_or_create_superuser()
-        data = get_data_from_factory(obj, ProcessStepModelViewSet, superuser=super_user, delete=True)
-        request = self.api_factory.post("", data=data)
+    @pytest.mark.parametrize(
+        "viewset, entry, field, is_editable",
+        [
+            (AssignedProcessStepModelViewSet, "assigned_process_step", "status", False),
+            (ConditionModelViewSet, "condition", "expected_value", True),
+            (DataModelViewSet, "singular_data", "label", True),
+            (DecisionStepModelViewSet, "decision_step", "status", True),
+            (ProcessModelViewSet, "process", "state", False),
+            (ProcessStepModelViewSet, "process_step", "status", False),
+            (TransitionModelViewSet, "transition", "name", True),
+            (WorkflowModelViewSet, "workflow", "name", True),
+        ],
+    )
+    def test_patch(
+        self,
+        request_factory,
+        super_user,
+        viewset,
+        entry,
+        field,
+        is_editable,
+        request: FixtureRequest,
+    ):
+        # Arrange
+        entry = request.getfixturevalue(entry)
+        old_field_data = getattr(entry, field)
+        new_field_data = "Foo Bar"
+        request = request_factory.patch("", data={field: new_field_data})
         request.user = super_user
-        kwargs = get_kwargs(obj, ProcessStepModelViewSet, request)
-        vs = ProcessStepModelViewSet.as_view({"post": "create"})
-        response = vs(request, **kwargs)
-        assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
-
-    def test_delete(self, process_step_factory):
-        request = self.api_factory.delete("")
-        request.user = get_or_create_superuser()
-        obj = process_step_factory()
-        kwargs = get_kwargs(obj, ProcessStepModelViewSet, request)
-        vs = ProcessStepModelViewSet.as_view({"delete": "destroy"})
-        response = vs(request, **kwargs, pk=obj.pk)
-        assert response.status_code == status.HTTP_204_NO_CONTENT
-
-    def test_patch(self, process_step_factory):
-        obj = process_step_factory()
-        request = self.api_factory.patch("", data={"name": "New Name"})
-        request.user = get_or_create_superuser()
-        vs = ProcessStepModelViewSet.as_view({"patch": "partial_update"})
-        response = vs(request, pk=obj.id)
+        vs = viewset.as_view({"patch": "partial_update"})
+        # Act
+        response = vs(request, pk=entry.id)
+        field_data = new_field_data if is_editable else old_field_data
+        entry.refresh_from_db()
+        # Assert
         assert response.status_code == status.HTTP_200_OK
+        assert getattr(entry, field) == field_data
 
-    def test_get_queryset_superuser(self, process_step_factory):
-        process_step1 = process_step_factory(permission=Permission.objects.first())
-        process_step2 = process_step_factory()
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
-        mvs = ProcessStepModelViewSet(request=request, kwargs={})
-        assert set(str(x.pk) for x in mvs.get_queryset()) == {process_step2.pk, process_step1.pk}
-
-    def test_get_queryset_user_permission(self, process_step_factory):
-        permission = Permission.objects.first()
-        process_step1 = process_step_factory(permission=permission)
-        process_step2 = process_step_factory()
-        request = self.api_factory.get("")
-        user = UserFactory()
+    def test_get_process_step_su(self, request_factory, super_user, permission, process_step_factory):
+        # Arrange
+        process_step_a = process_step_factory(permission=permission)
+        process_step_b = process_step_factory()
+        request = request_factory.get("")
+        request.user = super_user
+        # Act
+        vs = ProcessStepModelViewSet(request=request, kwargs={})
+        qs = vs.get_queryset()
+        id_list = list(map(str, qs.values_list("id", flat=True)))
+        # Assert
+        assert process_step_a.id in id_list
+        assert process_step_b.id in id_list
+
+    def test_get_queryset_user_permission(self, request_factory, user, permission, process_step_factory):
+        # Arrange
         user.user_permissions.add(permission)
+        process_step_a = process_step_factory(permission=permission)
+        process_step_b = process_step_factory()
+        request = request_factory.get("")
         request.user = user
-        mvs = ProcessStepModelViewSet(request=request, kwargs={})
-        assert set(str(x.pk) for x in mvs.get_queryset()) == {process_step2.pk, process_step1.pk}
-
-    def test_get_queryset_group_permission(self, process_step_factory):
-        permission = Permission.objects.first()
-        process_step1 = process_step_factory(permission=permission)
-        process_step2 = process_step_factory()
-        request = self.api_factory.get("")
+        # Act
+        vs = ProcessStepModelViewSet(request=request, kwargs={})
+        qs = vs.get_queryset()
+        id_list = list(map(str, qs.values_list("id", flat=True)))
+        # Assert
+        assert process_step_a.id in id_list
+        assert process_step_b.id in id_list
+
+    def test_get_queryset_user_no_permission(self, request_factory, user, permission, process_step_factory):
+        # Arrange
+        process_step_a = process_step_factory(permission=permission)
+        process_step_b = process_step_factory()
+        request = request_factory.get("")
+        request.user = user
+        # Act
+        vs = ProcessStepModelViewSet(request=request, kwargs={})
+        qs = vs.get_queryset()
+        id_list = list(map(str, qs.values_list("id", flat=True)))
+        # Assert
+        assert process_step_a.id not in id_list
+        assert process_step_b.id in id_list
+
+    def test_get_queryset_group_permission(self, request_factory, permission, process_step_factory):
+        # Arrange
+        process_step_a = process_step_factory(permission=permission)
+        process_step_b = process_step_factory()
         group = GroupFactory(permissions=[permission])
-        request.user = UserFactory(groups=[group])
-        mvs = ProcessStepModelViewSet(request=request, kwargs={})
-        assert set(str(x.pk) for x in mvs.get_queryset()) == {process_step1.pk, process_step2.pk}
-
-    def test_get_queryset_no_permission(self, process_step_factory):
-        process_step_factory(permission=Permission.objects.first())
-        process_step2 = process_step_factory()
-        request = self.api_factory.get("")
-        request.user = UserFactory()
-        mvs = ProcessStepModelViewSet(request=request, kwargs={})
-        assert set(str(x.pk) for x in mvs.get_queryset()) == {process_step2.pk}
+        user = UserFactory(is_superuser=False, groups=[group])
+        request = request_factory.get("")
+        request.user = user
+        # Act
+        vs = ProcessStepModelViewSet(request=request, kwargs={})
+        qs = vs.get_queryset()
+        id_list = list(map(str, qs.values_list("id", flat=True)))
+        # Assert
+        assert process_step_a.id in id_list
+        assert process_step_b.id in id_list
 
     @patch("wbcore.contrib.workflow.models.step.Step.start_next_step")
-    def test_next(self, mock_next, process_step_factory, transition_factory):
-        process_step = process_step_factory()
-        transition = transition_factory()
-        request = self.api_factory.get("")
-        request.user = get_or_create_superuser()
+    def test_next(self, mock_next, request_factory, super_user, process_step, transition):
+        request = request_factory.get("")
+        request.user = super_user
         request.GET = request.GET.copy()
-        request.GET["transition_id"] = transition.pk
+        request.GET["transition_id"] = transition.id
         response = ProcessStepModelViewSet().next(request, pk=process_step.pk)
         assert response.status_code == status.HTTP_200_OK
-        assert set(str(x.pk) for x in mock_next.call_args.args) == {process_step.pk, str(transition.pk)}
-
-    @pytest.mark.parametrize(
-        "bad_types",
-        [
-            Step.StepType.DECISIONSTEP,
-            Step.StepType.EMAILSTEP,
-            Step.StepType.FINISHSTEP,
-            Step.StepType.JOINSTEP,
-            Step.StepType.SCRIPTSTEP,
-            Step.StepType.SPLITSTEP,
-        ],
-    )
-    @pytest.mark.parametrize(
-        "bad_states",
-        [
-            ProcessStep.StepState.CANCELED,
-            ProcessStep.StepState.FAILED,
-            ProcessStep.StepState.FINISHED,
-            ProcessStep.StepState.WAITING,
-        ],
-    )
-    def test_assigned_process_steps(self, process_step_factory, user_step_factory, bad_types, bad_states):
-        request = self.api_factory.get("")
-        group = GroupFactory()
-        user = UserFactory(groups=[group], is_superuser=True)
-        request.user = user
-        step = user_step_factory(assignee_method=None)
-        process_step1 = process_step_factory(step=step, state=ProcessStep.StepState.ACTIVE, assignee=user)
-        process_step2 = process_step_factory(step=step, state=ProcessStep.StepState.ACTIVE, group=group)
-        process_step_factory(step__step_type=bad_types, state=ProcessStep.StepState.ACTIVE, assignee=user)
-        process_step_factory(step=step, state=bad_states, assignee=user)
-        vs = AssignedProcessStepModelViewSet.as_view({"get": "list"})
-        response = vs(request)
-        assert response.data.get("results")
-        assert not response.data.get("instance")
-        id_set = {x["id"] for x in response.data.get("results")}
-        assert id_set == {str(process_step1.pk), str(process_step2.pk)}
-        assert response.status_code == status.HTTP_200_OK
+        assert set(str(x.pk) for x in mock_next.call_args.args) == {
+            process_step.pk,
+            str(transition.pk),
+        }