Fix

coin/members/models.py

@@ -107,24 +107,18 @@ class Member(CoinLdapSyncModel):
 
         return ldap_cn
 
-    def sync_with_ldap(self, creation):
+    def sync_to_ldap(self, creation):
         """
         Update LDAP data when a member is saved
         """
+
+        assert self.ldap_cn, ('Can\'t sync with LDAP because missing ldap_cn '
+                              'value for the Member : %s' % self)
+
         if not creation:
-            if not self.ldap_cn:
-                # ldap_cn must be set to update a member in LDAP
-                raise Exception(
-                    'Can\'t sync with LDAP because missing ldap_cn value '
-                    'of Member : %s' % self)
-            else:
                 ldap_user = LdapUser.objects.get(pk=self.ldap_cn)
 
         if creation:
-            if not self.ldap_cn:
-                # If no ldap_cn specified for creation, generate one
-                self.ldap_cn = self.get_automatic_ldap_cn()
-
             max_uidNumber = LdapUser.objects.order_by('-uidNumber')[0].uidNumber
 
             ldap_user = LdapUser()
@@ -241,7 +235,7 @@ def define_ldap_cn(sender, instance, **kwargs):
     Lors de la sauvegarde d'un membre. Si le champ ldap_cn n'est pas définit,
     le calcul automatiquement en fonction du nom et du prénom
     """
-    if not instance.ldap_cn:
+    if not instance.ldap_cn and self.pk:
         instance.ldap_cn = instance.get_automatic_ldap_cn()
 
 

coin/members/tests.py

@@ -10,7 +10,7 @@ from pprint import pprint
 
 
 class MemberTests(TestCase):
-        
+
     def test_when_creating_member_a_ldapuser_is_also_created_with_same_data(self):
         """
         Test que lors de la création d'un nouveau membre, une entrée 
@@ -18,26 +18,26 @@ class MemberTests(TestCase):
         les mêmes données.
         Cela concerne le nom et le prénom
         """
+
         #~ Créé un membre
-        
-        first_name = u'Gérard';
-        last_name = u'Majax';
-        ldap_cn =  MemberTestsUtils.get_random_ldap_cn()
-        member = Member(first_name = first_name,
-                        last_name = last_name,
-                        ldap_cn = ldap_cn)
+        first_name = u'Gérard'
+        last_name = u'Majax'
+        ldap_cn = MemberTestsUtils.get_random_ldap_cn()
+        member = Member(first_name=first_name,
+                        last_name=last_name,
+                        ldap_cn=ldap_cn)
         member.save()
-        
+
         #~ Récupère l'utilisateur LDAP et fait les tests
         ldap_user = LdapUser.objects.get(pk=ldap_cn)
-        
+
         self.assertEqual(ldap_user.first_name, first_name)
         self.assertEqual(ldap_user.last_name, last_name)
         self.assertEqual(ldap_user.pk, ldap_cn)
-        
-        member.delete();
-        ldap_user.delete();
-    
+
+        member.delete()
+        ldap_user.delete()
+
     def test_when_modifiying_member_corresponding_ldap_user_is_also_modified_with_same_data(self):
         """
         Test que lorsque l'on modifie un membre, l'utilisateur LDAP 
@@ -45,28 +45,29 @@ class MemberTests(TestCase):
         Cela concerne le no met le prénom
         """
         #~ Créé un membre
-        first_name = u'Ronald';
-        last_name = u'Mac Donald';
-        ldap_cn =  MemberTestsUtils.get_random_ldap_cn()
-        member = Member(first_name = first_name, last_name = last_name, ldap_cn = ldap_cn)
+        first_name = u'Ronald'
+        last_name = u'Mac Donald'
+        ldap_cn = MemberTestsUtils.get_random_ldap_cn()
+        member = Member(first_name=first_name,
+                        last_name=last_name, ldap_cn=ldap_cn)
         member.save()
-        
+
         #~  Le modifie
-        new_first_name = u'José';
-        new_last_name = u'Bové';
+        new_first_name = u'José'
+        new_last_name = u'Bové'
         member.first_name = new_first_name
         member.last_name = new_last_name
         member.save()
-        
+
         #~ Récupère l'utilisateur LDAP et fait les tests
         ldap_user = LdapUser.objects.get(pk=ldap_cn)
-        
+
         self.assertEqual(ldap_user.first_name, new_first_name)
         self.assertEqual(ldap_user.last_name, new_last_name)
 
-        member.delete();
-        ldap_user.delete();
-    
+        member.delete()
+        ldap_user.delete()
+
     def test_when_creating_member_corresponding_ldap_user_is_in_coin_ldap_group(self):
         """
         Test que l'utilisateur Ldap fraichement créé est bien dans le group "coin"
