wbcore 2.2.1__py2.py3-none-any.whl → 2.2.4__py2.py3-none-any.whl

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

@@ -0,0 +1,225 @@
+from unittest.mock import patch
+
+import pytest
+from rest_framework.reverse import reverse
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.directory.factories import BankingContactFactory, PersonFactory
+from wbcore.contrib.workflow.models import ProcessStep
+
+
+@pytest.mark.django_db
+class TestUserStep:
+    def test_get_assigned_group(self, user_step_factory):
+        user_step = user_step_factory()
+        assert user_step.get_assigned_group() == user_step.group
+
+    def test_get_assigned_user(self, user_step_factory):
+        user = UserFactory()
+        user_step = user_step_factory(assignee=user, group=None)
+        assert user_step.get_assigned_user() == user
+
+    def test_execute_assignee_method(self, process_step_factory, user_step_factory):
+        step = user_step_factory()
+        manager = PersonFactory()
+        manager_account = UserFactory(profile=manager)
+        assignee = PersonFactory(relationship_managers=[manager])
+        instance = BankingContactFactory(entry=assignee)
+        process_step = process_step_factory(step=step, process__instance=instance)
+        process_step.step.execute_assignee_method(
+            process_step, "manager_of_instance_assignee", assignee_field="entry", assignee_type="entry"
+        )
+        assert process_step.assignee == manager_account
+
+    @patch("wbcore.contrib.workflow.models.step.UserStep.execute_assignee_method")
+    @patch("wbcore.contrib.workflow.models.step.UserStep.notify_assignees")
+    def test_run(self, mock_notify, mock_execute, process_step_factory, transition_factory, user_step_factory):
+        kwargs = {"test": "Test"}
+        step = user_step_factory(notify_user=True, kwargs=kwargs)
+        user = UserFactory(groups=[step.group])
+        process_step = process_step_factory(state=ProcessStep.StepState.ACTIVE, step=step)
+        transition_factory(from_step=step)
+        step.run(process_step)
+        assert mock_notify.call_args.args == ([user], process_step)
+        assert mock_execute.call_args.args == (process_step, step.assignee_method)
+        assert mock_execute.call_args.kwargs == kwargs
+
+    @patch("wbcore.contrib.workflow.models.step.UserStep.execute_assignee_method")
+    @patch("wbcore.contrib.workflow.models.step.UserStep.notify_assignees")
+    def test_run_no_kwargs(
+        self, mock_notify, mock_execute, process_step_factory, transition_factory, user_step_factory
+    ):
+        step = user_step_factory(notify_user=True)
+        user = UserFactory(groups=[step.group])
+        process_step = process_step_factory(state=ProcessStep.StepState.ACTIVE, step=step)
+        transition_factory(from_step=step)
+        step.run(process_step)
+        assert mock_notify.call_args.args == ([user], process_step)
+        assert mock_execute.call_args.args == (process_step, step.assignee_method)
+        assert mock_execute.call_args.kwargs == {}
+
+    @patch("wbcore.contrib.workflow.models.step.UserStep.execute_assignee_method")
+    @patch("wbcore.contrib.workflow.models.step.UserStep.notify_assignees")
+    def test_run_no_notification(
+        self, mock_notify, mock_execute, process_step_factory, transition_factory, user_step_factory
+    ):
+        kwargs = {"test": "Test"}
+        step = user_step_factory(notify_user=False, kwargs=kwargs)
+        UserFactory(groups=[step.group])
+        process_step = process_step_factory(state=ProcessStep.StepState.ACTIVE, step=step)
+        transition_factory(from_step=step)
+        step.run(process_step)
+        assert not mock_notify.called
+        assert mock_execute.call_args.args == (process_step, step.assignee_method)
+        assert mock_execute.call_args.kwargs == kwargs
+
+    @patch("wbcore.contrib.workflow.models.step.UserStep.execute_assignee_method")
+    @patch("wbcore.contrib.workflow.models.step.UserStep.notify_assignees")
+    def test_run_assignee_method_failed(
+        self, mock_notify, mock_execute, process_step_factory, transition_factory, user_step_factory
+    ):
+        kwargs = {"test": "Test"}
+        step = user_step_factory(notify_user=True, kwargs=kwargs)
+        UserFactory(groups=[step.group])
+        process_step = process_step_factory(state=ProcessStep.StepState.FAILED, step=step)
+        transition_factory(from_step=step)
+        step.run(process_step)
+        assert not mock_notify.called
+        assert mock_execute.call_args.args == (process_step, step.assignee_method)
+        assert mock_execute.call_args.kwargs == kwargs
+
+    @patch("wbcore.contrib.workflow.models.step.UserStep.set_failed")
+    @patch("wbcore.contrib.workflow.models.step.UserStep.execute_assignee_method")
+    @patch("wbcore.contrib.workflow.models.step.UserStep.notify_assignees")
+    def test_run_no_assignee(
+        self, mock_notify, mock_execute, mock_failed, process_step_factory, transition_factory, user_step_factory
+    ):
+        kwargs = {"test": "Test"}
+        step = user_step_factory(notify_user=True, kwargs=kwargs)
+        process_step = process_step_factory(state=ProcessStep.StepState.ACTIVE, step=step)
+        transition_factory(from_step=step)
+        step.run(process_step)
+        assert not mock_notify.called
+        assert mock_execute.call_args.args == (process_step, step.assignee_method)
+        assert mock_execute.call_args.kwargs == kwargs
+        assert mock_failed.call_args.args[0] == process_step
+
+    @patch("wbcore.contrib.workflow.models.step.UserStep.set_failed")
+    @patch("wbcore.contrib.workflow.models.step.UserStep.execute_assignee_method")
+    @patch("wbcore.contrib.workflow.models.step.UserStep.notify_assignees")
+    def test_run_no_transition(
+        self, mock_notify, mock_execute, mock_failed, process_step_factory, transition_factory, user_step_factory
+    ):
+        kwargs = {"test": "Test"}
+        step = user_step_factory(notify_user=True, kwargs=kwargs)
+        UserFactory(groups=[step.group])
+        process_step = process_step_factory(state=ProcessStep.StepState.ACTIVE, step=step)
+        step.run(process_step)
+        assert not mock_notify.called
+        assert mock_execute.call_args.args == (process_step, step.assignee_method)
+        assert mock_execute.call_args.kwargs == kwargs
+        assert mock_failed.call_args.args[0] == process_step
+
+    @patch("wbcore.contrib.workflow.models.step.process_can_finish.delay")
+    @patch("wbcore.contrib.workflow.models.step.UserStep.notify_assignees")
+    def test_set_failed_user_step_notify_user(
+        self, mock_notify, mock_can_finish, process_step_factory, user_step_factory
+    ):
+        step = user_step_factory(notify_user=True)
+        UserFactory(groups=[step.group])
+        process_step = process_step_factory(step=step, error_message=None)
+        error_message = "Error message"
+        step.set_failed(process_step, error_message)
+        assert process_step.state == ProcessStep.StepState.FAILED
+        assert process_step.error_message == error_message
+        assert mock_notify.call_args.args == (process_step.get_all_assignees(), process_step, error_message)
+        assert mock_can_finish.call_args.args == (process_step.process.pk,)
+
+    @patch("wbcore.contrib.workflow.models.step.process_can_finish.delay")
+    @patch("wbcore.contrib.workflow.models.step.UserStep.notify_assignees")
+    def test_set_failed_user_step_not_notify(
+        self, mock_notify, mock_can_finish, process_step_factory, user_step_factory
+    ):
+        step = user_step_factory(notify_user=False)
+        UserFactory(groups=[step.group])
+        process_step = process_step_factory(step=step, error_message=None)
+        error_message = "Error message"
+        step.set_failed(process_step, error_message)
+        assert process_step.state == ProcessStep.StepState.FAILED
+        assert process_step.error_message == error_message
+        assert not mock_notify.called
+        assert mock_can_finish.call_args.args == (process_step.process.pk,)
+
+    @patch("wbcore.contrib.workflow.models.step.process_can_finish.delay")
+    @patch("wbcore.contrib.workflow.models.step.UserStep.notify_assignees")
+    def test_set_failed_user_step_no_assignees(
+        self, mock_notify, mock_can_finish, process_step_factory, user_step_factory
+    ):
+        step = user_step_factory(notify_user=True)
+        process_step = process_step_factory(step=step, error_message=None)
+        error_message = "Error message"
+        step.set_failed(process_step, error_message)
+        assert process_step.state == ProcessStep.StepState.FAILED
+        assert process_step.error_message == error_message
+        assert not mock_notify.called
+        assert mock_can_finish.call_args.args == (process_step.process.pk,)
+
+    @patch("wbcore.contrib.workflow.models.step.send_notification")
+    def test_notify_single_assignee(self, mock_notification, process_step_factory, user_step_factory):
+        step = user_step_factory()
+        process_step = process_step_factory(step=step)
+        assignee_list = [UserFactory()]
+        step.notify_assignees(assignee_list, process_step)
+        assert mock_notification.call_args.kwargs == {
+            "code": "workflow.userstep.notify_next_step",
+            "title": "Workflow Step Awaiting Your Decision",
+            "body": "You were assigned to a workflow step. Please select the next step.",
+            "user": assignee_list[0],
+            "endpoint": reverse(f"{process_step.get_endpoint_basename()}-detail", args=[process_step.id]),
+        }
+
+    @patch("wbcore.contrib.workflow.models.step.send_notification")
+    def test_notify_assignee_error(self, mock_notification, process_step_factory, user_step_factory):
+        step = user_step_factory()
+        process_step = process_step_factory(step=step)
+        assignee_list = [UserFactory()]
+        error_message = "Test error"
+        step.notify_assignees(assignee_list, process_step, error_message)
+        assert mock_notification.call_args.kwargs == {
+            "code": "workflow.userstep.notify_failed_step",
+            "title": "Assigned Workflow Step Failed",
+            "body": f"A workflow step you were assigned to just failed with the error message '{error_message}'. Please take appropriate action.",
+            "user": assignee_list[0],
+            "endpoint": reverse(f"{process_step.get_endpoint_basename()}-detail", args=[process_step.id]),
+        }
+
+    @patch("wbcore.contrib.workflow.models.step.send_notification")
+    def test_notify_assignee_list(self, mock_notification, process_step_factory, user_step_factory):
+        step = user_step_factory()
+        process_step = process_step_factory(step=step)
+        assignee_list = UserFactory.create_batch(3)
+        step.notify_assignees(assignee_list, process_step)
+        assert mock_notification.call_count == 3
+
+    @patch("wbcore.contrib.workflow.models.step.send_notification")
+    def test_notify_assignee_inactive_user(self, mock_notification, process_step_factory, user_step_factory):
+        step = user_step_factory()
+        process_step = process_step_factory(step=step)
+        assignee_list = UserFactory.create_batch(3)
+        inactive_user = UserFactory(is_active=False)
+        assignee_list.append(inactive_user)
+        step.notify_assignees(assignee_list, process_step)
+        assert mock_notification.call_count == 3
+        for call in mock_notification.call_args_list:
+            assert call[1]["user"] != inactive_user
+
+    @patch("wbcore.contrib.workflow.models.step.send_notification")
+    @patch("wbcore.contrib.workflow.models.step.Step.user_can_see_step")
+    def test_notify_assignee_user_cant_see(
+        self, mock_can_see, mock_notification, process_step_factory, user_step_factory
+    ):
+        step = user_step_factory()
+        process_step = process_step_factory(step=step)
+        assignee_list = [UserFactory()]
+        mock_can_see.return_value = False
+        step.notify_assignees(assignee_list, process_step)
+        assert not mock_notification.called

