Merge branch 'postatum-99310032_more_args_processors' into develop

nefertari/authentication/models.py

@@ -147,16 +147,17 @@ def get_authuser_by_name(cls, request):
             return cls.get_resource(username=username)
 
 
-def lower_strip(instance, new_value):
-    return (new_value or '').lower().strip()
+def lower_strip(**kwargs):
+    return (kwargs['new_value'] or '').lower().strip()
 
 
-def random_uuid(instance, new_value):
-    return new_value or uuid.uuid4().hex
+def random_uuid(**kwargs):
+    return kwargs['new_value'] or uuid.uuid4().hex
 
 
-def encrypt_password(instance, new_value):
+def encrypt_password(**kwargs):
     """ Crypt :new_value: if it's not crypted yet. """
+    new_value = kwargs['new_value']
     if new_value and not crypt.match(new_value):
         new_value = str(crypt.encode(new_value))
     return new_value

nefertari/elasticsearch.py

@@ -82,18 +82,20 @@ def includeme(config):
         config.include('nefertari.polymorphic')
 
 
-def _bulk_body(documents_actions, request_params):
-    if request_params is None:
-        request_params = {}
-    request_params = dictset(request_params)
+def _bulk_body(documents_actions, request):
     kwargs = {
         'client': ES.api,
         'actions': documents_actions,
     }
 
+    if request is None:
+        query_params = {}
+    else:
+        query_params = request.params.mixed()
+    query_params = dictset(query_params)
     refresh_enabled = ES.settings.asbool('enable_refresh_query')