@@ -74,23 +75,23 @@ class MemberTests(TestCase):
         est bien retiré du groupe.
         """
         #~ Créé un membre
-        ldap_cn =  MemberTestsUtils.get_random_ldap_cn()
-        member = Member(first_name = 'Canard', last_name = 'WC', ldap_cn = ldap_cn)
+        ldap_cn = MemberTestsUtils.get_random_ldap_cn()
+        member = Member(first_name='Canard',
+                        last_name='WC', ldap_cn=ldap_cn)
         member.save()
-        
+
         #~ Récupère le group "coin" et test que l'utilisateur y est présent
         ldap_group = LdapGroup.objects.get(pk="coin")
         self.assertEqual(ldap_cn in ldap_group.members, True)
-        
+
         #~ Supprime l'utilisateur
-        member.delete();
-        
+        member.delete()
+
         #~ Récupère le group "coin" et test que l'utilisateur n'y est plus
         ldap_group = LdapGroup.objects.get(pk="coin")
         self.assertEqual(ldap_cn in ldap_group.members, False)
-        
-        LdapUser.objects.get(pk=ldap_cn).delete();
 
+        LdapUser.objects.get(pk=ldap_cn).delete()
 
     def test_change_password_and_auth(self):
         """
@@ -99,24 +100,24 @@ class MemberTests(TestCase):
         """
         ldap_cn = MemberTestsUtils.get_random_ldap_cn()
         password = "1234"
-        
+
          #~ Créé un nouveau membre
-        member = Member(first_name = u'Passe-partout', last_name = u'Du fort Boyard', ldap_cn = ldap_cn)
+        member = Member(first_name=u'Passe-partout',
+                        last_name=u'Du fort Boyard', ldap_cn=ldap_cn)
         member.save()
-        
+
         #~ Récupère l'utilisateur LDAP
         ldap_user = LdapUser.objects.get(pk=ldap_cn)
-        
+
         #~ Change son mot de passe
         member.change_password(password)
 
         #~ Test l'authentification
         c = Client()
         self.assertEqual(c.login(username=ldap_cn, password=password), True)
-        
-        member.delete();
-        ldap_user.delete();
 
+        member.delete()
+        ldap_user.delete()
 
     def test_when_creating_member_ldap_display_name_is_well_defined(self):
         """
@@ -126,17 +127,18 @@ class MemberTests(TestCase):
         first_name = u'Gérard'
         last_name = u'Majax'
         ldap_cn = MemberTestsUtils.get_random_ldap_cn()
-        member = Member(first_name = first_name, last_name = last_name, ldap_cn = ldap_cn)
+        member = Member(first_name=first_name,
+                        last_name=last_name, ldap_cn=ldap_cn)
         member.save()
-        
+
         #~ Récupère l'utilisateur LDAP
         ldap_user = LdapUser.objects.get(pk=ldap_cn)
-        
-        self.assertEqual(ldap_user.display_name, '%s %s' % (first_name, last_name))
-        
-        member.delete();
-        ldap_user.delete();
 
