Fix shortcut menu for baskets - add tests for shortcut menu

1 files changed, 261 insertions, 13 deletions

diff --git a/ishtar_common/tests.py b/ishtar_common/tests.py
index 335b20ff6..d3c6eed4b 100644
--- a/ishtar_common/tests.py
+++ b/ishtar_common/tests.py
@@ -17,8 +17,9 @@
 
 # See the file COPYING for details.
 
-from StringIO import StringIO
 from bs4 import BeautifulSoup as Soup
+import datetime
+from StringIO import StringIO
 
 from django.conf import settings
 from django.contrib.auth.models import User
@@ -337,14 +338,26 @@ class MergeTest(TestCase):
 
 class ShortMenuTest(TestCase):
     def setUp(self):
-        from archaeological_operations.models import OperationType
         self.username = 'username666'
         self.password = 'dcbqj7xnjkxnjsknx!@%'
         self.user = User.objects.create_superuser(
             self.username, "nomail@nomail.com", self.password)
         self.other_user = User.objects.create_superuser(
             'John', "nomail@nomail.com", self.password)
-        self.ope_type = OperationType.objects.create()
+        profile = models.get_current_profile()
+        profile.files = True
+        profile.save()
+
+    def _create_ope(self, user=None):
+        if not user:
+            user = self.other_user
+        from archaeological_operations.models import Operation, OperationType
+        ope_type = OperationType.objects.create()
+        return Operation.objects.create(
+            operation_type=ope_type,
+            history_modifier=user,
+            year=2042, operation_code=54
+        )
 
     def testNotConnected(self):
         c = Client()
@@ -356,31 +369,25 @@ class ShortMenuTest(TestCase):
         # no content because the user owns no object
         response = c.get(reverse('shortcut-menu'))
         self.assertFalse("shortcut-menu" in response.content)
-        from archaeological_operations.models import Operation
-        Operation.objects.create(
-            operation_type=self.ope_type,
-            history_modifier=self.user)
+        self._create_ope(user=self.user)
         # content is here
         response = c.get(reverse('shortcut-menu'))
         self.assertTrue("shortcut-menu" in response.content)
 
     def testOperation(self):
-        from archaeological_operations.models import Operation
         c = Client()
         c.login(username=self.username, password=self.password)
-        ope = Operation.objects.create(
-            operation_type=self.ope_type,
-            history_modifier=self.other_user,
-            year=2042, operation_code=54
-        )
+        ope = self._create_ope()
         # not available at first
         response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
         self.assertFalse(str(ope.cached_label) in response.content)
 
         # available because is the creator
         ope.history_creator = self.user
         ope.save()
         response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
         self.assertTrue(str(ope.cached_label) in response.content)
 
         # available because is in charge
@@ -388,6 +395,7 @@ class ShortMenuTest(TestCase):
         ope.in_charge = self.user.ishtaruser.person
         ope.save()
         response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
         self.assertTrue(str(ope.cached_label) in response.content)
 
         # available because is the scientist
@@ -396,8 +404,248 @@ class ShortMenuTest(TestCase):
         ope.scientist = self.user.ishtaruser.person
         ope.save()
         response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
         self.assertTrue(str(ope.cached_label) in response.content)
 
