Merge pull request #46 from rpkilby/fix-boolean-filter

Fix boolean filter

Author: Ryan P Kilby

rest_framework_filters/fields.py

@@ -1,5 +1,15 @@
 from django import forms
 
+# TODO: Remove when django-filter 0.12.0 is released
+try:
+    from django_filters import BooleanWidget
+except ImportError:
+    from .widgets import BooleanWidget
+
+
+class BooleanField(forms.BooleanField):
+    widget = BooleanWidget
+
 
 class ArrayDecimalField(forms.DecimalField):
     def clean(self, value):

rest_framework_filters/filters.py

@@ -14,7 +14,7 @@
 
 def _import_class(path):
     module_path, class_name = path.rsplit('.', 1)
-    class_name = str(class_name) # Ensure not unicode on py2.x
+    class_name = str(class_name)  # Ensure not unicode on py2.x
     module = __import__(module_path, fromlist=[class_name], level=0)
     return getattr(module, class_name)
 
@@ -69,6 +69,9 @@ class AllLookupsFilter(Filter):
 ###################################################
 # Fixed-up versions of some of the default filters
 ###################################################
+class BooleanFilter(BooleanFilter):
+    field_class = fields.BooleanField
+
 
 class InSetFilterBase(object):
     def filter(self, qs, value):

rest_framework_filters/widgets.py

@@ -0,0 +1,26 @@
+
+from __future__ import absolute_import
+from __future__ import unicode_literals
+
+from django import forms
+
+
+# TODO: Remove when django-filter 0.12.0 is released
+class BooleanWidget(forms.Widget):
+    """Convert true/false values into the internal Python True/False.
+    This can be used for AJAX queries that pass true/false from JavaScript's
+    internal types through.
+    """
+    def value_from_datadict(self, data, files, name):
+        """
+        """
+        value = super(BooleanWidget, self).value_from_datadict(
+            data, files, name)
+
+        if value is not None:
+            if value.lower() == 'true':
+                value = True
+            elif value.lower() == 'false':
+                value = False
+
+        return value

tests/filters.py

@@ -19,6 +19,8 @@ class Meta:
 class UserFilter(FilterSet):
     username = filters.CharFilter(name='username')
     email = filters.CharFilter(name='email')
+    last_login = filters.AllLookupsFilter()
+    is_active = filters.BooleanFilter(name='is_active')
 
     class Meta:
         model = User
@@ -56,15 +58,10 @@ class Meta:
         model = Note
 
 
-class PostFilterWithRelated(FilterSet):
-    note = RelatedFilter(NoteFilterWithRelatedAll, name='note')
-
-    class Meta:
-        model = Post
-
-
-class PostFilterWithMethod(FilterSet):
+class PostFilter(FilterSet):
+    # Used for Related filter and MethodFilter tests
     note = RelatedFilter(NoteFilterWithRelatedAll, name='note')
+    date_published = filters.AllLookupsFilter()
     is_published = filters.MethodFilter()
 
     class Meta:
@@ -91,23 +88,23 @@ def filter_is_published(self, name, qs, value):
 
 class CoverFilterWithRelatedMethodFilter(FilterSet):
     comment = filters.CharFilter(name='comment')
-    post = RelatedFilter(PostFilterWithMethod, name='post')
+    post = RelatedFilter(PostFilter, name='post')
 
     class Meta:
         model = Cover
 
 
 class CoverFilterWithRelated(FilterSet):
     comment = filters.CharFilter(name='comment')
-    post = RelatedFilter(PostFilterWithRelated, name='post')
+    post = RelatedFilter(PostFilter, name='post')
 
     class Meta:
         model = Cover
 
 
 class PageFilterWithRelated(FilterSet):
     title = filters.CharFilter(name='title')
-    previous_page = RelatedFilter(PostFilterWithRelated, name='previous_page')
+    previous_page = RelatedFilter(PostFilter, name='previous_page')
 
     class Meta:
         model = Page

tests/test_filterset.py

@@ -5,24 +5,22 @@
 import datetime
 
 from django.test import TestCase, override_settings