wbcore/contrib/workflow/tests/test_models/test_condition.py

@@ -0,0 +1,103 @@
+from unittest.mock import patch
+
+import pytest
+from wbcore.contrib.directory.factories import PersonFactory
+from wbcore.contrib.workflow.models import Condition
+
+
+@pytest.mark.django_db
+class TestCondition:
+    def test_errors_satisfied_not_called(self, condition_factory):
+        condition = condition_factory()
+        with pytest.raises(ValueError):
+            condition.errors
+
+    def test_errors(self, condition_factory):
+        condition = condition_factory()
+        with patch.object(condition, "_errors", create=True):
+            assert condition.errors
+
+    def test_satisfied_attribute_error(self, condition_factory):
+        instance = PersonFactory()
+        condition = condition_factory(attribute_name="Test")
+        assert not condition.satisfied(instance)
+        assert len(condition.errors) == 1
+
+    @patch("wbcore.contrib.workflow.models.data.Data.cast_value_from_target_object")
+    def test_satisfied_value_error(self, mock_cast, condition_factory):
+        instance = PersonFactory()
+        condition = condition_factory()
+        mock_cast.side_effect = ValueError
+        assert not condition.satisfied(instance)
+        assert len(condition.errors) == 1
+
+    @patch("wbcore.contrib.workflow.models.data.Data.cast_value_from_target_object")
+    def test_satisfied_eq(self, mock_cast, condition_factory):
+        instance = PersonFactory()
+        condition1 = condition_factory(operator=Condition.Operator.EQ, negate_operator=False)
+        condition2 = condition_factory(operator=Condition.Operator.EQ, negate_operator=True)
+        mock_cast.return_value = instance.first_name
+        assert condition1.satisfied(instance)
+        assert not condition1.errors
+        assert not condition2.satisfied(instance)
+        assert not condition2.errors
+
+    @patch("wbcore.contrib.workflow.models.data.Data.cast_value_from_target_object")
+    def test_satisfied_gt(self, mock_cast, condition_factory):
+        instance = PersonFactory(personality_profile_red=5)
+        condition1 = condition_factory(
+            attribute_name="personality_profile_red", operator=Condition.Operator.GT, negate_operator=False
+        )
+        condition2 = condition_factory(
+            attribute_name="personality_profile_red", operator=Condition.Operator.GT, negate_operator=True
+        )
+        mock_cast.return_value = 3
+        assert condition1.satisfied(instance)
+        assert not condition1.errors
+        assert not condition2.satisfied(instance)
+        assert not condition2.errors
+
+    @patch("wbcore.contrib.workflow.models.data.Data.cast_value_from_target_object")
+    def test_satisfied_gte(self, mock_cast, condition_factory):
+        instance = PersonFactory(personality_profile_red=5)
+        condition1 = condition_factory(
+            attribute_name="personality_profile_red", operator=Condition.Operator.GTE, negate_operator=False
+        )
+        condition2 = condition_factory(
+            attribute_name="personality_profile_red", operator=Condition.Operator.GTE, negate_operator=True
+        )
+        mock_cast.return_value = 5
+        assert condition1.satisfied(instance)
+        assert not condition1.errors
+        assert not condition2.satisfied(instance)
+        assert not condition2.errors
+
+    @patch("wbcore.contrib.workflow.models.data.Data.cast_value_from_target_object")
+    def test_satisfied_lt(self, mock_cast, condition_factory):
+        instance = PersonFactory(personality_profile_red=2)
+        condition1 = condition_factory(
+            attribute_name="personality_profile_red", operator=Condition.Operator.LT, negate_operator=False
+        )
+        condition2 = condition_factory(
+            attribute_name="personality_profile_red", operator=Condition.Operator.LT, negate_operator=True
+        )
+        mock_cast.return_value = 5
+        assert condition1.satisfied(instance)
+        assert not condition1.errors
+        assert not condition2.satisfied(instance)
+        assert not condition2.errors
+
+    @patch("wbcore.contrib.workflow.models.data.Data.cast_value_from_target_object")
+    def test_satisfied_lte(self, mock_cast, condition_factory):
+        instance = PersonFactory(personality_profile_red=2)
+        condition1 = condition_factory(
+            attribute_name="personality_profile_red", operator=Condition.Operator.LTE, negate_operator=False
+        )
+        condition2 = condition_factory(
+            attribute_name="personality_profile_red", operator=Condition.Operator.LTE, negate_operator=True
+        )
+        mock_cast.return_value = 2
+        assert condition1.satisfied(instance)
+        assert not condition1.errors
+        assert not condition2.satisfied(instance)
+        assert not condition2.errors

