Merge branch 'newlodel' of git.labocleo.org:lodel2 into newlodel

lodel/leapi/query.py

@@ -528,7 +528,7 @@ target to LeUpdateQuery constructor"
     #@returns the number of updated items
     #@todo change stategy for instance update. Datas should be allowed 
     #for execute method (and query)
-    def _query(self, filters, rel_filters, datas):
+    def _query(self, datas):
         uid_name = self._target_class._uid[0]
         if self.__leobject_instance is not None:
             #Instance update
@@ -629,7 +629,7 @@ class LeGetQuery(LeFilteredQuery):
         if 'group' in kwargs:
             #check kwargs['group']
             self.__group = kwargs['group']
-        if 'limit' in kwargs:
+        if 'limit' in kwargs and kwargs['limit'] is not None:
             try:
                 self.__limit = int(kwargs['limit'])
                 if self.__limit <= 0:
@@ -670,7 +670,7 @@ class LeGetQuery(LeFilteredQuery):
 
     ##@brief Implements select query operations
     # @returns a list containing the item(s)
-    def _query(self):
+    def _query(self, datas = None):
         # select datas corresponding to query_filter
         l_datas=self._ro_datasource.select(  self._target_class,
                                     list(self.field_list),

plugins/mongodb_datasource/migration_handler.py

@@ -6,6 +6,7 @@ from lodel.editorial_model.model import EditorialModel
 from .utils import get_connection_args, connect, collection_prefix, object_collection_name, mongo_fieldname
 from lodel.leapi.datahandlers.base_classes import DataHandler
 from lodel.plugin import LodelHook
+from leapi_dyncode import *
 
 
 class MigrationHandlerChangeError(Exception):
@@ -32,11 +33,14 @@ class MongoDbMigrationHandler(object):
     ## @brief Constructs a MongoDbMigrationHandler
     # @param conn_args dict : a dictionary containing the connection options
     # @param **kwargs : extra arguments
-    def __init__(self, editorial_model, conn_args=None, **kwargs):
+    def __init__(self, editorial_model=None, conn_args=None, **kwargs):
         self.editorial_model = editorial_model
 
         conn_args = get_connection_args() if conn_args is None else conn_args
 
+        if editorial_model is None:
+            raise MongoDbMigrationHandler("Missing editorial model")
+
         if len(conn_args.keys()) == 0:
             raise MigrationHandlerError("No connection arguments were given")
 
@@ -61,11 +65,10 @@ class MongoDbMigrationHandler(object):
         #self._install_collections()
 
     def _set_init_collection_names(self):
-        collection_names = []
-        init_collections = self.editorial_model.all_classes()
-        for init_collection in init_collections.items():
-            if init_collection.abstract:
-                collection_names.append(init_collection.uid)
+        collection_names = ['relation']
+        for dynclass in dynclasses:
+            if dynclass._abstract:
+                collection_names.append(dynclass.__name__)
         return collection_names
 
     ## @brief Installs the basis collections of the database

runtest

@@ -54,7 +54,6 @@ cp -R tests $testdir
 cd $testdir
 rm -R conf.d && mv tests/tests_conf.d conf.d
 make
-#python3 -W ignore -m unittest $@
 python3 loader.py $@
 
 rm -Rf $testdir

scripts/admin.py

@@ -23,7 +23,7 @@ def refresh_dyncode(model_file, translator, output_filename):
         out_fd.write(dyncode)
     out_fd.close()
 
-def init_db(conn_args):
-    migration_handler = MongoDbMigrationHandler(conn_args=conn_args)
+def init_db(conn_args, editorial_model):
+    migration_handler = MongoDbMigrationHandler(editorial_model, conn_args)
     migration_handler._install_collections()
     migration_handler.database.close()

tests/leapi/query/test_datasource.py

@@ -0,0 +1,104 @@
+import unittest
+from unittest import mock
+from unittest.mock import patch
+
+import tests.loader_utils
+from tests.leapi.query.utils import dyncode_module as dyncode
+from lodel.leapi.query import LeDeleteQuery, LeUpdateQuery, LeGetQuery, \
+    LeInsertQuery
+
+class LeQueryDatasourceTestCase(unittest.TestCase):
+    """ Testing LeQuery objects connection with datasource """
+
+    mockread = mock.MagicMock()
+    mockwrite = mock.MagicMock()
+    dyncode = None
+
+    @classmethod
+    def setUpClass(cls):
+        """ Mocking read & write datasource of dyncode """
+        cls.dyncode = dict()
+        for dyncls in dyncode.dynclasses:
+            dyncls._ro_datasource = cls.mockread
+            dyncls._rw_datasource = cls.mockwrite
+            cls.dyncode[dyncls.__name__] = dyncls
+
+    def setUp(self):
+        """ Reseting all mock calls before test """
+        self.mockread.reset_mock()
+        self.mockwrite.reset_mock()
+
+    def check_nocall(self, read = True, exclude = None):
+        """ Utility function to check if a datasource mock method has been
+            called during test """
+        exclude = [] if exclude is None else exclude
+        if read:
+            mockds = self.mockread
+        else:
+            mockds = self.mockwrite
+
+        if 'select' not in exclude:
+            self.assertFalse(
+                mockds.select.called,
+                "select method was not expected to be called")
+        if 'delete' not in exclude:
+            self.assertFalse(
+                mockds.delete.called,
+                "delete method was not expected to be called")
+        if 'update' not in exclude:
+            self.assertFalse(
+                mockds.update.called,
+                "update method was not expected to be called")
+        if 'insert' not in exclude:
+            self.assertFalse(
+                mockds.insert.called,
+                "insert method was not expected to be called")
+
+    def test_delete_simple_filter(self):
+        """ Testing delete query mocking datasource using simple query
+            filters """
+        cls = self.dyncode['Person']
+        query = LeDeleteQuery(
+            target_class = cls,
+            query_filter = ['lodel_id = 1', 'alias.lodel_id = 2'])
+        query.execute()
+        # Cannot check with assert_called_once_with because of the array
+        # that is not in a deterministic order
+        call_args = self.mockwrite.delete.call_args[0]
+        self.assertEqual(call_args[0], cls)
+        self.assertEqual(
+            sorted(call_args[1]),
+            sorted([('lodel_id', '=', '1'), ('alias', '=', '2')]))
+        self.assertEqual(call_args[2], [])
+        self.check_nocall(read = False, exclude = ['delete'])
+        self.check_nocall(read = True)
+
+
+    def test_delete_simple_rel_filters(self):
+        """ Testing delete query mocking datasource using simple filters
+            and relationnal filters"""
+        cls = self.dyncode['Person']
+        query = LeDeleteQuery(
+            target_class = cls,
+            query_filter = ['lodel_id = 1', 'alias.firstname = foo'])
+        query.execute()
+        self.mockwrite.delete.assert_called_once_with(
+            cls,
+            [('lodel_id', '=', '1')],
+            [(('alias', {cls: 'firstname'}), '=', 'foo')])
+        self.check_nocall(read = False, exclude = ['delete'])
+        self.check_nocall(read = True)
+
+    def test_delete_rel_filters(self):
+        """ Testing delete query mocking datasource """
+        cls = self.dyncode['Person']
+        query = LeDeleteQuery(
+            target_class = cls,
+            query_filter = ['alias.firstname = foo'])
+        query.execute()
+        self.mockwrite.delete.assert_called_once_with(
+            cls,
+            [],
+            [(('alias', {cls: 'firstname'}), '=', 'foo')])
+        self.check_nocall(read = False, exclude = ['delete'])
+        self.check_nocall(read = True)

tests/leapi/query/test_filtered.py

@@ -3,7 +3,7 @@ import unittest
 import tests.loader_utils
 from tests.leapi.query.utils import dyncode_module as dyncode
 
-from lodel.leapi.leobject import LeApiDataCheckError
+from lodel.leapi.exceptions import LeApiDataCheckError
 from lodel.leapi.query import LeDeleteQuery, LeUpdateQuery, LeGetQuery
 
 class LeFilteredQueryTestCase(unittest.TestCase):

tests/leapi/test_leobject.py

@@ -243,3 +243,28 @@ class LeObjectQueryMockTestCase(unittest.TestCase):
             self.assertEqual(res.d.lodel_id, 1)
             self.assertEqual(res.d.firstname, 'foo')
             self.assertEqual(res.d.lastname, 'bar')
+
+    def test_get_mini(self):
+        """ Checking that LeObject.get method calls LeGetQuery correctly
+            when called with minimum args """
+            
+        with patch.object(
+            LeGetQuery, '__init__', return_value = None) as mock_init:
+        
+            try:
+                dyncode.Person.get(['lodel_id = 1'])
+            except AttributeError:
+                pass
+            
+            mock_init.assert_called_once_with(
+                dyncode.Person,
+                query_filters = ['lodel_id = 1'],
+                field_list = dyncode.Person.fieldnames(True),
+                order = None, group = None, limit = None, offset = 0)
+
+        with patch.object(
+            LeGetQuery, 'execute', return_value = []) as mock_exec:
+            
+            dyncode.Person.get(['lodel_id = 1'])
+            mock_exec.assert_called_once_with()
+