-    if '_refresh_index' in request_params and refresh_enabled:
-        kwargs['refresh'] = request_params.asbool('_refresh_index')
+    if '_refresh_index' in query_params and refresh_enabled:
+        kwargs['refresh'] = query_params.asbool('_refresh_index')
 
     executed_num, errors = helpers.bulk(**kwargs)
     log.info('Successfully executed {} Elasticsearch action(s)'.format(
@@ -312,7 +314,7 @@ def prep_bulk_documents(self, action, documents):
 
         return docs_actions
 
-    def _bulk(self, action, documents, request_params=None):
+    def _bulk(self, action, documents, request=None):
         if not documents:
             log.debug('Empty documents: %s' % self.doc_type)
             return
@@ -326,18 +328,18 @@ def _bulk(self, action, documents, request_params=None):
                     doc['_timestamp'] = doc_data['timestamp']
 
         if documents_actions:
-            operation = partial(_bulk_body, request_params=request_params)
+            operation = partial(_bulk_body, request=request)
             self.process_chunks(
                 documents=documents_actions,
                 operation=operation)
         else:
             log.warning('Empty body')
 
-    def index(self, documents, request_params=None):
+    def index(self, documents, request=None):
         """ Reindex all `document`s. """
-        self._bulk('index', documents, request_params)
+        self._bulk('index', documents, request)
 
-    def index_missing_documents(self, documents, request_params=None):
+    def index_missing_documents(self, documents, request=None):
         """ Index documents that are missing from ES index.
 
         Determines which documents are missing using ES `mget` call which
@@ -369,14 +371,14 @@ def index_missing_documents(self, documents, request_params=None):
                      'index `{}`'.format(self.doc_type, self.index_name))
             return
 
-        self._bulk('index', documents, request_params)
+        self._bulk('index', documents, request)
 
-    def delete(self, ids, request_params=None):
+    def delete(self, ids, request=None):
         if not isinstance(ids, list):
             ids = [ids]
 
         documents = [{'_pk': _id, '_type': self.doc_type} for _id in ids]
-        self._bulk('delete', documents, request_params=request_params)
+        self._bulk('delete', documents, request=request)
 
     def get_by_ids(self, ids, **params):
         if not ids:
@@ -626,8 +628,8 @@ def get(self, **kw):
         return self.get_resource(**kw)
 
     @classmethod
-    def index_refs(cls, db_obj, request_params=None):
+    def index_refs(cls, db_obj, request=None):
         for model_cls, documents in db_obj.get_reference_documents():
             if getattr(model_cls, '_index_enabled', False) and documents:
                 cls(model_cls.__name__).index(
-                    documents, request_params=request_params)
+                    documents, request=request)

nefertari/polymorphic.py

@@ -212,7 +212,10 @@ def _set_object_self(self, obj):
 
         '_self' key is not set for singular resources.
         """
-        type_, obj_pk = obj['_type'], obj['_pk']
+        try:
+            type_, obj_pk = obj['_type'], obj['_pk']
+        except KeyError:
+            return
         resource = self.model_resources[type_]
         obj['_self'] = self.request.route_url(
             resource.uid, **{resource.id_name: obj_pk})

nefertari/wrappers.py

@@ -245,7 +245,10 @@ def is_singular(self):
     def _set_object_self(self, obj):
         """ Add '_self' key value to :obj: dict. """
         location = self.request.path_url
-        obj_pk = urllib.parse.quote(str(obj['_pk']))
+        try:
+            obj_pk = urllib.parse.quote(str(obj['_pk']))
+        except KeyError:
+            return
         if not self.is_singular and not location.endswith(obj_pk):
             location += '/{}'.format(obj_pk)
         obj.setdefault('_self', location)

tests/test_authentication/test_models.py

@@ -9,15 +9,17 @@ class TestModelHelpers(object):
 
     def test_lower_strip(self, engine_mock):
         from nefertari.authentication import models
-        assert models.lower_strip(None, 'Foo   ') == 'foo'
-        assert models.lower_strip(None, None) == ''
+        assert models.lower_strip(instance=None, new_value='Foo   ') == 'foo'
+        assert models.lower_strip(instance=None, new_value=None) == ''
 
     def test_encrypt_password(self, engine_mock):
         from nefertari.authentication import models
-        encrypted = models.encrypt_password(None, 'foo')
+        encrypted = models.encrypt_password(
+            instance=None, new_value='foo')
         assert models.crypt.match(encrypted)
         assert encrypted != 'foo'
-        assert encrypted == models.encrypt_password(None, encrypted)
+        assert encrypted == models.encrypt_password(
+            instance=None, new_value=encrypted)
 
     @patch('nefertari.authentication.models.uuid.uuid4')
     def test_create_apikey_token(self, mock_uuid, engine_mock):

tests/test_elasticsearch.py

@@ -147,7 +147,9 @@ def test_es_docs(self):
     @patch('nefertari.elasticsearch.helpers')
     def test_bulk_body(self, mock_helpers, mock_es):
         mock_helpers.bulk.return_value = (1, [])
-        es._bulk_body('foo', {'_refresh_index': True})
+        request = Mock()
+        request.params.mixed.return_value = {'_refresh_index': True}
+        es._bulk_body('foo', request)
         mock_helpers.bulk.assert_called_once_with(
             client=mock_es.api, refresh=True, actions='foo')
 
@@ -278,7 +280,7 @@ def test_bulk(self, mock_proc, mock_prep, mock_part):
         obj._bulk('index', docs)
         mock_prep.assert_called_once_with('index', docs)
         mock_part.assert_called_once_with(
-            es._bulk_body, request_params=None)
+            es._bulk_body, request=None)
         mock_proc.assert_called_once_with(
             documents=[{
                 '_id': 'story1', '_op_type': 'index', '_timestamp': 1,
@@ -312,15 +314,15 @@ def test_delete(self, mock_bulk):
         mock_bulk.assert_called_once_with(
             'delete', [{'_pk': 1, '_type': 'foo'},
                        {'_pk': 2, '_type': 'foo'}],
-            request_params=None)
+            request=None)
 
     @patch('nefertari.elasticsearch.ES._bulk')
     def test_delete_single_obj(self, mock_bulk):
         obj = es.ES('Foo', 'foondex')
         obj.delete(ids=1)
         mock_bulk.assert_called_once_with(
             'delete', [{'_pk': 1, '_type': 'foo'}],
-            request_params=None)
+            request=None)
 
     @patch('nefertari.elasticsearch.ES._bulk')
     @patch('nefertari.elasticsearch.ES.api.mget')
@@ -798,7 +800,7 @@ class Foo(object):
         db_obj.get_reference_documents.return_value = [(Foo, docs)]
         mock_settings.index_name = 'foo'
         es.ES.index_refs(db_obj)
-        mock_ind.assert_called_once_with(docs, request_params=None)
+        mock_ind.assert_called_once_with(docs, request=None)
 
     @patch('nefertari.elasticsearch.ES.settings')
     @patch('nefertari.elasticsearch.ES.index')