wbcore/contrib/workflow/tests/test_models/test_data.py

@@ -0,0 +1,134 @@
+from datetime import date, datetime
+from unittest.mock import patch
+
+import pytest
+from wbcore.contrib.workflow.models import Data
+
+
+@pytest.mark.django_db
+class TestData:
+    @pytest.mark.parametrize(
+        ("type", "field_name"),
+        [
+            (Data.DataType.CHAR, "CharField"),
+            (Data.DataType.BOOL, "BooleanField"),
+            (Data.DataType.DATE, "DateField"),
+            (Data.DataType.DATETIME, "DateTimeField"),
+            (Data.DataType.INT, "IntegerField"),
+        ],
+    )
+    @patch("wbcore.contrib.workflow.models.data.Data.cast_value_to_datatype")
+    def test_get_serializer_field(self, mock_cast, data_factory, type, field_name):
+        data = data_factory(help_text=None, data_type=type)
+        field = data.get_serializer_field()
+        assert field.__class__.__name__ == field_name
+        assert field.label == data.label
+        assert field.required == data.required
+        assert "default" not in field._kwargs
+        assert "help_text" not in field._kwargs
+        assert not mock_cast.called
+
+    @patch("wbcore.contrib.workflow.models.data.Data.cast_value_to_datatype")
+    def test_get_serializer_field_help_text(self, mock_cast, data_factory):
+        data = data_factory()
+        field = data.get_serializer_field()
+        assert field.label == data.label
+        assert field.required == data.required
+        assert "default" not in field._kwargs
+        assert field.help_text == data.help_text
+        assert not mock_cast.called
+
+    @patch("wbcore.contrib.workflow.models.data.Data.cast_value_to_datatype")
+    def test_get_serializer_field_default(self, mock_cast, data_factory):
+        data_type = Data.DataType.INT
+        default_value = "50"
+        casted_default_value = 50
+        data = data_factory(default=default_value, data_type=data_type)
+        mock_cast.return_value = casted_default_value
+        field = data.get_serializer_field()
+        assert mock_cast.call_args.args == (data_type, default_value)
+        assert field.label == data.label
+        assert field.required == data.required
+        assert field.default == casted_default_value
+        assert field.help_text == data.help_text
+
+    @pytest.mark.parametrize(
+        ("data_type", "value", "expected"),
+        [
+            (Data.DataType.BOOL, "True", True),
+            (Data.DataType.BOOL, "true", True),
+            (Data.DataType.BOOL, "False", False),
+            (Data.DataType.BOOL, "false", False),
+            (Data.DataType.DATE, "12.07.1054", date(1054, 7, 12)),
+            (Data.DataType.DATETIME, "12.07.1054 13:47:09", datetime(1054, 7, 12, 13, 47, 9)),
+            (Data.DataType.CHAR, "123456", "123456"),
+            (Data.DataType.INT, "123456", 123456),
+        ],
+    )
+    def test_cast_value_to_datatype(self, data_type, value, expected):
+        assert Data.cast_value_to_datatype(data_type, value) == expected
+
+    @pytest.mark.parametrize(
+        ("data_type", "value"),
+        [
+            (Data.DataType.BOOL, "Test"),
+            (Data.DataType.BOOL, "1"),
+            (Data.DataType.BOOL, "0"),
+            (Data.DataType.DATE, "07/12/1054"),
+            (Data.DataType.DATETIME, "07/12/1054 13:47:09"),
+            (Data.DataType.INT, "Test"),
+        ],
+    )
+    def test_cast_value_to_datatype_error(self, data_type, value):
+        with pytest.raises(ValueError):
+            Data.cast_value_to_datatype(data_type, value)
+
+    @pytest.mark.parametrize(
+        ("target", "data_type"),
+        [
+            (datetime(2003, 8, 28, 7, 18, 4), Data.DataType.DATETIME),
+            (date(2003, 8, 28), Data.DataType.DATE),
+            (True, Data.DataType.BOOL),
+            (False, Data.DataType.BOOL),
+            (69, Data.DataType.INT),
+            ("Test", Data.DataType.CHAR),
+        ],
+    )
+    @patch("wbcore.contrib.workflow.models.data.Data.cast_value_to_datatype")
+    def test_cast_value_from_target_object(self, mock_cast, target, data_type):
+        Data.cast_value_from_target_object(target, "Test")
+        assert mock_cast.call_args.args == (data_type, "Test")
+
+    @pytest.mark.parametrize(
+        "target",
+        [None, Data, str, {}, []],
+    )
+    def test_cast_value_from_target_object_error(self, target):
+        with pytest.raises(ValueError):
+            Data.cast_value_from_target_object(target, "Test")
+
+    @pytest.mark.parametrize(
+        ("data_object", "data_type", "expected"),
+        [
+            (datetime(2003, 8, 28, 7, 18, 4), Data.DataType.DATETIME, "28.08.2003 07:18:04"),
+            (date(2003, 8, 28), Data.DataType.DATE, "28.08.2003"),
+            (True, Data.DataType.BOOL, "True"),
+            (False, Data.DataType.BOOL, "False"),
+            (69, Data.DataType.INT, "69"),
+            ("Test", Data.DataType.CHAR, "Test"),
+        ],
+    )
+    def test_cast_datatype_to_string(self, data_type, data_object, expected):
+        assert Data.cast_datatype_to_string(data_type, data_object) == expected
+
+    @pytest.mark.parametrize(
+        ("data_object", "data_type"),
+        [
+            (69, Data.DataType.DATETIME),
+            ("Test", Data.DataType.DATE),
+            (datetime(2003, 8, 28, 7, 18, 4), Data.DataType.BOOL),
+        ],
+    )
+    def test_cast_datatype_to_string_error(self, data_type, data_object):
+        with pytest.raises(ValueError):
+            Data.cast_datatype_to_string(data_type, data_object)

