Test process_list and process_create

process/tests/common.py

+# coding: utf8
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+from backend.unittest import NamedObjects, PersonFixtureMixin
+import backend.models as bmodels
+import process.models as pmodels
+
+
+class TestProcesses(NamedObjects):
+    def __init__(self, **defaults):
+        super(TestProcesses, self).__init__(pmodels.Process, **defaults)
+
+    def create(self, _name, **kw):
+        self._update_kwargs_with_defaults(_name, kw)
+
+#        if "process" in kw:
+#            kw.setdefault("is_active", kw["process"] not in (const.PROGRESS_DONE, const.PROGRESS_CANCELLED))
+#        else:
+#            kw.setdefault("is_active", True)
+#
+#        if "manager" in kw:
+#            try:
+#                am = kw["manager"].am
+#            except AM.DoesNotExist:
+#                am = AM.objects.create(person=kw["manager"])
+#            kw["manager"] = am
+#
+        self[_name] = o = self._model.objects.create(**kw)
+#        for a in advocates:
+#            o.advocates.add(a)
+        return o
+
+
+class ProcessFixtureMixin(PersonFixtureMixin):
+    @classmethod
+    def get_processes_defaults(cls):
+        """
+        Get default arguments for test processes
+        """
+        return {}
+
+    @classmethod
+    def setUpClass(cls):
+        super(ProcessFixtureMixin, cls).setUpClass()
+        cls.processes = TestProcesses(**cls.get_processes_defaults())
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.processes.delete_all()
+        super(ProcessFixtureMixin, cls).tearDownClass()
+
+    def setUp(self):
+        super(ProcessFixtureMixin, self).setUp()
+        self.processes.refresh();
+
+
+def get_all_process_types():
+    """
+    Generate all valid (source_status, applying_for) pairs for all possible
+    processes.
+    """
+    for src, tgts in bmodels.Process._new_status_table:
+        for tgt in tgts:
+            yield src, tgt
+
+

process/tests/test_process_create.py

+# coding: utf8
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+from django.test import TestCase
+from django.core.urlresolvers import reverse
+from .common import ProcessFixtureMixin
+import process.models as pmodels
+
+
+class TestCreate(ProcessFixtureMixin, TestCase):
+    @classmethod
+    def __add_extra_tests__(cls):
+        def ok(visited, target):
+            cls._add_method(cls._test_success, visited, visited, target)
+            cls._add_method(cls._test_success, "fd", visited, target)
+            cls._add_method(cls._test_success, "dam", visited, target)
+            for visitor in ("pending", "dc", "dc_ga", "dm", "dm_ga", "dd_nu", "dd_u", "dd_e", "dd_r"):
+                if visitor == visited: continue
+                cls._add_method(cls._test_forbidden, visitor, visited, target)
+
+        def no(visited, target):
+            cls._add_method(cls._test_invalid, visited, visited, target)
+            cls._add_method(cls._test_invalid, "fd", visited, target)
+            cls._add_method(cls._test_invalid, "dam", visited, target)
+            for visitor in ("pending", "dc", "dc_ga", "dm", "dm_ga", "dd_nu", "dd_u", "dd_e", "dd_r"):
+                if visitor == visited: continue
+                cls._add_method(cls._test_forbidden, visitor, visited, target)
+
+        ok("dc", "dc_ga")
+        ok("dc", "dm")
+        no("dc", "dm_ga")
+        ok("dc", "dd_u")
+        ok("dc", "dd_nu")
+
+        ok("dc_ga", "dm_ga")
+        no("dc_ga", "dm")
+        ok("dc_ga", "dd_u")
+        ok("dc_ga", "dd_nu")
+
+        ok("dm", "dm_ga")
+        ok("dm", "dd_u")
+        no("dm", "dd_nu")
+
+        ok("dm_ga", "dd_u")
+        no("dm_ga", "dd_nu")
+
+        ok("dd_nu", "dd_u")
+
+        ok("dd_e", "dd_u")
+        ok("dd_e", "dd_nu")
+
+        ok("dd_r", "dd_u")
+        ok("dd_r", "dd_nu")
+
+
+    def _test_success(self, visitor, visited, target):
+        client = self.make_test_client(visitor)
+        response = client.get(reverse("process_create", args=[self.persons[visited].lookup_key]))
+        self.assertEquals(response.status_code, 200)
+        response = client.post(reverse("process_create", args=[self.persons[visited].lookup_key]), data={"applying_for": target})
+        self.assertRedirectMatches(response, r"/process/\d+$")
+        p = pmodels.Process.objects.get(person=self.persons[visited], applying_for=target, closed__isnull=True)
+        self.assertIsNone(p.frozen_by)
+        self.assertIsNone(p.frozen_time)
+        self.assertIsNone(p.approved_by)
+        self.assertIsNone(p.approved_time)
+        self.assertIsNone(p.closed)
+        self.assertEquals(p.fd_comment, "")
+
+    def _test_invalid(self, visitor, visited, target):
+        client = self.make_test_client(visitor)
+        response = client.get(reverse("process_create", args=[self.persons[visited].lookup_key]))
+        self.assertEquals(response.status_code, 200)
+
+        response = client.post(reverse("process_create", args=[self.persons[visited].lookup_key]), data={"applying_for": target})
+        self.assertEquals(response.status_code, 200)
+        self.assertFalse(pmodels.Process.objects.filter(person=self.persons[visited], applying_for=target, closed__isnull=True).exists())
+        self.assertIn("Select a valid choice.", response.context["form"].errors["applying_for"][0])
+
+    def _test_forbidden(self, visitor, visited, target):
+        client = self.make_test_client(visitor)
+        response = client.get(reverse("process_create", args=[self.persons[visited].lookup_key]))
+        self.assertPermissionDenied(response)
+
+        response = client.post(reverse("process_create", args=[self.persons[visited].lookup_key]), data={"applying_for": target})
+        self.assertPermissionDenied(response)
+        self.assertFalse(pmodels.Process.objects.filter(person=self.persons[visited], applying_for=target, closed__isnull=True).exists())

process/tests/test_process_list.py

+# coding: utf8
+from __future__ import print_function
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+from django.test import TestCase
+from django.core.urlresolvers import reverse
+from .common import ProcessFixtureMixin
+
+
+class TestList(ProcessFixtureMixin, TestCase):
+    @classmethod
+    def __add_extra_tests__(cls):
+        # Process list is visible by anyone
+        for visitor in ("pending", "dc", "dc_ga", "dm", "dm_ga", "dd_nu", "dd_u", "dd_e", "dd_r", "fd", "dam", None):
+            cls._add_method(cls._test_success, visitor)
+
+    def _test_success(self, visitor):
+        client = self.make_test_client(visitor)
+        response = client.get(reverse("process_list"))
+        self.assertEquals(response.status_code, 200)
+
+#    def _test_forbidden(self, visitor):
+#        client = self.make_test_client(visitor)
+#        response = client.get(reverse("process_list"))
+#        self.assertPermissionDenied(response)
+