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_decision_step.py

@@ -0,0 +1,79 @@
+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 TestDecisionStep:
+    def test_get_first_valid_transition(
+        self, process_step_factory, decision_step_factory, transition_factory, condition_factory
+    ):
+        attached_instance = PersonFactory()
+        step = decision_step_factory()
+        process_step = process_step_factory(process__instance=attached_instance, step=step)
+        valid_transition1 = transition_factory(from_step=step)
+        valid_transition2 = transition_factory(from_step=step)
+        invalid_transition = transition_factory(from_step=step)
+        transition_factory()
+        condition_factory(
+            transition=invalid_transition,
+            attribute_name="first_name",
+            expected_value=attached_instance.first_name,
+            operator=Condition.Operator.EQ,
+            negate_operator=True,
+        )
+        assert step.get_first_valid_transition(process_step) in [valid_transition1, valid_transition2]
+
+    def test_get_first_valid_transition_no_transitions(
+        self, process_step_factory, decision_step_factory, transition_factory, condition_factory
+    ):
+        attached_instance = PersonFactory()
+        step = decision_step_factory()
+        process_step = process_step_factory(process__instance=attached_instance, step=step)
+        invalid_transition = transition_factory(from_step=step)
+        transition_factory()
+        condition_factory(
+            transition=invalid_transition,
+            attribute_name="first_name",
+            expected_value=attached_instance.first_name,
+            operator=Condition.Operator.EQ,
+            negate_operator=True,
+        )
+        assert step.get_first_valid_transition(process_step) is None
+
+    @patch("wbcore.contrib.workflow.models.step.DecisionStep.get_first_valid_transition")
+    @patch("wbcore.contrib.workflow.models.step.Step.start_next_step")
+    def test_run(
+        self,
+        mock_next,
+        mock_transition,
+        process_step_factory,
+        transition_factory,
+        decision_step_factory,
+    ):
+        transition = transition_factory()
+        mock_transition.return_value = transition
+        step = decision_step_factory()
+        process_step = process_step_factory(step=step)
+        step.run(process_step)
+        assert mock_next.call_args.args == (process_step, transition)
+
+    @patch("wbcore.contrib.workflow.models.step.Step.set_failed")
+    @patch("wbcore.contrib.workflow.models.step.activate_step.delay")
+    @patch("wbcore.contrib.workflow.models.step.DecisionStep.get_first_valid_transition")
+    def test_run_failed(
+        self,
+        mock_transition,
+        mock_activate,
+        mock_failed,
+        process_step_factory,
+        decision_step_factory,
+    ):
+        mock_transition.return_value = None
+        step = decision_step_factory()
+        process_step = process_step_factory(step=step)
+        step.run(process_step)
+        assert mock_failed.call_args.args[0] == process_step
+        assert not mock_activate.called

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

@@ -0,0 +1,45 @@
+from unittest.mock import patch
+
+import pytest
+from django.template import TemplateSyntaxError
+from wbcore.contrib.directory.factories import EmailContactFactory
+
+
+@pytest.mark.django_db
+class TestEmailStep:
+    @patch("wbcore.contrib.workflow.models.step.Step.execute_single_next_step")
+    @patch("django.core.mail.EmailMultiAlternatives.__init__")
+    @patch("django.core.mail.EmailMultiAlternatives.send")
+    @patch("django.core.mail.EmailMultiAlternatives.attach_alternative")
+    def test_run(self, mock_attach, mock_send, mock_init, mock_execute, process_step_factory, email_step_factory):
+        step = email_step_factory(to=[EmailContactFactory()], cc=[EmailContactFactory(), EmailContactFactory()])
+        process_step = process_step_factory(step=step)
+        mock_init.return_value = None
+        step.run(process_step)
+        assert mock_init.call_args.args[0] == step.subject
+        assert mock_init.call_args.kwargs == {
+            "to": list(step.to.values_list("address", flat=True)),
+            "cc": list(step.cc.values_list("address", flat=True)),
+            "bcc": [],
+        }
+        assert mock_attach.called
+        assert mock_send.called
+        assert mock_execute.call_args.args == (process_step,)
+
+    @patch("wbcore.contrib.workflow.models.step.Step.set_failed")
+    @patch("django.template.Template.render")
+    @patch("wbcore.contrib.workflow.models.step.Step.execute_single_next_step")
+    @patch("django.core.mail.EmailMultiAlternatives.send")
+    def test_run_failed(
+        self, mock_send, mock_execute, mock_render, mock_set_failed, process_step_factory, email_step_factory
+    ):
+        step = email_step_factory(
+            to=[EmailContactFactory()],
+            cc=[EmailContactFactory(), EmailContactFactory()],
+        )
+        process_step = process_step_factory(step=step)
+        mock_render.side_effect = TemplateSyntaxError
+        step.run(process_step)
+        assert not mock_send.called
+        assert not mock_execute.called
+        assert mock_set_failed.call_args.args[0] == process_step

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