wbcore/contrib/workflow/tests/test_models/test_process.py

@@ -0,0 +1,98 @@
+from unittest.mock import patch
+
+import pytest
+from wbcore.contrib.authentication.factories import GroupFactory, UserFactory
+from wbcore.contrib.directory.factories import PersonFactory
+from wbcore.contrib.workflow.factories import UserStepFactory
+from wbcore.contrib.workflow.models import Process, ProcessStep
+
+
+@pytest.mark.django_db
+class TestProcess:
+    @patch("wbcore.contrib.workflow.models.process.ProcessStep.get_all_assignees")
+    @patch("wbcore.contrib.workflow.models.step.UserStep.notify_assignees")
+    def test_set_failed(
+        self,
+        mock_notify,
+        mock_assignees,
+        process_step_factory,
+        process_factory,
+        random_child_step_factory,
+        user_step_factory,
+    ):
+        step = random_child_step_factory(exclude_factories=[UserStepFactory])
+        user_step_no_notify = user_step_factory(notify_user=False)
+        user_step_notify = user_step_factory(notify_user=True)
+        process = process_factory(state=Process.ProcessState.ACTIVE)
+        process_step1 = process_step_factory(
+            state=ProcessStep.StepState.ACTIVE, process=process, step=step, error_message=None
+        )
+        process_step2 = process_step_factory(
+            state=ProcessStep.StepState.WAITING, process=process, step=step, error_message=None
+        )
+        process_step3 = process_step_factory(
+            state=ProcessStep.StepState.CANCELED, process=process, step=step, error_message=None
+        )
+        process_step4 = process_step_factory(
+            state=ProcessStep.StepState.FINISHED, process=process, step=step, error_message=None
+        )
+        process_step5 = process_step_factory(state=ProcessStep.StepState.ACTIVE, step=step, error_message=None)
+        process_step6 = process_step_factory(
+            state=ProcessStep.StepState.ACTIVE, process=process, step=user_step_no_notify, error_message=None
+        )
+        process_step7 = process_step_factory(
+            state=ProcessStep.StepState.ACTIVE, process=process, step=user_step_notify, error_message=None
+        )
+        user = UserFactory()
+        mock_assignees.return_value = [user]
+        process.set_failed()
+        assert mock_notify.call_count == 1
+        assert mock_notify.call_args.args[0] == [user]
+        assert str(mock_notify.call_args.args[1].pk) == process_step7.pk
+        assert mock_assignees.call_count == 1
+        for process_step in ProcessStep.objects.filter(
+            id__in=[process_step1.pk, process_step2.pk, process_step6.pk, process_step7.pk]
+        ):
+            assert process_step.state == ProcessStep.StepState.FAILED
+            assert process_step.error_message
+        for process_step in ProcessStep.objects.filter(id__in=[process_step3.pk, process_step4.pk, process_step5.pk]):
+            assert process_step.state != ProcessStep.StepState.FAILED
+            assert process_step.error_message is None
+        assert Process.objects.get(id=process.pk).state == Process.ProcessState.FAILED
+
+
+@pytest.mark.django_db
+class TestProcessStep:
+    def test_get_instance(self, process_step_factory):
+        attached_instance = PersonFactory()
+        process_step = process_step_factory(process__instance=attached_instance)
+        assert process_step.get_instance() == attached_instance
+
+    def test_get_instance_no_attached(self, process_step_factory):
+        process_step = process_step_factory(process__instance=None, process__instance_id=None)
+        assert process_step.get_instance() is None
+
+    def test_get_all_assignees_assignee(self, process_step_factory):
+        user = UserFactory()
+        group = GroupFactory()
+        process_step = process_step_factory(assignee=user, group=group)
+        assert process_step.get_all_assignees() == [user]
+
+    def test_get_all_assignees_group(self, process_step_factory):
+        group = GroupFactory()
+        user1 = UserFactory(groups=[group])
+        user2 = UserFactory(groups=[group])
+        UserFactory()
+        process_step = process_step_factory(group=group, assignee=None)
+        assert set(process_step.get_all_assignees()) == {user1, user2}
+
+    def test_get_all_assignees_empty_group(self, process_step_factory):
+        group = GroupFactory()
+        process_step = process_step_factory(group=group, assignee=None)
+        assert process_step.get_all_assignees() == []
+
+    def test_get_all_assignees_none(self, process_step_factory):
+        group = GroupFactory()
+        UserFactory(groups=[group])
+        process_step = process_step_factory(group=None, assignee=None)
+        assert process_step.get_all_assignees() == []