starred/netbox
1
0
Fork 0
mirror of https://github.com/netbox-community/netbox.git synced 2026-04-17 06:29:53 +02:00
Code Issues 273 Packages Projects Releases 10 Wiki Activity

Closes #7604: Add filter modifier dropdowns for advanced lookup operators (#20747)

Browse Source 
* Fixes #7604: Add filter modifier dropdowns for advanced lookup operators

Implements dynamic filter modifier UI that allows users to select lookup operators
(exact, contains, starts with, regex, negation, empty/not empty) directly in filter
forms without manual URL parameter editing.

Supports filters for all scalar types and strings, as well as some
related object filters. Explicitly does not support filters on fields
that use APIWidget. That has been broken out in to follow up work.

**Backend:**
- FilterModifierWidget: Wraps form widgets with lookup modifier dropdown
- FilterModifierMixin: Auto-enhances filterset fields with appropriate lookups
- Extended lookup support: Adds negation (n), regex, iregex, empty_true/false lookups
- Field-type-aware: CharField gets text lookups, IntegerField gets comparison operators, etc.

**Frontend:**
- TypeScript handler syncs modifier dropdown with URL parameters
- Dynamically updates form field names (serial → serial__ic) on modifier change
- Flexible-width modifier dropdowns with semantic CSS classes

* Remove extraneous TS comments

* Fix import order

* Fix CircuitFilterForm inheritance

* Enable filter form modifiers on DCIM models

* Enable filter form modifiers on Tenancy models

* Enable filter form modifiers on Wireless models

* Enable filter form modifiers on IPAM models

* Enable filter form modifiers on VPN models

* Enable filter form modifiers on Virtualization models

* Enable filter form modifiers on Circuit models

* Enable filter form modifiers on Users models

* Enable filter form modifiers on Core models

* Enable filter form modifiers on Extras models

* Add ChoiceField support to FilterModifierMixin

Enable filter modifiers for single-choice ChoiceFields in addition to the
existing MultipleChoiceField support. ChoiceFields can now display modifier
dropdowns with "Is", "Is Not", "Is Empty", and "Is Not Empty" options when
the corresponding FilterSet defines those lookups.

The mixin correctly verifies lookup availability against the FilterSet, so
modifiers only appear when multiple lookup options are actually supported.
Currently most FilterSets only define 'exact' for single-choice fields, but
this change enables future FilterSet enhancements to expose additional
lookups for ChoiceFields.

* Address PR feedback: Replace global filterset mappings with registry

* Address PR feedback: Move FilterModifierMixin into base filter form classes

Incorporates FilterModifierMixin into NetBoxModelFilterSetForm and FilterForm,
making filter modifiers automatic for all filter forms throughout the application.

* Fix filter modifier form submission bug with 'action' field collision

Forms with a field named "action" (e.g., ObjectChangeFilterForm) were causing
the form.action property to be shadowed by the field element, resulting in
[object HTMLSelectElement] appearing in the URL path.

Use form.getAttribute('action') instead of form.action to reliably retrieve
the form's action URL without collision from form fields.

Fixes form submission on /core/changelog/ and any other forms with an 'action'
field using filter modifiers.

* Address PR feedback: Move FORM_FIELD_LOOKUPS to module-level constant

Extracts the field type to lookup mappings from FilterModifierMixin class
attribute to a module-level constant for better reusability.

* Address PR feedback: Refactor and consolidate field filtering logic

Consolidated field enhancement logic in FilterModifierMixin by:
- Creating QueryField marker type (CharField subclass) for search fields
- Updating FilterForm and NetBoxModelFilterSetForm to use QueryField for 'q'
- Moving all skip logic into _get_lookup_choices() to return empty list for
  fields that shouldn't be enhanced
- Removing separate _should_skip_field() method
- Removing unused field_name parameter from _get_lookup_choices()
- Replacing hardcoded field name check ('q') with type-based detection

* Address PR feedback: Refactor applied_filters to use FORM_FIELD_LOOKUPS

* Address PR feedback: Rename FilterModifierWidget parameter to widget

* Fix registry pattern to use model identifiers as keys