@@ -0,0 +1,105 @@
+from unittest.mock import patch
+
+import pytest
+from wbcore.contrib.directory.models import Person
+from wbcore.contrib.workflow.models import Process, ProcessStep
+from wbcore.contrib.workflow.sites import workflow_site
+
+
+@pytest.mark.django_db
+class TestFinishStep:
+    @pytest.mark.parametrize(
+        "finished_state",
+        [ProcessStep.StepState.FAILED, ProcessStep.StepState.CANCELED, ProcessStep.StepState.FINISHED],
+    )
+    @pytest.mark.parametrize("unfinished_state", [ProcessStep.StepState.ACTIVE, ProcessStep.StepState.WAITING])
+    @patch("wbcore.contrib.workflow.models.step.Step.set_finished")
+    def test_run(self, mock_finish, process_step_factory, finish_step_factory, unfinished_state, finished_state):
+        step = finish_step_factory()
+        process_step = process_step_factory(step=step)
+        process_step_factory(process=process_step.process, state=finished_state)
+        process_step_factory(step=step, state=unfinished_state)
+        step.run(process_step)
+        assert mock_finish.call_args.args == (process_step,)
+
+    @pytest.mark.parametrize("unfinished_state", [ProcessStep.StepState.ACTIVE, ProcessStep.StepState.WAITING])
+    @patch("wbcore.contrib.workflow.models.step.Step.set_failed")
+    def test_run_failed(self, mock_failed, process_step_factory, finish_step_factory, unfinished_state):
+        step = finish_step_factory()
+        process_step = process_step_factory(step=step)
+        process_step_factory(process=process_step.process, state=unfinished_state)
+        step.run(process_step)
+        assert mock_failed.call_args.args[0] == process_step
+
+    @pytest.mark.parametrize(
+        "unfinished_state",
+        [
+            ProcessStep.StepState.ACTIVE,
+            ProcessStep.StepState.WAITING,
+            ProcessStep.StepState.CANCELED,
+            ProcessStep.StepState.FAILED,
+        ],
+    )
+    @patch("wbcore.contrib.workflow.models.step.Step.finish")
+    def test_finish_not_finished(self, mock_finish, unfinished_state, process_step_factory, finish_step_factory):
+        step = finish_step_factory(write_preserved_instance=True)
+        process_step = process_step_factory(
+            process__preserved_instance={"first_name": "Test"},
+            step=step,
+            process__finished=None,
+            state=unfinished_state,
+            process__state=Process.ProcessState.ACTIVE,
+        )
+        step.finish(process_step)
+        assert mock_finish.call_args.args == (process_step,)
+        assert process_step.process.finished is None
+        assert process_step.process.instance.first_name != "Test"
+        assert process_step.process.state == Process.ProcessState.ACTIVE
+
+    @patch("wbcore.contrib.workflow.models.step.Step.finish")
+    def test_finish_write_preserved_instance(self, mock_finish, process_step_factory, finish_step_factory):
+        step = finish_step_factory(write_preserved_instance=True, workflow__preserve_instance=True)
+        process_step = process_step_factory(
+            step=step,
+            process__finished=None,
+            state=ProcessStep.StepState.FINISHED,
+            process__workflow=step.workflow,
+        )
+        old_name = process_step.process.instance.first_name
+        workflow_site.registered_model_classes_serializer_map[
+            Person
+        ] = "wbcore.contrib.directory.serializers.PersonModelSerializer"
+        step.finish(process_step)
+        assert mock_finish.call_args.args == (process_step,)
+        assert process_step.process.finished is not None
+        assert process_step.process.instance.first_name != old_name
+        assert process_step.process.instance.first_name == process_step.process.preserved_instance["first_name"]
+        assert process_step.process.state == Process.ProcessState.FINISHED
+
+    @patch("wbcore.contrib.workflow.models.step.Step.finish")
+    def test_finish_do_not_write(self, mock_finish, process_step_factory, finish_step_factory):
+        step = finish_step_factory(write_preserved_instance=False, workflow__preserve_instance=True)
+        process_step = process_step_factory(
+            step=step,
+            process__finished=None,
+            state=ProcessStep.StepState.FINISHED,
+        )
+        old_name = process_step.process.instance.first_name
+        step.finish(process_step)
+        assert mock_finish.call_args.args == (process_step,)
+        assert process_step.process.finished is not None
+        assert process_step.process.instance.first_name == old_name
+        assert process_step.process.state == Process.ProcessState.FINISHED
+
+    @patch("wbcore.contrib.workflow.models.step.Step.finish")
+    def test_finish_no_preserved_instance(self, mock_finish, process_step_factory, finish_step_factory):
+        step = finish_step_factory(write_preserved_instance=True, workflow__preserve_instance=True)
+        process_step = process_step_factory(
+            step=step, process__finished=None, state=ProcessStep.StepState.FINISHED, process__preserved_instance=None
+        )
+        old_name = process_step.process.instance.first_name
+        step.finish(process_step)
+        assert mock_finish.call_args.args == (process_step,)
+        assert process_step.process.finished is not None
+        assert process_step.process.instance.first_name == old_name
+        assert process_step.process.state == Process.ProcessState.FINISHED

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