+        # end date is reached - no more available
+        ope.end_date = datetime.date(1900, 1, 1)
+        ope.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(ope.cached_label) in response.content)
+
+    def testFile(self):
+        from archaeological_files.models import File, FileType
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        file_type = FileType.objects.create()
+        fle = File.objects.create(
+            file_type=file_type,
+            history_modifier=self.other_user,
+            year=2043,
+        )
+        # not available at first
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(fle.cached_label) in response.content)
+
+        # available because is the creator
+        fle.history_creator = self.user
+        fle.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(fle.cached_label) in response.content)
+
+        # available because is in charge
+        fle.history_creator = self.other_user
+        fle.in_charge = self.user.ishtaruser.person
+        fle.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(fle.cached_label) in response.content)
+
+        # end date is reached - no more available
+        fle.end_date = datetime.date(1900, 1, 1)
+        fle.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(fle.cached_label) in response.content)
+
+    def _create_cr(self):
+        from archaeological_context_records.models import ContextRecord
+        from archaeological_operations.models import Parcel
+        ope = self._create_ope()
+        town = models.Town.objects.create()
+        parcel = Parcel.objects.create(
+            operation=ope,
+            town=town,
+            section="AA",
+            parcel_number=42
+        )
+        return ContextRecord.objects.create(
+            parcel=parcel,
+            operation=ope,
+            history_modifier=self.other_user,
+        )
+
+    def testContextRecord(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        cr = self._create_cr()
+
+        # not available at first
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(cr.cached_label) in response.content)
+
+        # available because is the creator
+        cr.history_creator = self.user
+        cr.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(cr.cached_label) in response.content)
+
+        # available because is in charge
+        cr.history_creator = self.other_user
+        cr.save()
+        cr.operation.in_charge = self.user.ishtaruser.person
+        cr.operation.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(cr.cached_label) in response.content)
+
+        # available because is the scientist
+        cr.history_creator = self.other_user
+        cr.save()
+        cr.operation.in_charge = None
+        cr.operation.scientist = self.user.ishtaruser.person
+        cr.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(cr.cached_label) in response.content)
+
+    def _create_find(self):
+        from archaeological_finds.models import BaseFind, Find
+        cr = self._create_cr()
+        base_find = BaseFind.objects.create(
+            context_record=cr
+        )
+        find = Find.objects.create(
+            label="Where is my find?"
+        )
+        find.base_finds.add(base_find)
+        return base_find, find
+
+    def testFind(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        base_find, find = self._create_find()
+
+        # not available at first
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(find.cached_label) in response.content)
+
+        # available because is the creator
+        find.history_creator = self.user
+        find.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(find.cached_label) in response.content)
+
+        # available because is in charge
+        find.history_creator = self.other_user
+        find.save()
+        base_find.context_record.operation.in_charge = \
+            self.user.ishtaruser.person
+        base_find.context_record.operation.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(find.cached_label) in response.content)
+
+        # available because is the scientist
+        find.history_creator = self.other_user
+        find.save()
+        base_find.context_record.operation.in_charge = None
+        base_find.context_record.operation.scientist = \
+            self.user.ishtaruser.person
+        base_find.context_record.operation.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(find.cached_label) in response.content)
+
+    def testBasket(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        from archaeological_finds.models import FindBasket
+        basket = FindBasket.objects.create(
+            label="My basket",
+        )
+
+        # not available at first
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(basket.label) in response.content)
+
+        # available because is the owner
+        basket.user = self.user.ishtaruser
+        basket.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(basket.label) in response.content)
+
+    def testTreatmentFile(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        from archaeological_finds.models import TreatmentFile, TreatmentFileType
+        tf = TreatmentFile.objects.create(
+            type=TreatmentFileType.objects.create(),
+            year=2050
+        )
+
+        # not available at first
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(tf.cached_label) in response.content)
+
+        # available because is the creator
+        tf.history_creator = self.user
+        tf.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(tf.cached_label) in response.content)
+
+        # available because is in charge
+        tf.history_creator = self.other_user
+        tf.in_charge = self.user.ishtaruser.person
+        tf.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(tf.cached_label) in response.content)
+
+        # end date is reached - no more available
+        tf.end_date = datetime.date(1900, 1, 1)
+        tf.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(tf.cached_label) in response.content)
+
+    def testTreatment(self):
+        c = Client()
+        c.login(username=self.username, password=self.password)
+        from archaeological_finds.models import Treatment
+        treat = Treatment.objects.create(
+            label="My treatment",
+            year=2052
+        )
+
+        # not available at first
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(treat.cached_label) in response.content)
+
+        # available because is the creator
+        treat.history_creator = self.user
+        treat.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(treat.cached_label) in response.content)
+
+        # available because is in charge
+        treat.history_creator = self.other_user
+        treat.person = self.user.ishtaruser.person
+        treat.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(str(treat.cached_label) in response.content)
+
+        # end date is reached - no more available
+        treat.end_date = datetime.date(1900, 1, 1)
+        treat.save()
+        response = c.get(reverse('shortcut-menu'))
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(str(treat.cached_label) in response.content)
+
 
 class ImportTest(TestCase):
     def testDeleteRelated(self):