closes #6

Author: bckohan

django_enum/filters.py

@@ -7,9 +7,9 @@
 from django_enum.forms import EnumChoiceField
 
 try:
-    from django_filters import ChoiceFilter, Filter, filterset
+    from django_filters import Filter, TypedChoiceFilter, filterset
 
-    class EnumFilter(ChoiceFilter):
+    class EnumFilter(TypedChoiceFilter):
         """
         Use this filter class instead of ``ChoiceFilter`` to get filters to
         accept Enum labels and symmetric properties.
@@ -30,18 +30,24 @@ class Color(TextChoices, s('rgb'), s('hex', case_fold=True)):
         values: ?color=R, ?color=G, ?color=B. ``EnumFilter`` will accept query
         parameter values from any of the symmetric properties: ?color=Red,
         ?color=ff0000, etc...
+
+        :param enum: The class of the enumeration containing the values to
+            filter on
+        :param strict: If False (default), values not in the enumeration will
+            be searchable.
+        :param kwargs: Any additional arguments for base classes
         """
         field_class: FormField = EnumChoiceField
 
-        def __init__(self, *, enum, **kwargs):
+        def __init__(self, *, enum, strict=False, **kwargs):
             self.enum = enum
             super().__init__(
                 enum=enum,
                 choices=kwargs.pop('choices', self.enum.choices),
+                strict=strict,
                 **kwargs
             )
 
-
     class FilterSet(filterset.FilterSet):
         """
         Use this class instead of django-filter's ``FilterSet`` class to
@@ -56,7 +62,10 @@ def filter_for_lookup(
         ) -> Tuple[Type[Filter], dict]:
             """For EnumFields use the EnumFilter class by default"""
             if hasattr(field, 'enum') and hasattr(field.enum, 'choices'):
-                return EnumFilter, {'enum': field.enum}
+                return EnumFilter, {
+                    'enum': field.enum,
+                    'strict': getattr(field, 'strict', False)
+                }
             return super().filter_for_lookup(field, lookup_type)
 
 

django_enum/forms.py

@@ -53,6 +53,8 @@ class EnumChoiceField(TypedChoiceField):
         enumeration value. This value will be returned when any "empty" value
         is encountered. If unspecified the default empty value of '' is
         returned.
+    :param empty_values: Override the list of what are considered to be empty
+        values.
     :param strict: If False, values not included in the enumeration list, but
         of the same primitive type are acceptable.
     :param choices: Override choices, otherwise enumeration choices attribute
@@ -114,14 +116,15 @@ def __init__(
             *,
             empty_value: Any = _Unspecified,
             strict: bool = strict_,
+            empty_values: List[Any] = TypedChoiceField.empty_values,
             choices: Iterable[Tuple[Any, str]] = (),
             **kwargs
     ):
         self.strict = strict
         if not self.strict:
             kwargs.setdefault('widget', NonStrictSelect)
 
-        self.empty_values = kwargs.pop('empty_values', self.empty_values)
+        self.empty_values = empty_values
 
         super().__init__(
             choices=choices or getattr(self.enum, 'choices', choices),

django_enum/tests/tests.py

@@ -952,7 +952,7 @@ def test_field_validation(self):
         ]:
             try:
                 enum_field.clean(bad_value)
-            except ValidationError:
+            except ValidationError:  # pragma: no cover
                 self.fail(f'non-strict choice field for {enum_field.enum} raised ValidationError on {bad_value} during clean')
 
     def test_non_strict_field(self):
@@ -1303,7 +1303,7 @@ def get_enum_val(self, enum, value, null=True, coerce=True, strict=True):
                     return enum(float(value))
                 return enum(value)
         except ValueError as err:
-            if strict:
+            if strict:  # pragma: no cover
                 raise err
 
         if value not in {None, ''}:
@@ -1367,7 +1367,7 @@ def verify_form(self, obj, soup):
                             coerce=field.coerce,
                             strict=field.strict
                         )
-                    except ValueError:
+                    except ValueError:   # pragma: no cover
                         self.assertFalse(field.strict)
                         value = self.enum_primitive(field.name)(option['value'])
                     self.assertEqual(str(expected[value]), option.text)
@@ -1393,8 +1393,8 @@ def verify_form(self, obj, soup):
                 self.assertFalse(
                     null_opt,
                     f"An unexpected null option is present on {field.name}"
-                )  # pragma: no cover
-            elif field.blank:
+                )
+            elif field.blank:  # pragma: no cover
                 self.assertTrue(
                     null_opt,
                     f"Expected a null option on field {field.name}, but none was present."
@@ -1489,14 +1489,20 @@ def test_django_filter(self):
                 reverse(f'{self.NAMESPACE}:enum-filter')
             )
 
-        def do_test_django_filter(self, url):
+        def do_test_django_filter(self, url, skip_non_strict=True):
             """
             Exhaustively test query parameter permutations based on data
             created in setUp
             """
             client = Client()
             for attr, val_map in self.values.items():
                 for val, objs in val_map.items():
+                    if (
+                        skip_non_strict and not
+                        self.MODEL_CLASS._meta.get_field(attr).strict and not
+                        any([val == en for en in self.MODEL_CLASS._meta.get_field(attr).enum])
+                    ):
+                        continue
                     if val in {None, ''}:
                         # todo how to query None or empty?
                         continue
@@ -2180,7 +2186,8 @@ def field_filter_properties(self):
         if DJANGO_FILTERS_INSTALLED:
             def test_django_filter(self):
                 self.do_test_django_filter(
-                    reverse(f'{self.NAMESPACE}:enum-filter-symmetric')
+                    reverse(f'{self.NAMESPACE}:enum-filter-symmetric'),
+                    skip_non_strict=False
                 )
         else:
             pass  # pragma: no cover