should_index: handle properties and BooleanFields

Author: PLNech

src/models.py

@@ -38,6 +38,8 @@ class AlgoliaIndex(object):
     # - a BooleanField
     # - a boolean property or attribute
     should_index = None
+    # Name of the attribute to check on instances if should_index is not a callable
+    _should_index_is_method = False
 
     # Instance of the index from algoliasearch client
     __index = None
@@ -94,23 +96,20 @@ def __init__(self, model, client):
                 raise AlgoliaIndexError('{} is not an attribute of {}.'.format(
                     self.geo_field, model))
 
-        # Check should_index + get the callable
+        # Check should_index + get the callable or attribute/field name
         if self.should_index:
             if hasattr(model, self.should_index):
                 attr = getattr(model, self.should_index)
-                if callable(attr):
+                if type(attr) is not bool:  # if attr is a bool, we keep attr=name to getattr on instance
                     self.should_index = attr
-                else:
-                    should_index_attr_name = self.should_index
-                    if isinstance(attr, bool):
-                        self.should_index = lambda instance: getattr(instance, should_index_attr_name) is True
-                        self.should_index._is_default = True
-                    else:
-                        raise AlgoliaIndexError('{} should be a bound callable or a boolean attribute.'.format(
-                            self.should_index))
+                if callable(self.should_index):
+                    self._should_index_is_method = True
             else:
-                raise AlgoliaIndexError('{} is not an attribute of {}.'.format(
-                    self.should_index, model))
+                try:
+                    model._meta.get_field_by_name(self.should_index)
+                except:
+                    raise AlgoliaIndexError('{} is not an attribute nor a field of {}.'.format(
+                        self.should_index, model))
 
     def __set_index(self, client):
         '''Get an instance of Algolia Index'''
@@ -196,8 +195,8 @@ def _build_object(self, instance):
         return tmp
 
     def update_obj_index(self, instance):
-        '''Update the object.'''
-        if self.should_index:
+        """Update the object."""
+        if self._has_should_index():
             if not self._should_really_index(instance):
                 # Should not index, but since we don't now the state of the
                 # instance, we need to send a DELETE request to ensure that if
@@ -209,21 +208,40 @@ def update_obj_index(self, instance):
         self.__index.save_object(obj)
         logger.debug('UPDATE %s FROM %s', obj['objectID'], self.model)
 
+    def _has_should_index(self):
+        """Return True if this AlgoliaIndex has a should_index method or attribute"""
+        return self.should_index is not None
+
     def _should_index(self, instance):
-        """Return true if the object should be indexed (including when self.should_index is not set)."""
-        if self.should_index:
+        """Return True if the object should be indexed (including when self.should_index is not set)."""
+        if self._has_should_index():
             return self._should_really_index(instance)
         else:
             return True
 
     def _should_really_index(self, instance):
-        """Return true if according to should_index the object should be indexed."""
-        if hasattr(self.should_index, "__self__") or hasattr(self.should_index, '_is_default'):
-            # bound method or lambda, let's use instance
-            return self.should_index(instance)
+        """Return True if according to should_index the object should be indexed."""
+        if self._should_index_is_method:
+            if hasattr(self.should_index, "__self__"):
+                # bound method, call with instance
+                return self.should_index(instance)
+            else:
+                # unbound method, simply call without arguments
+                return self.should_index()
         else:
-            # unbound method, simply call without arguments
-            return self.should_index()
+            # property/attribute/Field, evaluate as bool
+            attr_type = type(self.should_index)
+            if attr_type is str:
+                attr_value = getattr(instance, self.should_index)
+            elif attr_type is property:
+                attr_value = self.should_index.__get__(instance)
+            else:
+                raise AlgoliaIndexError('{} should be a boolean attribute or a method that returns a boolean.'.format(
+                    self.should_index))
+            if type(attr_value) is not bool:
+                raise AlgoliaIndexError("%s's should_index (%s) should be a boolean" % (
+                    instance.__class__.__name__, self.should_index))
+            return attr_value
 
     def delete_obj_index(self, instance):
         '''Delete the object.'''

tests/models.py

@@ -32,3 +32,11 @@ def static_should_not_index():
     @property
     def property_should_index(self):
         return True
+
+    @property
+    def property_should_not_index(self):
+        return True
+
+    @property
+    def property_string(self):
+        return "foo"

tests/test_index.py

@@ -15,7 +15,8 @@ def setUp(self):
                                 name='SuperK',
                                 address='Finland',
                                 lat=63.3,
-                                lng=-32.0)
+                                lng=-32.0,
+                                is_admin=True)
         self.instance.category = ['Shop', 'Grocery']
         self.instance.locations = [
             {'lat': 10.3, 'lng': -20.0},
@@ -205,26 +206,59 @@ class ExampleIndex(AlgoliaIndex):
             fields = 'name'
             should_index = 'index_me'
         index = ExampleIndex(Example, self.client)
-        obj = index._build_object(self.instance)
         self.assertTrue(index._should_index(self.instance),
                         "We should index an instance when its should_index attr is True")
 
         instance_should_not = Example()
         instance_should_not.index_me = False
-        obj = index._build_object(instance_should_not)
         self.assertFalse(index._should_index(instance_should_not),
                          "We should not index an instance when its should_index attr is False")
 
-    def test_should_index_field_raises(self):
+        class ExampleIndex(AlgoliaIndex):
+            fields = 'name'
+            should_index = 'category'
+        index = ExampleIndex(Example, self.client)
+        with self.assertRaises(AlgoliaIndexError, msg="We should raise when the should_index attr is not boolean"):
+            index._should_index(self.instance)
+
+    def test_should_index_field(self):
         class ExampleIndex(AlgoliaIndex):
             fields = 'name'
             should_index = 'is_admin'
-        with self.assertRaises(AlgoliaIndexError):
-            index = ExampleIndex(Example, self.client)
+        index = ExampleIndex(Example, self.client)
+        self.assertTrue(index._should_index(self.instance),
+                        "We should index an instance when its should_index field is True")
+
+        instance_should_not = Example()
+        instance_should_not.is_admin = False
+        self.assertFalse(index._should_index(instance_should_not),
+                         "We should not index an instance when its should_index field is False")
 
-    def test_should_index_property_raises(self):
+        class ExampleIndex(AlgoliaIndex):
+            fields = 'name'
+            should_index = 'name'
+        index = ExampleIndex(Example, self.client)
+        with self.assertRaises(AlgoliaIndexError, msg="We should raise when the should_index field is not boolean"):
+            index._should_index(self.instance)
+
+    def test_should_index_property(self):
         class ExampleIndex(AlgoliaIndex):
             fields = 'name'
             should_index = 'property_should_index'
-        with self.assertRaises(AlgoliaIndexError):
-            index = ExampleIndex(Example, self.client)
+        index = ExampleIndex(Example, self.client)
+        self.assertTrue(index._should_index(self.instance),
+                        "We should index an instance when its should_index property is True")
+
+        class ExampleIndex(AlgoliaIndex):
+            fields = 'name'
+            should_index = 'static_should_not_index'
+        index = ExampleIndex(Example, self.client)
+        self.assertFalse(index._should_index(self.instance),
+                         "We should not index an instance when its should_index property is False")
+
+        class ExampleIndex(AlgoliaIndex):
+            fields = 'name'
+            should_index = 'property_string'
+        index = ExampleIndex(Example, self.client)
+        with self.assertRaises(AlgoliaIndexError, msg="We should raise when the should_index property is not boolean"):
+            index._should_index(self.instance)