+        self.assertEqual(ldap_user.display_name, '%s %s' %
+                         (first_name, last_name))
+
+        member.delete()
+        ldap_user.delete()
 
     def test_when_creating_member_ldap_cn_is_well_defined(self):
         """
@@ -148,16 +150,16 @@ class MemberTests(TestCase):
         random = os.urandom(4).encode('hex')
         first_name = u'Gérard-Étienne'
         last_name = u'Majax de la Boétie-Blop' + random
-               
+
         control = 'gemajaxdelaboetieblop' + random
-        
-        member = Member(first_name = first_name, last_name = last_name)
+
+        member = Member(first_name=first_name, last_name=last_name)
         member.save()
 
         self.assertEqual(member.ldap_cn, control)
-        
-        member.delete();
-        LdapUser.objects.get(pk=member.ldap_cn).delete();
+
+        member.delete()
+        LdapUser.objects.get(pk=member.ldap_cn).delete()
 
     def test_when_saving_member_and_ldap_fail_dont_save(self):
         """
@@ -167,34 +169,38 @@ class MemberTests(TestCase):
         # Fait échouer le LDAP en définissant un mauvais mot de passe
         for dbconnection in db.connections.all():
             if (type(dbconnection) is
-                ldapdb.backends.ldap.base.DatabaseWrapper):
+                    ldapdb.backends.ldap.base.DatabaseWrapper):
                 dbconnection.settings_dict['PASSWORD'] = 'wrong password test'
 
         # Créé un membre
         first_name = u'Du'
         last_name = u'Pont'
         ldap_cn = MemberTestsUtils.get_random_ldap_cn()
-        member = Member(first_name = first_name, last_name = last_name, ldap_cn = ldap_cn)
-        
+        member = Member(first_name=first_name,
+                        last_name=last_name, ldap_cn=ldap_cn)
+
         # Le sauvegarde en base de donnée
         # Le save devrait renvoyer une exception parceque le LDAP échoue
         self.assertRaises(Exception, member.save)
-        
+
         # On s'assure, malgré l'exception, que le membre n'est pas en base
         with self.assertRaises(Member.DoesNotExist):
             Member.objects.get(ldap_cn=ldap_cn)
 
 
 class MemberAdminTests(TestCase):
+
     def setUp(self):
         #~ Client web
         self.client = Client()
         #~ Créé un superuser
         self.admin_user_password = '1234'
-        self.admin_user = User.objects.create_superuser('test_admin_user', 'i@mail.com', self.admin_user_password)
+        self.admin_user = User.objects.create_superuser(
+            'test_admin_user', 'i@mail.com', self.admin_user_password)
         #~ Connection
-        self.assertEqual(self.client.login(username = self.admin_user.username, password = self.admin_user_password),True)
-        
+        self.assertEqual(self.client.login(
+            username=self.admin_user.username, password=self.admin_user_password), True)
+
     def test_cant_change_ldap_cn_when_editing(self):
         """
         Vérifie que dans l'admin Django, le champ ldap_cn n'est pad modifiable
@@ -204,20 +210,23 @@ class MemberAdminTests(TestCase):
         first_name = u'Gérard'
         last_name = u'Majax'
         ldap_cn = MemberTestsUtils.get_random_ldap_cn()
-        member = Member(first_name = first_name, last_name = last_name, ldap_cn = ldap_cn)
+        member = Member(first_name=first_name,
+                        last_name=last_name, ldap_cn=ldap_cn)
         member.save()
-        
+
         edit_page = self.client.get('/admin/members/member/%i/' % member.id)
         self.assertNotContains(edit_page,
             '''<input id="id_ldap_cn" />''',
-            html=True)
-        
-        LdapUser.objects.get(pk=ldap_cn).delete();
+                               html=True)
+
+        LdapUser.objects.get(pk=ldap_cn).delete()
+
 
 class MemberTestsUtils(object):
+
     @staticmethod
     def get_random_ldap_cn():
         """
         Renvoi une clé aléatoire pour un utilisateur LDAP
         """
-        return 'coin_test_' + os.urandom(8).encode('hex');
+        return 'coin_test_' + os.urandom(8).encode('hex')

coin/models.py

@@ -30,7 +30,7 @@ class CoinLdapSyncModel(models.Model):
         # Si la sauvegarde LDAP échoue, Rollback la sauvegarde en base, sinon
         # commit
         try:
-            self.sync_with_ldap(creation)
+            self.sync_to_ldap(creation)
         except:
             raise