@@ -0,0 +1,127 @@
+from unittest.mock import patch
+
+import pytest
+from wbcore.contrib.workflow.models import ProcessStep
+
+
+@pytest.mark.django_db
+class TestJoinStep:
+    @patch("wbcore.contrib.workflow.models.step.Step.set_canceled")
+    def test_cancel_if_leading_to_self_transition_found(
+        self, mock_canceled, random_child_step_factory, join_step_factory, process_step_factory, transition_factory
+    ):
+        self_step = join_step_factory()
+        step = random_child_step_factory()
+        process_step = process_step_factory(step=step)
+        transition1 = transition_factory(from_step=step)
+        transition_factory(from_step=step)
+        transition_factory(from_step=transition1.to_step, to_step=self_step)
+        transition_factory()
+        self_step.cancel_if_leading_to_self(step, process_step)
+        assert mock_canceled.call_args.args == (process_step,)
+
+    @patch("wbcore.contrib.workflow.models.step.Step.set_canceled")
+    def test_cancel_if_leading_to_self_no_transition_found(
+        self,
+        mock_canceled,
+        random_child_step_factory,
+        join_step_factory,
+        process_step_factory,
+        transition_factory,
+    ):
+        self_step = join_step_factory()
+        step = random_child_step_factory()
+        process_step = process_step_factory(step=step)
+        transition1 = transition_factory(from_step=step)
+        transition_factory(from_step=step)
+        transition_factory(from_step=transition1.to_step)
+        transition_factory()
+        self_step.cancel_if_leading_to_self(step, process_step)
+        assert not mock_canceled.called
+
+    @patch("wbcore.contrib.workflow.models.step.JoinStep.cancel_if_leading_to_self")
+    @patch("wbcore.contrib.workflow.models.step.Step.execute_single_next_step")
+    def test_run_wait_for_all_transition_without_process_step(
+        self, mock_execute, mock_cancel, process_step_factory, join_step_factory, transition_factory
+    ):
+        step = join_step_factory(wait_for_all=True)
+        transition_factory(to_step=step)
+        process_step = process_step_factory(step=step, state=ProcessStep.StepState.ACTIVE)
+        step.run(process_step)
+        assert process_step.state == ProcessStep.StepState.WAITING
+        assert not mock_execute.called
+        assert not mock_cancel.called
+
+    @patch("wbcore.contrib.workflow.models.step.JoinStep.cancel_if_leading_to_self")
+    @patch("wbcore.contrib.workflow.models.step.Step.execute_single_next_step")
+    def test_run_wait_for_all_transition_with_process_step(
+        self, mock_execute, mock_cancel, process_step_factory, join_step_factory, transition_factory
+    ):
+        step = join_step_factory(wait_for_all=True)
+        transition = transition_factory(to_step=step)
+        process_step = process_step_factory(step=step, state=ProcessStep.StepState.ACTIVE)
+        process_step_factory(
+            step=transition.from_step, process=process_step.process, state=ProcessStep.StepState.ACTIVE
+        )
+        step.run(process_step)
+        assert process_step.state == ProcessStep.StepState.WAITING
+        assert not mock_execute.called
+        assert not mock_cancel.called
+
+    @pytest.mark.parametrize("state", [ProcessStep.StepState.FINISHED, ProcessStep.StepState.CANCELED])
+    @patch("wbcore.contrib.workflow.models.step.JoinStep.cancel_if_leading_to_self")
+    @patch("wbcore.contrib.workflow.models.step.Step.execute_single_next_step")
+    def test_run_wait_for_all_transition_with_finished_canceled_process_step(
+        self, mock_execute, mock_cancel, process_step_factory, join_step_factory, transition_factory, state
+    ):
+        step = join_step_factory(wait_for_all=True)
+        transition = transition_factory(to_step=step)
+        transition_factory(from_step=step)
+        process_step = process_step_factory(step=step, state=ProcessStep.StepState.ACTIVE)
+        process_step_factory(step=transition.from_step, process=process_step.process, state=state)
+        step.run(process_step)
+        assert process_step.state == ProcessStep.StepState.WAITING
+        assert mock_execute.call_args.args == (process_step,)
+        assert not mock_cancel.called
+
+    @patch("wbcore.contrib.workflow.models.step.JoinStep.cancel_if_leading_to_self")
+    @patch("wbcore.contrib.workflow.models.step.Step.execute_single_next_step")
+    def test_run_wait_for_all_no_transition(
+        self, mock_execute, mock_cancel, process_step_factory, join_step_factory, transition_factory
+    ):
+        step = join_step_factory(wait_for_all=True)
+        transition_factory(from_step=step)
+        process_step = process_step_factory(step=step, state=ProcessStep.StepState.ACTIVE)
+        step.run(process_step)
+        assert process_step.state == ProcessStep.StepState.WAITING
+        assert mock_execute.call_args.args == (process_step,)
+        assert not mock_cancel.called
+
+    @patch("wbcore.contrib.workflow.models.step.JoinStep.cancel_if_leading_to_self")
+    @patch("wbcore.contrib.workflow.models.step.Step.execute_single_next_step")
+    def test_run_do_not_wait(
+        self,
+        mock_execute,
+        mock_cancel,
+        process_step_factory,
+        join_step_factory,
+    ):
+        step = join_step_factory(wait_for_all=False)
+        process_step = process_step_factory(step=step, state=ProcessStep.StepState.ACTIVE)
+        unfinished_process_step1 = process_step_factory(
+            process=process_step.process, state=ProcessStep.StepState.ACTIVE
+        )
+        unfinished_process_step2 = process_step_factory(
+            process=process_step.process, state=ProcessStep.StepState.WAITING
+        )
+        process_step_factory(state=ProcessStep.StepState.ACTIVE)
+        process_step_factory(process=process_step.process, state=ProcessStep.StepState.FINISHED)
+        process_step_factory(process=process_step.process, state=ProcessStep.StepState.CANCELED)
+        process_step_factory(process=process_step.process, state=ProcessStep.StepState.FAILED)
+        step.run(process_step)
+        assert process_step.state == ProcessStep.StepState.WAITING
+        assert mock_execute.call_args.args == (process_step,)
+        assert set(tuple(map(lambda y: str(y.pk), x.args)) for x in mock_cancel.call_args_list) == {
+            (str(unfinished_process_step1.step.pk), unfinished_process_step1.pk),
+            (str(unfinished_process_step2.step.pk), unfinished_process_step2.pk),
+        }

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