Added tests for Lodel.user module

Testing authentication_method and identification_method decorator classes + UserIdentity and UserContext classes

Lodel/hooks.py

@@ -83,5 +83,5 @@ class LodelHook(object):
     # @warning REALLY NOT a good idea !
     # @note implemented for testing purpose
     @classmethod
-    def __reset_hooks__(cls):
+    def __reset__(cls):
         cls._hooks = dict()

Lodel/test/tests_user.py

@@ -0,0 +1,155 @@
+#-*- coding: utf-8 -*-
+
+import unittest
+import unittest.mock
+from unittest.mock import Mock
+
+from Lodel.user import  authentication_method, identification_method, UserIdentity, UserContext
+
+
+class AuthIdMethodTestCase(unittest.TestCase):
+    
+    def test_authentication_method_registration(self):
+        before = set(authentication_method.list_methods())
+
+        def test_method(self):
+            pass
+        authentication_method(test_method) # faking test_method decoration
+
+        after = set(authentication_method.list_methods())
+        self.assertEqual(after - before, set([test_method]))
+
+    def test_identification_method_registration(self):
+        before = set(identification_method.list_methods())
+
+        def test_method(self):
+            pass
+        identification_method(test_method) # faking test_method decoration
+        
+        after = set(identification_method.list_methods())
+        self.assertEqual(after - before, set([test_method]))
+
+    def test_authentication_method_calls(self):
+        mock_list = list()
+        for i in range(5):
+            auth_mock = Mock(return_value = False)
+            mock_list.append(auth_mock)
+            authentication_method(auth_mock)
+        ret = authentication_method.authenticate('login', 'password')
+        self.assertFalse(ret)
+        for mock in mock_list:
+            mock.assert_called_once_with('login', 'password')
+        # Adding a mock that will fake a successfull auth
+        user_id = UserIdentity(42, 'superlogin', authenticated = True)
+        authentication_method( Mock(return_value = user_id) )
+        ret = authentication_method.authenticate('login', 'password')
+        self.assertEqual(ret, user_id)
+
+    def test_identificatio_method_calls(self):
+        mock_list = list()
+        for i in range(5):
+            id_mock = Mock(return_value = False)
+            mock_list.append(id_mock)
+            identification_method(id_mock)
+        client_infos = {'ip':'127.0.0.1', 'user-agent': 'bla bla'}
+        ret = identification_method.identify(client_infos)
+        self.assertFalse(ret)
+        for mock in mock_list:
+            mock.assert_called_once_with(client_infos)
+        # Adding a mock that will fake a successfull identification
+        user_id = UserIdentity(42, 'login', identified = True)
+        identification_method( Mock(return_value = user_id) )
+        ret = identification_method.identify(client_infos)
+        self.assertEqual(ret, user_id)
+
+class UserIdentityTestCase(unittest.TestCase):
+    
+    def test_init(self):
+        """ Testing UserIdentity constructor """
+        uid = UserIdentity(42, 'login', 'anonymous login')
+        self.assertEqual(uid.user_id, 42)
+        self.assertEqual(uid.username, 'login')
+        self.assertEqual(uid.fullname, 'anonymous login')
+        self.assertFalse(uid.is_authenticated)
+        self.assertFalse(uid.is_identified)
+        self.assertEqual(str(uid), uid.fullname)
+
+    def test_identified(self):
+        """ Testing identified flag relation with authenticated flag """
+        uid = UserIdentity(42, 'login', identified = True)
+        self.assertTrue(uid.is_identified)
+        self.assertFalse(uid.is_authenticated)
+
+    def test_authentified(self):
+        """ Testing identified flag relation with authenticated flag """
+        uid = UserIdentity(42, 'login', authenticated = True)
+        self.assertTrue(uid.is_identified)
+        self.assertTrue(uid.is_authenticated)
+
+    def test_anonymous(self):
+        """ Testing the anonymous UserIdentity """
+        anon = UserIdentity.anonymous()
+        self.assertEqual(anon, UserIdentity.anonymous())
+        self.assertFalse(anon.is_authenticated)
+        self.assertFalse(anon.is_identified)
+
+class UserContextTestCase(unittest.TestCase):
+    
+    def test_static(self):
+        """ Testing that the class is static """
+        with self.assertRaises(NotImplementedError):
+            UserContext()
+
+    def test_not_init(self):
+        """ Testing method call with a non initialised class """
+        UserContext.__reset__()
+        with self.assertRaises(AssertionError):
+            UserContext.identity()
+        with self.assertRaises(AssertionError):
+            UserContext.authenticate('login', 'foobar')
+
+    def test_anon_init(self):
+        """ Testing class initialisation """
+        identification_method.__reset__()
+        authentication_method.__reset__()
+        UserContext.__reset__()
+        auth_id = UserIdentity(43, 'loggedlogin', authenticated = True)
+        # Add a fake authentication method
+        auth_mock = Mock(return_value = auth_id)
+        authentication_method(auth_mock)
+        # Are we anonymous ?
+        UserContext.init('localhost')
+        self.assertEqual(UserContext.identity(), UserIdentity.anonymous())
+        # Can we authenticate ourself ?
+        UserContext.authenticate('login', 'pass')
+        auth_mock.assert_called_once_with('login', 'pass')
+        self.assertEqual(auth_id, UserContext.identity())
+
+    def test_init(self):
+        """ Testing class initialisation being identified by client_infos"""
+        identification_method.__reset__()
+        authentication_method.__reset__()
+        UserContext.__reset__()
+        user_id = UserIdentity(42, 'login', identified = True)
+        auth_id = UserIdentity(43, 'loggedlogin', authenticated = True)
+        # Add a fake id method
+        id_mock = Mock(return_value = user_id)
+        identification_method(id_mock)
+        # Add a fake authentication method
+        auth_mock = Mock(return_value = auth_id)
+        authentication_method(auth_mock)
+        # testing lazy identification
+        UserContext.init('localhost')
+        id_mock.assert_not_called()
+        auth_mock.assert_not_called() # should really not be called yet
+        # triggering identification
+        ret_id = UserContext.identity()
+        id_mock.assert_called_once_with('localhost')
+        self.assertEqual(ret_id, user_id)
+        auth_mock.assert_not_called() # should really not be called yet
+        id_mock.reset_mock()
+        # Trying to auth
+        UserContext.authenticate('identifier', 'superproof')
+        id_mock.assert_not_called()
+        auth_mock.assert_called_once_with('identifier', 'superproof')
+        self.assertEqual(UserContext.identity(), auth_id)

