NeoAnd/netbox
1
0
Fork 0
mirror of https://github.com/netbox-community/netbox.git synced 2025-07-24 17:38:37 -06:00
Code Issues Actions 11 Packages Projects Releases Wiki Activity

Standardize usage of self.filterset for test cases

Browse Source
This commit is contained in:
Jeremy Stretch 2020-01-08 17:06:39 -05:00
parent c04d8ca5a7
commit b1e8145ffb
6 changed files with 546 additions and 509 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
netbox/circuits/tests/test_filters.py
View File

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

656
netbox/dcim/tests/test_filters.py
View File

File diff suppressed because it is too large Load Diff

188
netbox/ipam/tests/test_filters.py
View File

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

22
netbox/secrets/tests/test_filters.py
View File

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

20
netbox/tenancy/tests/test_filters.py
View File

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

101
netbox/virtualization/tests/test_filters.py
View File

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