-from django.contrib.auth.models import User
 from django.utils.dateparse import parse_time, parse_datetime
 
 from rest_framework_filters import filters
 
 from .models import (
-    Note, Post, Cover, Page, A, B, C, Person, Tag, BlogPost,
+    User, Note, Post, Cover, Page, A, B, C, Person, Tag, BlogPost,
 )
 
 from .filters import (
     NoteFilterWithAll,
-    # UserFilter,
+    UserFilter,
     # UserFilterWithAll,
     NoteFilterWithRelated,
     NoteFilterWithRelatedAll,
     NoteFilterWithRelatedAllDifferentFilterName,
-    PostFilterWithRelated,
-    PostFilterWithMethod,
+    PostFilter,
     CoverFilterWithRelatedMethodFilter,
     CoverFilterWithRelated,
     # PageFilterWithRelated,
@@ -257,7 +255,7 @@ def test_double_relation_filter(self):
         GET = {
             'note__author__username__endswith': 'user2'
         }
-        f = PostFilterWithRelated(GET, queryset=Post.objects.all())
+        f = PostFilter(GET, queryset=Post.objects.all())
         self.assertEqual(len(list(f)), 1)
         post = list(f)[0]
         self.assertEqual(post.content, "Test content in post 3")
@@ -320,17 +318,8 @@ def test_get_filterset_subset(self):
 
 class MethodFilterTests(TestCase):
 
-    if django.VERSION >= (1, 8):
-        @classmethod
-        def setUpTestData(cls):
-            cls.generateTestData()
-
-    else:
-        def setUp(self):
-            self.generateTestData()
-
     @classmethod
-    def generateTestData(cls):
+    def setUpTestData(cls):
         user = User.objects.create(username="user1", email="user1@example.org")
 
         note1 = Note.objects.create(title="Test 1", content="Test content 1", author=user)
@@ -346,7 +335,7 @@ def test_method_filter(self):
         GET = {
             'is_published': 'true'
         }
-        filterset = PostFilterWithMethod(GET, queryset=Post.objects.all())
+        filterset = PostFilter(GET, queryset=Post.objects.all())
         results = list(filterset)
         self.assertEqual(len(results), 1)
         self.assertEqual(results[0].content, "Test content in post 2")
@@ -465,6 +454,9 @@ def setUpTestData(cls):
         john = Person.objects.create(name="John")
         Person.objects.create(name="Mark", best_friend=john)
 
+        User.objects.create(username="user1", email="user1@example.org", is_active=True, last_login=datetime.date.today())
+        User.objects.create(username="user2", email="user2@example.org", is_active=False)
+
     def test_inset_number_filter(self):
         p1 = Person.objects.get(name="John").pk
         p2 = Person.objects.get(name="Mark").pk
@@ -563,6 +555,69 @@ def test_dict_declaration(self):
             filters.BooleanFilter
         )
 
+    def test_boolean_filter(self):
+        # Capitalized True
+        GET = {'is_active': 'True'}
+        filterset = UserFilter(GET, queryset=User.objects.all())
+        results = list(filterset)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].username, 'user1')
+
+        # Lowercase True
+        GET = {'is_active': 'true'}
+        filterset = UserFilter(GET, queryset=User.objects.all())
+        results = list(filterset)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].username, 'user1')
+
+        # Uppercase True
+        GET = {'is_active': 'TRUE'}
+        filterset = UserFilter(GET, queryset=User.objects.all())
+        results = list(filterset)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].username, 'user1')
+
+        # Capitalized False
+        GET = {'is_active': 'False'}
+        filterset = UserFilter(GET, queryset=User.objects.all())
+        results = list(filterset)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].username, 'user2')
+
+        # Lowercase False
+        GET = {'is_active': 'false'}
+        filterset = UserFilter(GET, queryset=User.objects.all())
+        results = list(filterset)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].username, 'user2')
+
+        # Uppercase False
+        GET = {'is_active': 'FALSE'}
+        filterset = UserFilter(GET, queryset=User.objects.all())
+        results = list(filterset)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].username, 'user2')
+
+    def test_isnull_override(self):
+        import django_filters.filters
+
+        self.assertIsInstance(
+            UserFilter().filters['last_login__isnull'],
+            django_filters.filters.BooleanFilter
+        )
+
+        GET = {'last_login__isnull': 'false'}
+        filterset = UserFilter(GET, queryset=User.objects.all())
+        results = list(filterset)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].username, 'user1')
+
+        GET = {'last_login__isnull': 'true'}
+        filterset = UserFilter(GET, queryset=User.objects.all())
+        results = list(filterset)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0].username, 'user2')
+
 
 class FilterExclusionTests(TestCase):