Lodel/user.py

@@ -107,7 +107,7 @@ class authentication_method(object):
     @classmethod
     def authenticate(cls, identifier, proof):
         if len(cls.__methods) == 0:
-            raise RuntimeError("Not authentication method registered")
+            raise RuntimeError("No authentication method registered")
         res = False
         for method in cls.__methods:
             ret = method(identifier, proof)
@@ -127,6 +127,12 @@ class authentication_method(object):
     def list_methods(cls):
         return list(copy.copy(cls.__methods))
 
+    ## @brief Unregister all authentication methods
+    # @warning REALLY NOT a good idead !
+    # @note implemented for testing purpose
+    @classmethod
+    def __reset__(cls):
+        cls.__methods = set()
 
 
 ## @brief Decorator class designed to register identification methods
@@ -165,8 +171,9 @@ class identification_method(object):
                     if res is not False:
                         warnings.warn("Identifying methods returns multiple identity given client_infos")
                     else:
-                        return ret
-                    res = ret
+                        res = ret
+                else:
+                    return ret
         return res
     
     ## @return registered identification methods
@@ -174,6 +181,13 @@ class identification_method(object):
     def list_methods(cls):
         return list(copy.copy(cls.__methods))
 
+    ## @brief Unregister all identification methods
+    # @warning REALLY NOT a good idead !
+    # @note implemented for testing purpose
+    @classmethod
+    def __reset__(cls):
+        cls.__methods = set()
+
 
 ## @brief Static class designed to handle user context
 class UserContext(object):
@@ -232,6 +246,7 @@ class UserContext(object):
         cls.__identity = ret
     
     ## @return UserIdentity instance
+    # @todo useless alias to identity()
     @classmethod
     def user_identity(cls):
         cls.assert_init()
@@ -246,3 +261,12 @@ class UserContext(object):
     @classmethod
     def assert_init(cls):
         assert cls.initialized(), "User context is not initialized"
+    
+    ## @brief Reset the UserContext
+    # @warning Most of the time IT IS NOT A GOOD IDEAD
+    # @note implemented for test purpose
+    @classmethod
+    def __reset__(cls):
+        cls.__client_infos = None
+        cls.__identity = None
+        cls.__context = None

leapi/lecrud.py

@@ -309,8 +309,8 @@ class _LeCrud(object):
     # @todo better error handling
     def delete(self):
         LodelHook.call_hook('leapi_delete_pre', self, None)
-        self._datasource.delete(self.__class__, self.uidget())
-        return LodelHook.call_hook('leapi_delete_post', self, None)
+        ret = self._datasource.delete(self.__class__, self.uidget())
+        return LodelHook.call_hook('leapi_delete_post', self, ret)
 
     ## @brief Check that datas are valid for this type
     # @param datas dict : key == field name value are field values