Changed filterset registration to use model identifiers ('{app_label}.{model_name}')
as registry keys instead of form classes, matching NetBox's pattern for search indexes.

* Address PR feedback: refactor brittle test for APISelect useage

Now checks if widget is actually APISelect, rather than trying to infer
from the class name.

* Refactor register_filterset to be more generic and simple

* Remove unneeded imports left from earlier registry work

* Update app registry for new `filtersets` store

* Remove unused star import, leftover from earlier work

* Enables filter modifiers on APISelect based fields

* Support filter modifiers for ChoiceField

* Include MODIFIER_EMPTY_FALSE/_TRUE in __all__

Co-authored-by: Jeremy Stretch <jstretch@netboxlabs.com>

* Fix filterset registration for doubly-registered models

* Removed explicit checks against QueryField and [Null]BooleanField

I did add them to FORM_FIELD_LOOKUPS, though, to underscore that they
were considered and are intentially empty for future devs.

* Switch to sentence case for filter pill text

* Fix applied_filters template tag to use field-type-specific lookup labelsresolves

E.g. resolves gt="after" for dates vs "greater than" for numbers

* Verifies that filter pills for exact matches (no lookup
Add test for exact lookup filter pill rendering

* Add guard for FilterModifierWidget with no lookups

* Remove comparison symbols from numeric filter labels

* Match complete tags in widget rendering test assertions

* Check all expected lookups in field enhancement tests

* Move register_filterset to netbox.plugins.registration

* Require registered filterset for filter modifier enhancements

Updates FilterModifierMixin to only enhance form fields when the
associated model has a registered filterset. This provides plugin
safety by ensuring unregistered plugin filtersets fall back to
simple filters without lookup modifiers.

Test changes:
- Create TestModel and TestFilterSet using BaseFilterSet for
automatic lookup generation
- Import dcim.filtersets to ensure Device filterset registration
- Adjust tag field expectations to match actual Device filterset
(has exact/n but not empty lookups)

* Attempt to resolve static conflicts

* Move register_filterset() back to utilities.filtersets

* Add register_filterset() to plugins documentation for filtersets

* Reorder import statements

---------

Co-authored-by: Jeremy Stretch <jstretch@netboxlabs.com>
This commit is contained in:
Jason Novinger
2025-12-05 14:13:37 -06:00
committed by GitHub
parent 20c260b126
commit 7eefb07554
33 changed files with 1023 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
netbox/utilities/filtersets.py Normal file
View File

@@ -0,0 +1,17 @@
from netbox.registry import registry
__all__ = (
'register_filterset',
)
def register_filterset(filterset_class):
"""
Decorator for registering a FilterSet with the application registry.
Uses model identifier as key to match search index pattern.
"""
model = filterset_class._meta.model
label = f'{model._meta.app_label}.{model._meta.model_name}'
registry['filtersets'][label] = filterset_class
return filterset_class

9
netbox/utilities/forms/fields/fields.py
View File

@@ -17,11 +17,20 @@ __all__ = (
'JSONField',
'LaxURLField',
'MACAddressField',
'QueryField',
'SlugField',
'TagFilterField',
)
class QueryField(forms.CharField):
"""
A CharField subclass used for global search/query fields in filter forms.
This field type signals to FilterModifierMixin to skip enhancement with lookup modifiers.
"""
pass
class CommentField(forms.CharField):
"""
A textarea with support for Markdown rendering. Exists mostly just to add a standard `help_text`.

7
netbox/utilities/forms/forms.py
View File

@@ -4,7 +4,8 @@ from django import forms
from django.utils.translation import gettext as _
from netbox.models.features import ChangeLoggingMixin
from utilities.forms.mixins import BackgroundJobMixin
from utilities.forms.fields import QueryField
from utilities.forms.mixins import BackgroundJobMixin, FilterModifierMixin
__all__ = (
'BulkDeleteForm',
@@ -140,11 +141,11 @@ class CSVModelForm(forms.ModelForm):
return super().clean()
class FilterForm(forms.Form):
class FilterForm(FilterModifierMixin, forms.Form):
"""
Base Form class for FilterSet forms.
"""
q = forms.CharField(
q = QueryField(
required=False,
label=_('Search')
)

152
netbox/utilities/forms/mixins.py
View File

@@ -5,13 +5,100 @@ from django import forms
from django.core.validators import MaxValueValidator, MinValueValidator
from django.utils.translation import gettext_lazy as _
from netbox.registry import registry
from utilities.forms.fields import ColorField, QueryField, TagFilterField
from utilities.forms.widgets import FilterModifierWidget
from utilities.forms.widgets.modifiers import MODIFIER_EMPTY_FALSE, MODIFIER_EMPTY_TRUE
__all__ = (
'BackgroundJobMixin',
'CheckLastUpdatedMixin',
'DistanceValidationMixin',
'FilterModifierMixin',
'FORM_FIELD_LOOKUPS',
)
# Mapping of form field types to their supported lookups
FORM_FIELD_LOOKUPS = {
QueryField: [],
forms.BooleanField: [],
forms.NullBooleanField: [],
forms.CharField: [
('exact', _('is')),
('n', _('is not')),
('ic', _('contains')),
('isw', _('starts with')),
('iew', _('ends with')),
('ie', _('equals (case-insensitive)')),
('regex', _('matches pattern')),
('iregex', _('matches pattern (case-insensitive)')),
(MODIFIER_EMPTY_TRUE, _('is empty')),
(MODIFIER_EMPTY_FALSE, _('is not empty')),
],
forms.IntegerField: [
('exact', _('is')),
('n', _('is not')),
('gt', _('greater than')),
('gte', _('at least')),
('lt', _('less than')),
('lte', _('at most')),
(MODIFIER_EMPTY_TRUE, _('is empty')),
(MODIFIER_EMPTY_FALSE, _('is not empty')),
],
forms.DecimalField: [
('exact', _('is')),
('n', _('is not')),
('gt', _('greater than')),
('gte', _('at least')),
('lt', _('less than')),
('lte', _('at most')),
(MODIFIER_EMPTY_TRUE, _('is empty')),
(MODIFIER_EMPTY_FALSE, _('is not empty')),
],
forms.DateField: [
('exact', _('is')),
('n', _('is not')),
('gt', _('after')),
('gte', _('on or after')),
('lt', _('before')),
('lte', _('on or before')),
(MODIFIER_EMPTY_TRUE, _('is empty')),
(MODIFIER_EMPTY_FALSE, _('is not empty')),
],
forms.ModelChoiceField: [
('exact', _('is')),
('n', _('is not')),
(MODIFIER_EMPTY_TRUE, _('is empty')),
(MODIFIER_EMPTY_FALSE, _('is not empty')),
],
ColorField: [
('exact', _('is')),
('n', _('is not')),
(MODIFIER_EMPTY_TRUE, _('is empty')),
(MODIFIER_EMPTY_FALSE, _('is not empty')),
],
TagFilterField: [
('exact', _('has these tags')),
('n', _('does not have these tags')),
(MODIFIER_EMPTY_TRUE, _('is empty')),
(MODIFIER_EMPTY_FALSE, _('is not empty')),
],
forms.ChoiceField: [
('exact', _('is')),
('n', _('is not')),
(MODIFIER_EMPTY_TRUE, _('is empty')),
(MODIFIER_EMPTY_FALSE, _('is not empty')),
],
forms.MultipleChoiceField: [
('exact', _('is')),
('n', _('is not')),
(MODIFIER_EMPTY_TRUE, _('is empty')),
(MODIFIER_EMPTY_FALSE, _('is not empty')),
],
}
class BackgroundJobMixin(forms.Form):
background_job = forms.BooleanField(
label=_('Background job'),
@@ -75,3 +162,68 @@ class DistanceValidationMixin(forms.Form):
MaxValueValidator(Decimal(100000)),
]
)
class FilterModifierMixin:
"""
Mixin that enhances filter form fields with lookup modifier dropdowns.
Automatically detects fields that could benefit from multiple lookup options
and wraps their widgets with FilterModifierWidget.
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._enhance_fields_with_modifiers()
def _enhance_fields_with_modifiers(self):
"""Wrap compatible field widgets with FilterModifierWidget."""
model = getattr(self, 'model', None)
if model is None and hasattr(self, '_meta'):
model = getattr(self._meta, 'model', None)
filterset_class = None
if model:
key = f'{model._meta.app_label}.{model._meta.model_name}'
filterset_class = registry['filtersets'].get(key)
filterset = filterset_class() if filterset_class else None
for field_name, field in self.fields.items():
lookups = self._get_lookup_choices(field)
if filterset:
lookups = self._verify_lookups_with_filterset(field_name, lookups, filterset)
if len(lookups) > 1:
field.widget = FilterModifierWidget(
widget=field.widget,
lookups=lookups
)
def _get_lookup_choices(self, field):
"""Determine the available lookup choices for a given field.
Returns an empty list for fields that should not be enhanced.
"""
for field_class in field.__class__.__mro__:
if field_lookups := FORM_FIELD_LOOKUPS.get(field_class):
return field_lookups
return []
def _verify_lookups_with_filterset(self, field_name, lookups, filterset):
"""Verify which lookups are actually supported by the FilterSet."""
verified_lookups = []
for lookup_code, lookup_label in lookups:
if lookup_code in (MODIFIER_EMPTY_TRUE, MODIFIER_EMPTY_FALSE):
filter_key = f'{field_name}__empty'
else:
filter_key = f'{field_name}__{lookup_code}' if lookup_code != 'exact' else field_name
if filter_key in filterset.filters:
verified_lookups.append((lookup_code, lookup_label))
return verified_lookups

1
netbox/utilities/forms/widgets/__init__.py
View File

@@ -1,4 +1,5 @@
from .apiselect import *
from .datetime import *
from .misc import *
from .modifiers import *
from .select import *

113
netbox/utilities/forms/widgets/modifiers.py Normal file
View File

@@ -0,0 +1,113 @@
from django import forms
from django.utils.translation import gettext_lazy as _
__all__ = (
'FilterModifierWidget',
'MODIFIER_EMPTY_FALSE',
'MODIFIER_EMPTY_TRUE',
)
# Modifier codes for empty/null checking
# These map to Django's 'empty' lookup: field__empty=true/false
MODIFIER_EMPTY_TRUE = 'empty_true'
MODIFIER_EMPTY_FALSE = 'empty_false'
class FilterModifierWidget(forms.Widget):
"""
Wraps an existing widget to add a modifier dropdown for filter lookups.
The original widget's semantics (name, id, attributes) are preserved.
The modifier dropdown controls which lookup type is used (exact, contains, etc.).
"""
template_name = 'widgets/filter_modifier.html'
def __init__(self, widget, lookups, attrs=None):
"""
Args:
widget: The widget being wrapped (e.g., TextInput, NumberInput)
lookups: List of (lookup_code, label) tuples (e.g., [('exact', 'Is'), ('ic', 'Contains')])
attrs: Additional widget attributes
"""
self.original_widget = widget
self.lookups = lookups
super().__init__(attrs or getattr(widget, 'attrs', {}))
def value_from_datadict(self, data, files, name):
"""
Extract value from data, checking all possible lookup variants.
When form redisplays after validation error, the data may contain
serial__ic=test but the field is named serial. This method searches
all lookup variants to find the value.
Returns:
Just the value string for form validation. The modifier is reconstructed
during rendering from the query parameter names.
"""
# Special handling for empty - check if field__empty exists
empty_param = f"{name}__empty"
if empty_param in data:
# Return the boolean value for empty lookup
return data.get(empty_param)
# Try exact field name first
value = self.original_widget.value_from_datadict(data, files, name)
# If not found, check all modifier variants
# Note: SelectMultiple returns [] (empty list) when not found, not None
if value is None or (isinstance(value, list) and len(value) == 0):
for lookup, _ in self.lookups:
if lookup == 'exact':
continue # Already checked above
# Skip empty_true/false variants - they're handled above
if lookup in (MODIFIER_EMPTY_TRUE, MODIFIER_EMPTY_FALSE):
continue
lookup_name = f"{name}__{lookup}"
test_value = self.original_widget.value_from_datadict(data, files, lookup_name)
if test_value is not None:
value = test_value
break
# Return None if no value found (prevents field appearing in changed_data)
# Handle all widget empty value representations
if value is None:
return None
if isinstance(value, str) and not value.strip():
return None
if isinstance(value, (list, tuple)) and len(value) == 0:
return None
# Return just the value for form validation
return value
def get_context(self, name, value, attrs):
"""
Build context for template rendering.
Includes both the original widget's context and our modifier-specific data.
Note: value is now just a simple value (string/int/etc), not a dict.
The JavaScript initializeFromURL() will set the correct modifier dropdown
value based on URL parameters.
"""
# Propagate any attrs set on the wrapper (like data-url from get_bound_field)
# to the original widget before rendering
self.original_widget.attrs.update(self.attrs)
# Get context from the original widget
original_context = self.original_widget.get_context(name, value, attrs)
# Build our wrapper context
context = super().get_context(name, value, attrs)
context['widget']['original_widget'] = original_context['widget']
context['widget']['lookups'] = self.lookups
context['widget']['field_name'] = name
# Default to 'exact' - JavaScript will update based on URL params
context['widget']['current_modifier'] = 'exact'
context['widget']['current_value'] = value or ''
# Translatable placeholder for empty lookups
context['widget']['empty_placeholder'] = _('(automatically set)')
return context

18
netbox/utilities/templates/widgets/filter_modifier.html Normal file
View File

@@ -0,0 +1,18 @@
<div class="d-flex filter-modifier-group">
{% if widget.lookups %}
{# Modifier dropdown - NO name attribute, just a UI control #}
<select class="form-select modifier-select"
data-field="{{ widget.field_name }}"
data-empty-placeholder="{{ widget.empty_placeholder }}"
aria-label="Modifier">
{% for lookup, label in widget.lookups %}
<option value="{{ lookup }}"{% if widget.current_modifier == lookup %} selected{% endif %}>{{ label }}</option>
{% endfor %}
</select>
{% endif %}
{# Original widget - rendered exactly as it would be without our wrapper #}
<div class="ms-2 flex-grow-1 filter-value-container">
{% include widget.original_widget.template_name with widget=widget.original_widget %}
</div>
</div>

57
netbox/utilities/templatetags/helpers.py
View File

@@ -5,9 +5,11 @@ from urllib.parse import quote
from django import template
from django.urls import NoReverseMatch, reverse
from django.utils.html import conditional_escape
from django.utils.translation import gettext_lazy as _
from core.models import ObjectType
from utilities.forms import get_selected_values, TableConfigForm
from utilities.forms.mixins import FORM_FIELD_LOOKUPS
from utilities.views import get_viewname, get_action_url
from netbox.settings import DISK_BASE_UNIT, RAM_BASE_UNIT
@@ -418,7 +420,20 @@ def applied_filters(context, model, form, query_params):
continue
querydict = query_params.copy()
if filter_name not in querydict:
# Check if this is a modifier-enhanced field
# Field may be in querydict as field__lookup instead of field
param_name = None
if filter_name in querydict:
param_name = filter_name
else:
# Check for modifier variants (field__ic, field__isw, etc.)
for key in querydict.keys():
if key.startswith(f'{filter_name}__'):
param_name = key
break
if param_name is None:
continue
# Skip saved filters, as they're displayed alongside the quick search widget
@@ -426,14 +441,46 @@ def applied_filters(context, model, form, query_params):
continue
bound_field = form.fields[filter_name].get_bound_field(form, filter_name)
querydict.pop(filter_name)
querydict.pop(param_name)
# Extract modifier from parameter name (e.g., "serial__ic" → "ic")
if '__' in param_name:
modifier = param_name.split('__', 1)[1]
else:
modifier = 'exact'
# Get display value
display_value = ', '.join([str(v) for v in get_selected_values(form, filter_name)])
# Get the correct lookup label for this field's type
lookup_label = None
if modifier != 'exact':
field = form.fields[filter_name]
for field_class in field.__class__.__mro__:
if field_lookups := FORM_FIELD_LOOKUPS.get(field_class):
for lookup_code, label in field_lookups:
if lookup_code == modifier:
lookup_label = label
break
if lookup_label:
break
# Special handling for empty lookup (boolean value)
if modifier == 'empty':
if display_value.lower() in ('true', '1'):
link_text = f'{bound_field.label} {_("is empty")}'
else:
link_text = f'{bound_field.label} {_("is not empty")}'
elif lookup_label:
link_text = f'{bound_field.label} {lookup_label}: {display_value}'
else:
link_text = f'{bound_field.label}: {display_value}'
applied_filters.append({
'name': filter_name,
'value': form.cleaned_data[filter_name],
'name': param_name, # Use actual param name for removal link
'value': form.cleaned_data.get(filter_name),
'link_url': f'?{querydict.urlencode()}',
'link_text': f'{bound_field.label}: {display_value}',
'link_text': link_text,
})
save_link = None

293
netbox/utilities/tests/test_filter_modifiers.py Normal file
View File

@@ -0,0 +1,293 @@
from django import forms
from django.db import models
from django.http import QueryDict
from django.template import Context
from django.test import RequestFactory, TestCase
import dcim.filtersets # noqa: F401 - Import to register Device filterset
from dcim.forms.filtersets import DeviceFilterForm
from dcim.models import Device
from netbox.filtersets import BaseFilterSet
from utilities.filtersets import register_filterset
from users.models import User
from utilities.forms.fields import TagFilterField
from utilities.forms.mixins import FilterModifierMixin
from utilities.forms.widgets import FilterModifierWidget
from utilities.templatetags.helpers import applied_filters
# Test model for FilterModifierMixin tests
class TestModel(models.Model):
"""Dummy model for testing filter modifiers."""
char_field = models.CharField(max_length=100, blank=True)
integer_field = models.IntegerField(null=True, blank=True)
decimal_field = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
date_field = models.DateField(null=True, blank=True)
boolean_field = models.BooleanField(default=False)
class Meta:
app_label = 'utilities'
managed = False # Don't create actual database table
# Test filterset using BaseFilterSet to automatically generate lookups
@register_filterset
class TestFilterSet(BaseFilterSet):
class Meta:
model = TestModel
fields = ['char_field', 'integer_field', 'decimal_field', 'date_field', 'boolean_field']
class FilterModifierWidgetTest(TestCase):
"""Tests for FilterModifierWidget value extraction and rendering."""
def test_value_from_datadict_finds_value_in_lookup_variant(self):
"""
Widget should find value from serial__ic when field is named serial.
This is critical for form redisplay after validation errors.
"""
widget = FilterModifierWidget(
widget=forms.TextInput(),
lookups=[('exact', 'Is'), ('ic', 'Contains'), ('isw', 'Starts With')]
)
data = QueryDict('serial__ic=test123')
result = widget.value_from_datadict(data, {}, 'serial')
self.assertEqual(result, 'test123')
def test_value_from_datadict_handles_exact_match(self):
"""Widget should detect exact match when field name has no modifier."""
widget = FilterModifierWidget(
widget=forms.TextInput(),
lookups=[('exact', 'Is'), ('ic', 'Contains')]
)
data = QueryDict('serial=test456')
result = widget.value_from_datadict(data, {}, 'serial')
self.assertEqual(result, 'test456')
def test_value_from_datadict_returns_none_when_no_value(self):
"""Widget should return None when no data present to avoid appearing in changed_data."""
widget = FilterModifierWidget(
widget=forms.TextInput(),
lookups=[('exact', 'Is'), ('ic', 'Contains')]
)
data = QueryDict('')
result = widget.value_from_datadict(data, {}, 'serial')
self.assertIsNone(result)
def test_get_context_includes_original_widget_and_lookups(self):
"""Widget context should include original widget context and lookup choices."""
widget = FilterModifierWidget(
widget=forms.TextInput(),
lookups=[('exact', 'Is'), ('ic', 'Contains'), ('isw', 'Starts With')]
)
value = 'test'
context = widget.get_context('serial', value, {})
self.assertIn('original_widget', context['widget'])
self.assertEqual(
context['widget']['lookups'],
[('exact', 'Is'), ('ic', 'Contains'), ('isw', 'Starts With')]
)
self.assertEqual(context['widget']['field_name'], 'serial')
self.assertEqual(context['widget']['current_modifier'], 'exact') # Defaults to exact, JS updates from URL
self.assertEqual(context['widget']['current_value'], 'test')
def test_widget_renders_modifier_dropdown_and_input(self):
"""Widget should render modifier dropdown alongside original input."""
widget = FilterModifierWidget(
widget=forms.TextInput(),
lookups=[('exact', 'Is'), ('ic', 'Contains')]
)
html = widget.render('serial', 'test', {})
# Should contain modifier dropdown
self.assertIn('class="form-select modifier-select"', html)
self.assertIn('data-field="serial"', html)
self.assertIn('<option value="exact" selected>Is</option>', html)
self.assertIn('<option value="ic">Contains</option>', html)
# Should contain original input
self.assertIn('type="text"', html)
self.assertIn('name="serial"', html)
self.assertIn('value="test"', html)
class FilterModifierMixinTest(TestCase):
"""Tests for FilterModifierMixin form field enhancement."""
def test_mixin_enhances_char_field_with_modifiers(self):
"""CharField should be enhanced with contains/starts/ends modifiers."""
class TestForm(FilterModifierMixin, forms.Form):
char_field = forms.CharField(required=False)
model = TestModel
form = TestForm()
self.assertIsInstance(form.fields['char_field'].widget, FilterModifierWidget)
lookup_codes = [lookup[0] for lookup in form.fields['char_field'].widget.lookups]
expected_lookups = ['exact', 'n', 'ic', 'isw', 'iew', 'ie', 'regex', 'iregex', 'empty_true', 'empty_false']
self.assertEqual(lookup_codes, expected_lookups)
def test_mixin_skips_boolean_fields(self):
"""Boolean fields should not be enhanced."""
class TestForm(FilterModifierMixin, forms.Form):
boolean_field = forms.BooleanField(required=False)
model = TestModel
form = TestForm()
self.assertNotIsInstance(form.fields['boolean_field'].widget, FilterModifierWidget)
def test_mixin_enhances_tag_filter_field(self):
"""TagFilterField should be enhanced even though it's a MultipleChoiceField."""
class TestForm(FilterModifierMixin, forms.Form):
tag = TagFilterField(Device)
model = Device
form = TestForm()
self.assertIsInstance(form.fields['tag'].widget, FilterModifierWidget)
tag_lookups = [lookup[0] for lookup in form.fields['tag'].widget.lookups]
# Device filterset has tag and tag__n but not tag__empty
expected_lookups = ['exact', 'n']
self.assertEqual(tag_lookups, expected_lookups)
def test_mixin_enhances_integer_field(self):
"""IntegerField should be enhanced with comparison modifiers."""
class TestForm(FilterModifierMixin, forms.Form):
integer_field = forms.IntegerField(required=False)
model = TestModel
form = TestForm()
self.assertIsInstance(form.fields['integer_field'].widget, FilterModifierWidget)
lookup_codes = [lookup[0] for lookup in form.fields['integer_field'].widget.lookups]
expected_lookups = ['exact', 'n', 'gt', 'gte', 'lt', 'lte', 'empty_true', 'empty_false']
self.assertEqual(lookup_codes, expected_lookups)
def test_mixin_enhances_decimal_field(self):
"""DecimalField should be enhanced with comparison modifiers."""
class TestForm(FilterModifierMixin, forms.Form):
decimal_field = forms.DecimalField(required=False)
model = TestModel
form = TestForm()
self.assertIsInstance(form.fields['decimal_field'].widget, FilterModifierWidget)
lookup_codes = [lookup[0] for lookup in form.fields['decimal_field'].widget.lookups]
expected_lookups = ['exact', 'n', 'gt', 'gte', 'lt', 'lte', 'empty_true', 'empty_false']
self.assertEqual(lookup_codes, expected_lookups)
def test_mixin_enhances_date_field(self):
"""DateField should be enhanced with date-appropriate modifiers."""
class TestForm(FilterModifierMixin, forms.Form):
date_field = forms.DateField(required=False)
model = TestModel
form = TestForm()
self.assertIsInstance(form.fields['date_field'].widget, FilterModifierWidget)
lookup_codes = [lookup[0] for lookup in form.fields['date_field'].widget.lookups]
expected_lookups = ['exact', 'n', 'gt', 'gte', 'lt', 'lte', 'empty_true', 'empty_false']
self.assertEqual(lookup_codes, expected_lookups)
class ExtendedLookupFilterPillsTest(TestCase):
"""Tests for filter pill rendering of extended lookups."""
@classmethod
def setUpTestData(cls):
cls.user = User.objects.create(username='test_user')
def test_negation_lookup_filter_pill(self):
"""Filter pill should show 'is not' for negation lookup."""
query_params = QueryDict('serial__n=ABC123')
form = DeviceFilterForm(query_params)
request = RequestFactory().get('/', query_params)
request.user = self.user
context = Context({'request': request})
result = applied_filters(context, Device, form, query_params)
self.assertGreater(len(result['applied_filters']), 0)
filter_pill = result['applied_filters'][0]
self.assertIn('is not', filter_pill['link_text'].lower())
self.assertIn('ABC123', filter_pill['link_text'])
def test_regex_lookup_filter_pill(self):
"""Filter pill should show 'matches pattern' for regex lookup."""
query_params = QueryDict('serial__regex=^ABC.*')
form = DeviceFilterForm(query_params)
request = RequestFactory().get('/', query_params)
request.user = self.user
context = Context({'request': request})
result = applied_filters(context, Device, form, query_params)
self.assertGreater(len(result['applied_filters']), 0)
filter_pill = result['applied_filters'][0]
self.assertIn('matches pattern', filter_pill['link_text'].lower())
def test_exact_lookup_filter_pill(self):
"""Filter pill should show field label and value without lookup modifier for exact match."""
query_params = QueryDict('serial=ABC123')
form = DeviceFilterForm(query_params)
request = RequestFactory().get('/', query_params)
request.user = self.user
context = Context({'request': request})
result = applied_filters(context, Device, form, query_params)
self.assertGreater(len(result['applied_filters']), 0)
filter_pill = result['applied_filters'][0]
# Should not contain lookup modifier text
self.assertNotIn('is not', filter_pill['link_text'].lower())
self.assertNotIn('matches pattern', filter_pill['link_text'].lower())
self.assertNotIn('contains', filter_pill['link_text'].lower())
# Should contain field label and value
self.assertIn('Serial', filter_pill['link_text'])
self.assertIn('ABC123', filter_pill['link_text'])
class EmptyLookupTest(TestCase):
"""Tests for empty (is empty/not empty) lookup support."""
@classmethod
def setUpTestData(cls):
cls.user = User.objects.create(username='test_user')
def test_empty_true_appears_in_filter_pills(self):
"""Filter pill should show 'Is Empty' for empty=true."""
query_params = QueryDict('serial__empty=true')
form = DeviceFilterForm(query_params)
request = RequestFactory().get('/', query_params)
request.user = self.user
context = Context({'request': request})
result = applied_filters(context, Device, form, query_params)
self.assertGreater(len(result['applied_filters']), 0)
filter_pill = result['applied_filters'][0]
self.assertIn('empty', filter_pill['link_text'].lower())
def test_empty_false_appears_in_filter_pills(self):
"""Filter pill should show 'Is Not Empty' for empty=false."""
query_params = QueryDict('serial__empty=false')
form = DeviceFilterForm(query_params)
request = RequestFactory().get('/', query_params)
request.user = self.user
context = Context({'request': request})
result = applied_filters(context, Device, form, query_params)
self.assertGreater(len(result['applied_filters']), 0)
filter_pill = result['applied_filters'][0]
self.assertIn('not empty', filter_pill['link_text'].lower())