Standardize usage of self.filterset for test cases

netbox/circuits/tests/test_filters.py

@@ -8,6 +8,7 @@ from dcim.models import Region, Site
 
 class ProviderTestCase(TestCase):
     queryset = Provider.objects.all()
+    filterset = ProviderFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -54,42 +55,43 @@ class ProviderTestCase(TestCase):
 
     def test_name(self):
         params = {'name': ['Provider 1', 'Provider 2']}
-        self.assertEqual(ProviderFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_slug(self):
         params = {'slug': ['provider-1', 'provider-2']}
-        self.assertEqual(ProviderFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_asn(self):
         params = {'asn': ['65001', '65002']}
-        self.assertEqual(ProviderFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_account(self):
         params = {'account': ['1234', '2345']}
-        self.assertEqual(ProviderFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_id__in(self):
         id_list = self.queryset.values_list('id', flat=True)[:3]
         params = {'id__in': ','.join([str(id) for id in id_list])}
-        self.assertEqual(ProviderFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
     def test_site(self):
         sites = Site.objects.all()[:2]
         params = {'site_id': [sites[0].pk, sites[1].pk]}
-        self.assertEqual(ProviderFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'site': [sites[0].slug, sites[1].slug]}
-        self.assertEqual(ProviderFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_region(self):
         regions = Region.objects.all()[:2]
         params = {'region_id': [regions[0].pk, regions[1].pk]}
-        self.assertEqual(ProviderFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'region': [regions[0].slug, regions[1].slug]}
-        self.assertEqual(ProviderFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
 
 class CircuitTypeTestCase(TestCase):
     queryset = CircuitType.objects.all()
+    filterset = CircuitTypeFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -102,19 +104,20 @@ class CircuitTypeTestCase(TestCase):
 
     def test_id(self):
         params = {'id': [self.queryset.first().pk]}
-        self.assertEqual(CircuitTypeFilter(params, self.queryset).qs.count(), 1)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
     def test_name(self):
         params = {'name': ['Circuit Type 1']}
-        self.assertEqual(CircuitTypeFilter(params, self.queryset).qs.count(), 1)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
     def test_slug(self):
         params = {'slug': ['circuit-type-1']}
-        self.assertEqual(CircuitTypeFilter(params, self.queryset).qs.count(), 1)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
 
 class CircuitTestCase(TestCase):
     queryset = Circuit.objects.all()
+    filterset = CircuitFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -166,56 +169,57 @@ class CircuitTestCase(TestCase):
 
     def test_cid(self):
         params = {'cid': ['Test Circuit 1', 'Test Circuit 2']}
-        self.assertEqual(CircuitFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_install_date(self):
         params = {'install_date': ['2020-01-01', '2020-01-02']}
-        self.assertEqual(CircuitFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_commit_rate(self):
         params = {'commit_rate': ['1000', '2000']}
-        self.assertEqual(CircuitFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_id__in(self):
         id_list = self.queryset.values_list('id', flat=True)[:3]
         params = {'id__in': ','.join([str(id) for id in id_list])}
-        self.assertEqual(CircuitFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
     def test_provider(self):
         provider = Provider.objects.first()
         params = {'provider_id': [provider.pk]}
-        self.assertEqual(CircuitFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
         params = {'provider': [provider.slug]}
-        self.assertEqual(CircuitFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
     def test_type(self):
         circuit_type = CircuitType.objects.first()
         params = {'type_id': [circuit_type.pk]}
-        self.assertEqual(CircuitFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
         params = {'type': [circuit_type.slug]}
-        self.assertEqual(CircuitFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
     def test_status(self):
         params = {'status': [CIRCUIT_STATUS_ACTIVE, CIRCUIT_STATUS_PLANNED]}
-        self.assertEqual(CircuitFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_region(self):
         regions = Region.objects.all()[:2]
         params = {'region_id': [regions[0].pk, regions[1].pk]}
-        self.assertEqual(CircuitFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'region': [regions[0].slug, regions[1].slug]}
-        self.assertEqual(CircuitFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_site(self):
         sites = Site.objects.all()[:2]
         params = {'site_id': [sites[0].pk, sites[1].pk]}
-        self.assertEqual(CircuitFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'site': [sites[0].slug, sites[1].slug]}
-        self.assertEqual(CircuitFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
 
 class CircuitTerminationTestCase(TestCase):
     queryset = CircuitTermination.objects.all()
+    filterset = CircuitTerminationFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -256,28 +260,28 @@ class CircuitTerminationTestCase(TestCase):
 
     def test_term_side(self):
         params = {'term_side': 'A'}
-        self.assertEqual(CircuitTerminationFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
     def test_port_speed(self):
         params = {'port_speed': ['1000', '2000']}
-        self.assertEqual(CircuitTerminationFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_upstream_speed(self):
         params = {'upstream_speed': ['1000', '2000']}
-        self.assertEqual(CircuitTerminationFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_xconnect_id(self):
         params = {'xconnect_id': ['ABC', 'DEF']}
-        self.assertEqual(CircuitTerminationFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_circuit_id(self):
         circuits = Circuit.objects.all()[:2]
         params = {'circuit_id': [circuits[0].pk, circuits[1].pk]}
-        self.assertEqual(CircuitTerminationFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_site(self):
         sites = Site.objects.all()[:2]
         params = {'site_id': [sites[0].pk, sites[1].pk]}
-        self.assertEqual(CircuitTerminationFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
         params = {'site': [sites[0].slug, sites[1].slug]}
-        self.assertEqual(CircuitTerminationFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)

netbox/ipam/tests/test_filters.py

@@ -2,16 +2,14 @@ from django.test import TestCase
 
 from dcim.models import Device, DeviceRole, DeviceType, Interface, Manufacturer, Region, Site
 from ipam.constants import *
-from ipam.filters import (
-    AggregateFilter, IPAddressFilter, PrefixFilter, RIRFilter, RoleFilter, ServiceFilter, VLANFilter, VLANGroupFilter,
-    VRFFilter,
-)
+from ipam.filters import *
 from ipam.models import Aggregate, IPAddress, Prefix, RIR, Role, Service, VLAN, VLANGroup, VRF
 from virtualization.models import Cluster, ClusterType, VirtualMachine
 
 
 class VRFTestCase(TestCase):
     queryset = VRF.objects.all()
+    filterset = VRFFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -28,26 +26,27 @@ class VRFTestCase(TestCase):
 
     def test_name(self):
         params = {'name': ['VRF 1', 'VRF 2']}
-        self.assertEqual(VRFFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_rd(self):
         params = {'rd': ['65000:100', '65000:200']}
-        self.assertEqual(VRFFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_enforce_unique(self):
         params = {'enforce_unique': 'true'}
-        self.assertEqual(VRFFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
         params = {'enforce_unique': 'false'}
-        self.assertEqual(VRFFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
     def test_id__in(self):
         id_list = self.queryset.values_list('id', flat=True)[:3]
         params = {'id__in': ','.join([str(id) for id in id_list])}
-        self.assertEqual(VRFFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
 
 class RIRTestCase(TestCase):
     queryset = RIR.objects.all()
+    filterset = RIRFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -64,26 +63,27 @@ class RIRTestCase(TestCase):
 
     def test_name(self):
         params = {'name': ['RIR 1', 'RIR 2']}
-        self.assertEqual(RIRFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_slug(self):
         params = {'slug': ['rir-1', 'rir-2']}
-        self.assertEqual(RIRFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_is_private(self):
         params = {'is_private': 'true'}
-        self.assertEqual(RIRFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
         params = {'is_private': 'false'}
-        self.assertEqual(RIRFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
     def test_id__in(self):
         id_list = self.queryset.values_list('id', flat=True)[:3]
         params = {'id__in': ','.join([str(id) for id in id_list])}
-        self.assertEqual(RIRFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
 
 class AggregateTestCase(TestCase):
     queryset = Aggregate.objects.all()
+    filterset = AggregateFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -107,27 +107,28 @@ class AggregateTestCase(TestCase):
 
     def test_family(self):
         params = {'family': '4'}
-        self.assertEqual(AggregateFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
     def test_date_added(self):
         params = {'date_added': ['2020-01-01', '2020-01-02']}
-        self.assertEqual(AggregateFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     # TODO: Test for multiple values
     def test_prefix(self):
         params = {'prefix': '10.1.0.0/16'}
-        self.assertEqual(AggregateFilter(params, self.queryset).qs.count(), 1)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
     def test_rir(self):
         rirs = RIR.objects.all()[:2]
         params = {'rir_id': [rirs[0].pk, rirs[1].pk]}
-        self.assertEqual(AggregateFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
         params = {'rir': [rirs[0].slug, rirs[1].slug]}
-        self.assertEqual(AggregateFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
 
 class RoleTestCase(TestCase):
     queryset = Role.objects.all()
+    filterset = RoleFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -142,19 +143,20 @@ class RoleTestCase(TestCase):
     def test_id(self):
         id_list = self.queryset.values_list('id', flat=True)[:2]
         params = {'id': [str(id) for id in id_list]}
-        self.assertEqual(RoleFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_name(self):
         params = {'name': ['Role 1', 'Role 2']}
-        self.assertEqual(RoleFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_slug(self):
         params = {'slug': ['role-1', 'role-2']}
-        self.assertEqual(RoleFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
 
 class PrefixTestCase(TestCase):
     queryset = Prefix.objects.all()
+    filterset = PrefixFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -212,80 +214,81 @@ class PrefixTestCase(TestCase):
 
     def test_family(self):
         params = {'family': '6'}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 5)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 5)
 
     def test_is_pool(self):
         params = {'is_pool': 'true'}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'is_pool': 'false'}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 8)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 8)
 
     def test_id__in(self):
         id_list = self.queryset.values_list('id', flat=True)[:3]
         params = {'id__in': ','.join([str(id) for id in id_list])}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
     def test_within(self):
         params = {'within': '10.0.0.0/16'}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_within_include(self):
         params = {'within_include': '10.0.0.0/16'}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 5)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 5)
 
     def test_contains(self):
         params = {'contains': '10.0.1.0/24'}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'contains': '2001:db8:0:1::/64'}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_mask_length(self):
         params = {'mask_length': '24'}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_vrf(self):
         vrfs = VRF.objects.all()[:2]
         params = {'vrf_id': [vrfs[0].pk, vrfs[1].pk]}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
         params = {'vrf': [vrfs[0].rd, vrfs[1].rd]}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_region(self):
         regions = Region.objects.all()[:2]
         params = {'region_id': [regions[0].pk, regions[1].pk]}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
         params = {'region': [regions[0].slug, regions[1].slug]}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_site(self):
         sites = Site.objects.all()[:2]
         params = {'site_id': [sites[0].pk, sites[1].pk]}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
         params = {'site': [sites[0].slug, sites[1].slug]}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_vlan(self):
         vlans = VLAN.objects.all()[:2]
         params = {'vlan_id': [vlans[0].pk, vlans[1].pk]}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
         # TODO: Test for multiple values
         params = {'vlan_vid': vlans[0].vid}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_role(self):
         roles = Role.objects.all()[:2]
         params = {'role_id': [roles[0].pk, roles[1].pk]}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
         params = {'role': [roles[0].slug, roles[1].slug]}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_status(self):
         params = {'status': [PREFIX_STATUS_DEPRECATED, PREFIX_STATUS_RESERVED]}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
 
 class IPAddressTestCase(TestCase):
     queryset = IPAddress.objects.all()
+    filterset = IPAddressFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -343,84 +346,85 @@ class IPAddressTestCase(TestCase):
 
     def test_family(self):
         params = {'family': '6'}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_dns_name(self):
         params = {'dns_name': ['ipaddress-a', 'ipaddress-b']}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_id__in(self):
         id_list = self.queryset.values_list('id', flat=True)[:3]
         params = {'id__in': ','.join([str(id) for id in id_list])}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
     def test_parent(self):
         params = {'parent': '10.0.0.0/24'}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
         params = {'parent': '2001:db8::/64'}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def filter_address(self):
         # Check IPv4 and IPv6, with and without a mask
         params = {'address': '10.0.0.1/24'}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 1)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
         params = {'address': '10.0.0.1'}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 1)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
         params = {'address': '2001:db8::1/64'}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 1)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
         params = {'address': '2001:db8::1'}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 1)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
     def test_mask_length(self):
         params = {'mask_length': '24'}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_vrf(self):
         vrfs = VRF.objects.all()[:2]
         params = {'vrf_id': [vrfs[0].pk, vrfs[1].pk]}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
         params = {'vrf': [vrfs[0].rd, vrfs[1].rd]}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     # TODO: Test for multiple values
     def test_device(self):
         device = Device.objects.first()
         params = {'device_id': device.pk}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 1)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
         params = {'device': device.name}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 1)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
     def test_virtual_machine(self):
         vms = VirtualMachine.objects.all()[:2]
         params = {'virtual_machine_id': [vms[0].pk, vms[1].pk]}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'virtual_machine': [vms[0].name, vms[1].name]}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_interface(self):
         interfaces = Interface.objects.all()[:2]
         params = {'interface_id': [interfaces[0].pk, interfaces[1].pk]}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'interface': ['Interface 1', 'Interface 2']}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_assigned_to_interface(self):
         params = {'assigned_to_interface': 'true'}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 6)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 6)
         params = {'assigned_to_interface': 'false'}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_status(self):
         params = {'status': [PREFIX_STATUS_DEPRECATED, PREFIX_STATUS_RESERVED]}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_role(self):
         params = {'role': [IPADDRESS_ROLE_SECONDARY, IPADDRESS_ROLE_VIP]}
-        self.assertEqual(IPAddressFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
 
 class VLANGroupTestCase(TestCase):
     queryset = VLANGroup.objects.all()
+    filterset = VLANGroupFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -452,33 +456,34 @@ class VLANGroupTestCase(TestCase):
     def test_id(self):
         id_list = self.queryset.values_list('id', flat=True)[:2]
         params = {'id': [str(id) for id in id_list]}
-        self.assertEqual(VLANGroupFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_name(self):
         params = {'name': ['VLAN Group 1', 'VLAN Group 2']}
-        self.assertEqual(VLANGroupFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_slug(self):
         params = {'slug': ['vlan-group-1', 'vlan-group-2']}
-        self.assertEqual(VLANGroupFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_region(self):
         regions = Region.objects.all()[:2]
         params = {'region_id': [regions[0].pk, regions[1].pk]}
-        self.assertEqual(VLANGroupFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'region': [regions[0].slug, regions[1].slug]}
-        self.assertEqual(VLANGroupFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_site(self):
         sites = Site.objects.all()[:2]
         params = {'site_id': [sites[0].pk, sites[1].pk]}
-        self.assertEqual(VLANGroupFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'site': [sites[0].slug, sites[1].slug]}
-        self.assertEqual(VLANGroupFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
 
 class VLANTestCase(TestCase):
     queryset = VLAN.objects.all()
+    filterset = VLANFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -525,52 +530,53 @@ class VLANTestCase(TestCase):
 
     def test_name(self):
         params = {'name': ['VLAN 101', 'VLAN 102']}
-        self.assertEqual(VLANFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_rd(self):
         params = {'vid': ['101', '201', '301']}
-        self.assertEqual(VLANFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
     def test_id__in(self):
         id_list = self.queryset.values_list('id', flat=True)[:3]
         params = {'id__in': ','.join([str(id) for id in id_list])}
-        self.assertEqual(VLANFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
     def test_region(self):
         regions = Region.objects.all()[:2]
         params = {'region_id': [regions[0].pk, regions[1].pk]}
-        self.assertEqual(VLANFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
         params = {'region': [regions[0].slug, regions[1].slug]}
-        self.assertEqual(VLANFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_site(self):
         sites = Site.objects.all()[:2]
         params = {'site_id': [sites[0].pk, sites[1].pk]}
-        self.assertEqual(VLANFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
         params = {'site': [sites[0].slug, sites[1].slug]}
-        self.assertEqual(VLANFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_group(self):
         groups = VLANGroup.objects.all()[:2]
         params = {'group_id': [groups[0].pk, groups[1].pk]}
-        self.assertEqual(VLANFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
         params = {'group': [groups[0].slug, groups[1].slug]}
-        self.assertEqual(VLANFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_role(self):
         roles = Role.objects.all()[:2]
         params = {'role_id': [roles[0].pk, roles[1].pk]}
-        self.assertEqual(VLANFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
         params = {'role': [roles[0].slug, roles[1].slug]}
-        self.assertEqual(VLANFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_status(self):
         params = {'status': [VLAN_STATUS_ACTIVE, VLAN_STATUS_DEPRECATED]}
-        self.assertEqual(PrefixFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
 
 class ServiceTestCase(TestCase):
     queryset = Service.objects.all()
+    filterset = ServiceFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -610,30 +616,30 @@ class ServiceTestCase(TestCase):
     def test_id(self):
         id_list = self.queryset.values_list('id', flat=True)[:3]
         params = {'id': [str(id) for id in id_list]}
-        self.assertEqual(ServiceFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
     def test_name(self):
         params = {'name': ['Service 1', 'Service 2']}
-        self.assertEqual(ServiceFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_protocol(self):
         params = {'protocol': IP_PROTOCOL_TCP}
-        self.assertEqual(ServiceFilter(params, self.queryset).qs.count(), 4)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 4)
 
     def test_port(self):
         params = {'port': ['1001', '1002', '1003']}
-        self.assertEqual(ServiceFilter(params, self.queryset).qs.count(), 3)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 3)
 
     def test_device(self):
         devices = Device.objects.all()[:2]
         params = {'device_id': [devices[0].pk, devices[1].pk]}
-        self.assertEqual(ServiceFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'device': [devices[0].name, devices[1].name]}
-        self.assertEqual(ServiceFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_virtual_machine(self):
         vms = VirtualMachine.objects.all()[:2]
         params = {'virtual_machine_id': [vms[0].pk, vms[1].pk]}
-        self.assertEqual(ServiceFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'virtual_machine': [vms[0].name, vms[1].name]}
-        self.assertEqual(ServiceFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)

netbox/secrets/tests/test_filters.py

@@ -1,12 +1,13 @@
 from django.test import TestCase
 
 from dcim.models import Device, DeviceRole, DeviceType, Manufacturer, Site
-from secrets.filters import SecretFilter, SecretRoleFilter
+from secrets.filters import *
 from secrets.models import Secret, SecretRole
 
 
 class SecretRoleTestCase(TestCase):
     queryset = SecretRole.objects.all()
+    filterset = SecretRoleFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -21,19 +22,20 @@ class SecretRoleTestCase(TestCase):
     def test_id(self):
         id_list = self.queryset.values_list('id', flat=True)[:2]
         params = {'id': [str(id) for id in id_list]}
-        self.assertEqual(SecretRoleFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_name(self):
         params = {'name': ['Secret Role 1', 'Secret Role 2']}
-        self.assertEqual(SecretRoleFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_slug(self):
         params = {'slug': ['secret-role-1', 'secret-role-2']}
-        self.assertEqual(SecretRoleFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
 
 class SecretTestCase(TestCase):
     queryset = Secret.objects.all()
+    filterset = SecretFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -68,23 +70,23 @@ class SecretTestCase(TestCase):
 
     def test_name(self):
         params = {'name': ['Secret 1', 'Secret 2']}
-        self.assertEqual(SecretFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_id__in(self):
         id_list = self.queryset.values_list('id', flat=True)[:2]
         params = {'id__in': ','.join([str(id) for id in id_list])}
-        self.assertEqual(SecretFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_role(self):
         roles = SecretRole.objects.all()[:2]
         params = {'role_id': [roles[0].pk, roles[1].pk]}
-        self.assertEqual(SecretFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'role': [roles[0].slug, roles[1].slug]}
-        self.assertEqual(SecretFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_device(self):
         devices = Device.objects.all()[:2]
         params = {'device_id': [devices[0].pk, devices[1].pk]}
-        self.assertEqual(SecretFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'device': [devices[0].name, devices[1].name]}
-        self.assertEqual(SecretFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)

netbox/tenancy/tests/test_filters.py

@@ -1,11 +1,12 @@
 from django.test import TestCase
 
-from tenancy.filters import TenantFilter, TenantGroupFilter
+from tenancy.filters import *
 from tenancy.models import Tenant, TenantGroup
 
 
 class TenantGroupTestCase(TestCase):
     queryset = TenantGroup.objects.all()
+    filterset = TenantGroupFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -20,19 +21,20 @@ class TenantGroupTestCase(TestCase):
     def test_id(self):
         id_list = self.queryset.values_list('id', flat=True)[:2]
         params = {'id': [str(id) for id in id_list]}
-        self.assertEqual(TenantGroupFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_name(self):
         params = {'name': ['Tenant Group 1', 'Tenant Group 2']}
-        self.assertEqual(TenantGroupFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_slug(self):
         params = {'slug': ['tenant-group-1', 'tenant-group-2']}
-        self.assertEqual(TenantGroupFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
 
 class TenantTestCase(TestCase):
     queryset = Tenant.objects.all()
+    filterset = TenantFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -53,20 +55,20 @@ class TenantTestCase(TestCase):
 
     def test_name(self):
         params = {'name': ['Tenant 1', 'Tenant 2']}
-        self.assertEqual(TenantFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_slug(self):
         params = {'slug': ['tenant-1', 'tenant-2']}
-        self.assertEqual(TenantFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_id__in(self):
         id_list = self.queryset.values_list('id', flat=True)[:2]
         params = {'id__in': ','.join([str(id) for id in id_list])}
-        self.assertEqual(TenantFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_group(self):
         group = TenantGroup.objects.all()[:2]
         params = {'group_id': [group[0].pk, group[1].pk]}
-        self.assertEqual(TenantFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'group': [group[0].slug, group[1].slug]}
-        self.assertEqual(TenantFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)

netbox/virtualization/tests/test_filters.py

@@ -2,14 +2,13 @@ from django.test import TestCase
 
 from dcim.models import DeviceRole, Interface, Platform, Region, Site
 from virtualization.constants import *
-from virtualization.filters import (
-    ClusterFilter, ClusterGroupFilter, ClusterTypeFilter, InterfaceFilter, VirtualMachineFilter,
-)
+from virtualization.filters import *
 from virtualization.models import Cluster, ClusterGroup, ClusterType, VirtualMachine
 
 
 class ClusterTypeTestCase(TestCase):
     queryset = ClusterType.objects.all()
+    filterset = ClusterTypeFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -24,19 +23,20 @@ class ClusterTypeTestCase(TestCase):
     def test_id(self):
         id_list = self.queryset.values_list('id', flat=True)[:2]
         params = {'id': [str(id) for id in id_list]}
-        self.assertEqual(ClusterTypeFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_name(self):
         params = {'name': ['Cluster Type 1', 'Cluster Type 2']}
-        self.assertEqual(ClusterTypeFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_slug(self):
         params = {'slug': ['cluster-type-1', 'cluster-type-2']}
-        self.assertEqual(ClusterTypeFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
 
 class ClusterGroupTestCase(TestCase):
     queryset = ClusterGroup.objects.all()
+    filterset = ClusterGroupFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -51,19 +51,20 @@ class ClusterGroupTestCase(TestCase):
     def test_id(self):
         id_list = self.queryset.values_list('id', flat=True)[:2]
         params = {'id': [str(id) for id in id_list]}
-        self.assertEqual(ClusterGroupFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_name(self):
         params = {'name': ['Cluster Group 1', 'Cluster Group 2']}
-        self.assertEqual(ClusterGroupFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_slug(self):
         params = {'slug': ['cluster-group-1', 'cluster-group-2']}
-        self.assertEqual(ClusterGroupFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
 
 class ClusterTestCase(TestCase):
     queryset = Cluster.objects.all()
+    filterset = ClusterFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -107,44 +108,45 @@ class ClusterTestCase(TestCase):
 
     def test_name(self):
         params = {'name': ['Cluster 1', 'Cluster 2']}
-        self.assertEqual(ClusterFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_id__in(self):
         id_list = self.queryset.values_list('id', flat=True)[:2]
         params = {'id__in': ','.join([str(id) for id in id_list])}
-        self.assertEqual(ClusterFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_region(self):
         regions = Region.objects.all()[:2]
         params = {'region_id': [regions[0].pk, regions[1].pk]}
-        self.assertEqual(ClusterFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'region': [regions[0].slug, regions[1].slug]}
-        self.assertEqual(ClusterFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_site(self):
         sites = Site.objects.all()[:2]
         params = {'site_id': [sites[0].pk, sites[1].pk]}
-        self.assertEqual(ClusterFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'site': [sites[0].slug, sites[1].slug]}
-        self.assertEqual(ClusterFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_group(self):
         groups = ClusterGroup.objects.all()[:2]
         params = {'group_id': [groups[0].pk, groups[1].pk]}
-        self.assertEqual(ClusterFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'group': [groups[0].slug, groups[1].slug]}
-        self.assertEqual(ClusterFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_type(self):
         types = ClusterType.objects.all()[:2]
         params = {'type_id': [types[0].pk, types[1].pk]}
-        self.assertEqual(ClusterFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'type': [types[0].slug, types[1].slug]}
-        self.assertEqual(ClusterFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
 
 class VirtualMachineTestCase(TestCase):
     queryset = VirtualMachine.objects.all()
+    filterset = VirtualMachineFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -217,90 +219,91 @@ class VirtualMachineTestCase(TestCase):
     def test_id(self):
         id_list = self.queryset.values_list('id', flat=True)[:2]
         params = {'id': [str(id) for id in id_list]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_name(self):
         params = {'name': ['Virtual Machine 1', 'Virtual Machine 2']}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_vcpus(self):
         params = {'vcpus': [1, 2]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_memory(self):
         params = {'memory': [1, 2]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_disk(self):
         params = {'disk': [1, 2]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_id__in(self):
         id_list = self.queryset.values_list('id', flat=True)[:2]
         params = {'id__in': ','.join([str(id) for id in id_list])}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_status(self):
         params = {'status': [DEVICE_STATUS_ACTIVE, DEVICE_STATUS_STAGED]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_cluster_group(self):
         groups = ClusterGroup.objects.all()[:2]
         params = {'cluster_group_id': [groups[0].pk, groups[1].pk]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'cluster_group': [groups[0].slug, groups[1].slug]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_cluster_type(self):
         types = ClusterType.objects.all()[:2]
         params = {'cluster_type_id': [types[0].pk, types[1].pk]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'cluster_type': [types[0].slug, types[1].slug]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_cluster(self):
         clusters = Cluster.objects.all()[:2]
         params = {'cluster_id': [clusters[0].pk, clusters[1].pk]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         # TODO: 'cluster' should match on name
         # params = {'cluster': [clusters[0].name, clusters[1].name]}
-        # self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        # self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_region(self):
         regions = Region.objects.all()[:2]
         params = {'region_id': [regions[0].pk, regions[1].pk]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'region': [regions[0].slug, regions[1].slug]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_site(self):
         sites = Site.objects.all()[:2]
         params = {'site_id': [sites[0].pk, sites[1].pk]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'site': [sites[0].slug, sites[1].slug]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_role(self):
         roles = DeviceRole.objects.all()[:2]
         params = {'role_id': [roles[0].pk, roles[1].pk]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'role': [roles[0].slug, roles[1].slug]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_platform(self):
         platforms = Platform.objects.all()[:2]
         params = {'platform_id': [platforms[0].pk, platforms[1].pk]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'platform': [platforms[0].slug, platforms[1].slug]}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_mac_address(self):
         params = {'mac_address': ['00-00-00-00-00-01', '00-00-00-00-00-02']}
-        self.assertEqual(VirtualMachineFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
 
 class InterfaceTestCase(TestCase):
     queryset = Interface.objects.all()
+    filterset = InterfaceFilter
 
     @classmethod
     def setUpTestData(cls):
@@ -336,29 +339,29 @@ class InterfaceTestCase(TestCase):
     def test_id(self):
         id_list = self.queryset.values_list('id', flat=True)[:2]
         params = {'id': [str(id) for id in id_list]}
-        self.assertEqual(InterfaceFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_name(self):
         params = {'name': ['Interface 1', 'Interface 2']}
-        self.assertEqual(InterfaceFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_assigned_to_interface(self):
         params = {'enabled': 'true'}
-        self.assertEqual(InterfaceFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'enabled': 'false'}
-        self.assertEqual(InterfaceFilter(params, self.queryset).qs.count(), 1)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
 
     def test_mtu(self):
         params = {'mtu': [100, 200]}
-        self.assertEqual(InterfaceFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_virtual_machine(self):
         vms = VirtualMachine.objects.all()[:2]
         params = {'virtual_machine_id': [vms[0].pk, vms[1].pk]}
-        self.assertEqual(InterfaceFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {'virtual_machine': [vms[0].name, vms[1].name]}
-        self.assertEqual(InterfaceFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
 
     def test_mac_address(self):
         params = {'mac_address': ['00-00-00-00-00-01', '00-00-00-00-00-02']}
-        self.assertEqual(InterfaceFilter(params, self.queryset).qs.count(), 2)
+        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)