Fix cache for multiple instance of ishtar - Database changes for managing modules via profile

1 files changed, 80 insertions, 46 deletions

diff --git a/ishtar_common/tests.py b/ishtar_common/tests.py
index 621b05242..4e800b0d5 100644
--- a/ishtar_common/tests.py
+++ b/ishtar_common/tests.py
@@ -17,10 +17,6 @@
 
 # See the file COPYING for details.
 
-import tempfile, datetime
-from zipfile import ZipFile, ZIP_DEFLATED
-
-from django.conf import settings
 from django.contrib.auth.models import User
 from django.contrib.contenttypes.models import ContentType
 from django.template.defaultfilters import slugify
@@ -29,6 +25,10 @@ from django.test import TestCase
 from ishtar_common import models
 
 """
+from django.conf import settings
+import tempfile, datetime
+from zipfile import ZipFile, ZIP_DEFLATED
+
 from oook_replace.oook_replace import oook_replace
 
 class OOOGenerationTest(TestCase):
@@ -53,34 +53,36 @@ class OOOGenerationTest(TestCase):
 class MergeTest(TestCase):
     def setUp(self):
         self.user, created = User.objects.get_or_create(username='username')
-        self.organisation_types = models.OrganizationType.create_default_for_test()
+        self.organisation_types = \
+            models.OrganizationType.create_default_for_test()
 
         self.person_types = [models.PersonType.objects.create(label='Admin'),
                              models.PersonType.objects.create(label='User')]
         self.author_types = [models.AuthorType.objects.create(label='1'),
-                             models.AuthorType.objects.create(label='2'),]
+                             models.AuthorType.objects.create(label='2')]
 
         self.company_1 = models.Organization.objects.create(
-                    history_modifier=self.user, name='Franquin Comp.',
-                    organization_type=self.organisation_types[0])
-        self.person_1 = models.Person.objects.create(name='Boule',
-                surname=' ',
-                history_modifier=self.user, attached_to=self.company_1)
+            history_modifier=self.user, name='Franquin Comp.',
+            organization_type=self.organisation_types[0])
+        self.person_1 = models.Person.objects.create(
+            name='Boule', surname=' ', history_modifier=self.user,
+            attached_to=self.company_1)
         self.person_1.person_types.add(self.person_types[0])
-        self.author_1_pk = models.Author.objects.create(person=self.person_1,
-                                            author_type=self.author_types[0]).pk
+        self.author_1_pk = models.Author.objects.create(
+            person=self.person_1, author_type=self.author_types[0]).pk
 
         self.company_2 = models.Organization.objects.create(
-                    history_modifier=self.user, name='Goscinny Corp.',
-                    organization_type=self.organisation_types[1])
-        self.person_2 = models.Person.objects.create(name='Bill',
-                history_modifier=self.user, surname='Peyo', title='Mr',
-                attached_to=self.company_2)
+            history_modifier=self.user, name='Goscinny Corp.',
+            organization_type=self.organisation_types[1])
+        self.person_2 = models.Person.objects.create(
+            name='Bill', history_modifier=self.user, surname='Peyo',
+            title='Mr', attached_to=self.company_2)
         self.person_2.person_types.add(self.person_types[1])
-        self.author_2_pk = models.Author.objects.create(person=self.person_2,
-                                            author_type=self.author_types[1]).pk
-        self.person_3 = models.Person.objects.create(name='George',
-                history_modifier=self.user, attached_to=self.company_1)
+        self.author_2_pk = models.Author.objects.create(
+            person=self.person_2, author_type=self.author_types[1]).pk
+        self.person_3 = models.Person.objects.create(
+            name='George', history_modifier=self.user,
+            attached_to=self.company_1)
 
     def testPersonMerge(self):
         self.person_1.merge(self.person_2)
@@ -93,9 +95,11 @@ class MergeTest(TestCase):
         # preserve existing foreign key
         self.assertEqual(self.person_1.attached_to, self.company_1)
         # preserve existing many to many
-        self.assertTrue(self.person_types[0] in self.person_1.person_types.all())
+        self.assertTrue(self.person_types[0]
+                        in self.person_1.person_types.all())
         # add new many to many
-        self.assertTrue(self.person_types[1] in self.person_1.person_types.all())
+        self.assertTrue(self.person_types[1]
+                        in self.person_1.person_types.all())
         # update reverse foreign key association and dont break the existing
         self.assertEqual(models.Author.objects.get(pk=self.author_1_pk).person,
                          self.person_1)
@@ -104,32 +108,37 @@ class MergeTest(TestCase):
 
         self.person_3.merge(self.person_1)
         # manage well empty many to many fields
-        self.assertTrue(self.person_types[1] in self.person_3.person_types.all())
+        self.assertTrue(self.person_types[1]
+                        in self.person_3.person_types.all())
+
 
 class ImportKeyTest(TestCase):
     def testKeys(self):
-        content_type = ContentType.objects.get_for_model(models.OrganizationType)
+        content_type = ContentType.objects.get_for_model(
+            models.OrganizationType)
 
         # creation
         label = u"Ploufé"
         ot = models.OrganizationType.objects.create(label=label)
-        self.assertEqual(models.ItemKey.objects.filter(object_id=ot.pk,
-                                    key=slugify(label),
-                                    content_type=content_type).count(), 1)
+        self.assertEqual(models.ItemKey.objects.filter(
+                         object_id=ot.pk, key=slugify(label),
+                         content_type=content_type).count(), 1)
         label_2 = u"Plif"
         ot_2 = models.OrganizationType.objects.create(label=label_2)
-        self.assertEqual(models.ItemKey.objects.filter(object_id=ot_2.pk,
-                                    key=slugify(label_2),
-                                    content_type=content_type).count(), 1)
+        self.assertEqual(models.ItemKey.objects.filter(
+                         object_id=ot_2.pk, key=slugify(label_2),
+                         content_type=content_type).count(), 1)
 
         # replace key
         ot_2.add_key(slugify(label), force=True)
         # one key point to only one item
-        self.assertEqual(models.ItemKey.objects.filter(key=slugify(label),
-                                    content_type=content_type).count(), 1)
+        self.assertEqual(models.ItemKey.objects.filter(
+                         key=slugify(label),
+                         content_type=content_type).count(), 1)
         # this key point to the right item
-        self.assertEqual(models.ItemKey.objects.filter(object_id=ot_2.pk,
-                key=slugify(label), content_type=content_type).count(), 1)
+        self.assertEqual(models.ItemKey.objects.filter(
+                         object_id=ot_2.pk, key=slugify(label),
+                         content_type=content_type).count(), 1)
 
         # modification
         label_3 = "Yop"
@@ -137,14 +146,39 @@ class ImportKeyTest(TestCase):
         ot_2.txt_idx = slugify(label_3)
         ot_2.save()
         # old label not referenced anymore
-        self.assertEqual(models.ItemKey.objects.filter(object_id=ot_2.pk,
-                key=slugify(label_2), content_type=content_type).count(), 0)
-        # forced key association is always here
-        self.assertEqual(models.ItemKey.objects.filter(object_id=ot_2.pk,
-                key=slugify(label), content_type=content_type).count(), 1)
+        self.assertEqual(models.ItemKey.objects.filter(
+                         object_id=ot_2.pk, key=slugify(label_2),
+                         content_type=content_type).count(), 0)
+        # # forced key association is always here
         # new key is here
-        self.assertEqual(models.ItemKey.objects.filter(object_id=ot_2.pk,
-                key=slugify(label_3), content_type=content_type).count(), 1)
-
-
-
+        self.assertEqual(models.ItemKey.objects.filter(
+                         object_id=ot_2.pk, key=slugify(label),
+                         content_type=content_type).count(), 1)
+        self.assertEqual(models.ItemKey.objects.filter(
+                         object_id=ot_2.pk, key=slugify(label_3),
+                         content_type=content_type).count(), 1)
+
+
+class IshtarSiteProfileTest(TestCase):
+    def testRelevance(self):
+        profile = models.IshtarSiteProfile.objects.create(
+            label="Test profile", slug='test-profile')
+        profile2 = models.IshtarSiteProfile.objects.create(
+            label="Test profile 2", slug='test-profile-2')
+        # when no profile is the current, activate by default the first created
+        self.assertTrue(profile.active and not profile2.active)
+        profile2.active = True
+        profile2 = profile2.save()
+        profile = models.IshtarSiteProfile.objects.get(slug='test-profile')
+        # only one profile active at a time
+        self.assertTrue(profile2.active and not profile.active)
+        # activate find active automatically context records
+        self.assertFalse(profile.context_record)
+        profile.find = True
+        profile = profile.save()
+        self.assertTrue(profile.context_record)
+        # activate warehouse active automatically context records and finds
+        self.assertFalse(profile2.context_record or profile2.find)
+        profile2.warehouse = True
+        profile2 = profile2.save()
+        self.assertTrue(profile2.context_record and profile2.find)