From 9d69f14faad1a44ec2cee6a40c80607159538b71 Mon Sep 17 00:00:00 2001 From: Jeremy Stretch Date: Fri, 15 Feb 2019 17:02:18 -0500 Subject: [PATCH] Implement basic view testing for all models (#2909) --- netbox/circuits/tests/test_views.py | 91 +++++ netbox/dcim/tests/test_views.py | 458 ++++++++++++++++++++++ netbox/extras/tests/test_views.py | 105 +++++ netbox/ipam/tests/test_views.py | 282 +++++++++++++ netbox/secrets/tests/test_views.py | 82 ++++ netbox/tenancy/tests/test_views.py | 58 +++ netbox/virtualization/tests/test_views.py | 117 ++++++ 7 files changed, 1193 insertions(+) create mode 100644 netbox/circuits/tests/test_views.py create mode 100644 netbox/dcim/tests/test_views.py create mode 100644 netbox/extras/tests/test_views.py create mode 100644 netbox/ipam/tests/test_views.py create mode 100644 netbox/secrets/tests/test_views.py create mode 100644 netbox/tenancy/tests/test_views.py create mode 100644 netbox/virtualization/tests/test_views.py diff --git a/netbox/circuits/tests/test_views.py b/netbox/circuits/tests/test_views.py new file mode 100644 index 000000000..65ae6d7db --- /dev/null +++ b/netbox/circuits/tests/test_views.py @@ -0,0 +1,91 @@ +import urllib.parse + +from django.test import Client, TestCase +from django.urls import reverse + +from circuits.models import Circuit, CircuitType, Provider + + +class ProviderTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + Provider.objects.bulk_create([ + Provider(name='Provider 1', slug='provider-1', asn=65001), + Provider(name='Provider 2', slug='provider-2', asn=65002), + Provider(name='Provider 3', slug='provider-3', asn=65003), + ]) + + def test_provider_list(self): + + url = reverse('circuits:provider_list') + params = { + "q": "test", + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_provider(self): + + provider = Provider.objects.first() + response = self.client.get(provider.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class CircuitTypeTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + CircuitType.objects.bulk_create([ + CircuitType(name='Circuit Type 1', slug='circuit-type-1'), + CircuitType(name='Circuit Type 2', slug='circuit-type-2'), + CircuitType(name='Circuit Type 3', slug='circuit-type-3'), + ]) + + def test_circuittype_list(self): + + url = reverse('circuits:circuittype_list') + + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + + +class CircuitTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + provider = Provider(name='Provider 1', slug='provider-1', asn=65001) + provider.save() + + circuittype = CircuitType(name='Circuit Type 1', slug='circuit-type-1') + circuittype.save() + + Circuit.objects.bulk_create([ + Circuit(cid='Circuit 1', provider=provider, type=circuittype), + Circuit(cid='Circuit 2', provider=provider, type=circuittype), + Circuit(cid='Circuit 3', provider=provider, type=circuittype), + ]) + + def test_circuit_list(self): + + url = reverse('circuits:circuit_list') + params = { + "provider": Provider.objects.first().slug, + "type": CircuitType.objects.first().slug, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_provider(self): + + provider = Provider.objects.first() + response = self.client.get(provider.get_absolute_url()) + self.assertEqual(response.status_code, 200) diff --git a/netbox/dcim/tests/test_views.py b/netbox/dcim/tests/test_views.py new file mode 100644 index 000000000..79f38a5c9 --- /dev/null +++ b/netbox/dcim/tests/test_views.py @@ -0,0 +1,458 @@ +import urllib.parse + +from django.contrib.auth import get_user_model +from django.test import Client, TestCase +from django.urls import reverse + +from dcim.constants import CABLE_TYPE_CAT6, IFACE_FF_1GE_FIXED +from dcim.models import ( + Cable, Device, DeviceRole, DeviceType, Interface, InventoryItem, Manufacturer, Platform, Rack, RackGroup, + RackReservation, RackRole, Site, Region, VirtualChassis, +) + + +class RegionTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + # Create three Regions + for i in range(1, 4): + Region(name='Region {}'.format(i), slug='region-{}'.format(i)).save() + + def test_region_list(self): + + url = reverse('dcim:region_list') + + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + + +class SiteTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + region = Region(name='Region 1', slug='region-1') + region.save() + + Site.objects.bulk_create([ + Site(name='Site 1', slug='site-1', region=region), + Site(name='Site 2', slug='site-2', region=region), + Site(name='Site 3', slug='site-3', region=region), + ]) + + def test_site_list(self): + + url = reverse('dcim:site_list') + params = { + "region": Region.objects.first().slug, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_site(self): + + site = Site.objects.first() + response = self.client.get(site.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class RackGroupTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + site = Site(name='Site 1', slug='site-1') + site.save() + + RackGroup.objects.bulk_create([ + RackGroup(name='Rack Group 1', slug='rack-group-1', site=site), + RackGroup(name='Rack Group 2', slug='rack-group-2', site=site), + RackGroup(name='Rack Group 3', slug='rack-group-3', site=site), + ]) + + def test_rackgroup_list(self): + + url = reverse('dcim:rackgroup_list') + + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + + +class RackTypeTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + RackRole.objects.bulk_create([ + RackRole(name='Rack Role 1', slug='rack-role-1'), + RackRole(name='Rack Role 2', slug='rack-role-2'), + RackRole(name='Rack Role 3', slug='rack-role-3'), + ]) + + def test_rackrole_list(self): + + url = reverse('dcim:rackrole_list') + + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + + +class RackReservationTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + User = get_user_model() + user = User(username='testuser', email='testuser@example.com') + user.save() + + site = Site(name='Site 1', slug='site-1') + site.save() + + rack = Rack(name='Rack 1', site=site) + rack.save() + + RackReservation.objects.bulk_create([ + RackReservation(rack=rack, user=user, units=[1, 2, 3], description='Reservation 1'), + RackReservation(rack=rack, user=user, units=[4, 5, 6], description='Reservation 2'), + RackReservation(rack=rack, user=user, units=[7, 8, 9], description='Reservation 3'), + ]) + + def test_rackreservation_list(self): + + url = reverse('dcim:rackreservation_list') + + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + + +class RackTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + site = Site(name='Site 1', slug='site-1') + site.save() + + Rack.objects.bulk_create([ + Rack(name='Rack 1', site=site), + Rack(name='Rack 2', site=site), + Rack(name='Rack 3', site=site), + ]) + + def test_rack_list(self): + + url = reverse('dcim:rack_list') + params = { + "site": Site.objects.first().slug, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_rack(self): + + rack = Rack.objects.first() + response = self.client.get(rack.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class ManufacturerTypeTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + Manufacturer.objects.bulk_create([ + Manufacturer(name='Manufacturer 1', slug='manufacturer-1'), + Manufacturer(name='Manufacturer 2', slug='manufacturer-2'), + Manufacturer(name='Manufacturer 3', slug='manufacturer-3'), + ]) + + def test_manufacturer_list(self): + + url = reverse('dcim:manufacturer_list') + + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + + +class DeviceTypeTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + manufacturer = Manufacturer(name='Manufacturer 1', slug='manufacturer-1') + manufacturer.save() + + DeviceType.objects.bulk_create([ + DeviceType(model='Device Type 1', slug='device-type-1', manufacturer=manufacturer), + DeviceType(model='Device Type 2', slug='device-type-2', manufacturer=manufacturer), + DeviceType(model='Device Type 3', slug='device-type-3', manufacturer=manufacturer), + ]) + + def test_devicetype_list(self): + + url = reverse('dcim:devicetype_list') + params = { + "manufacturer": Manufacturer.objects.first().slug, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_devicetype(self): + + devicetype = DeviceType.objects.first() + response = self.client.get(devicetype.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class DeviceRoleTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + DeviceRole.objects.bulk_create([ + DeviceRole(name='Device Role 1', slug='device-role-1'), + DeviceRole(name='Device Role 2', slug='device-role-2'), + DeviceRole(name='Device Role 3', slug='device-role-3'), + ]) + + def test_devicerole_list(self): + + url = reverse('dcim:devicerole_list') + + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + + +class PlatformTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + Platform.objects.bulk_create([ + Platform(name='Platform 1', slug='platform-1'), + Platform(name='Platform 2', slug='platform-2'), + Platform(name='Platform 3', slug='platform-3'), + ]) + + def test_platform_list(self): + + url = reverse('dcim:platform_list') + + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + + +class DeviceTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + site = Site(name='Site 1', slug='site-1') + site.save() + + manufacturer = Manufacturer(name='Manufacturer 1', slug='manufacturer-1') + manufacturer.save() + + devicetype = DeviceType(model='Device Type 1', manufacturer=manufacturer) + devicetype.save() + + devicerole = DeviceRole(name='Device Role 1', slug='device-role-1') + devicerole.save() + + Device.objects.bulk_create([ + Device(name='Device 1', site=site, device_type=devicetype, device_role=devicerole), + Device(name='Device 2', site=site, device_type=devicetype, device_role=devicerole), + Device(name='Device 3', site=site, device_type=devicetype, device_role=devicerole), + ]) + + def test_device_list(self): + + url = reverse('dcim:device_list') + params = { + "device_type_id": DeviceType.objects.first().pk, + "role": DeviceRole.objects.first().slug, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_device(self): + + device = Device.objects.first() + response = self.client.get(device.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class InventoryItemTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + site = Site(name='Site 1', slug='site-1') + site.save() + + manufacturer = Manufacturer(name='Manufacturer 1', slug='manufacturer-1') + manufacturer.save() + + devicetype = DeviceType(model='Device Type 1', manufacturer=manufacturer) + devicetype.save() + + devicerole = DeviceRole(name='Device Role 1', slug='device-role-1') + devicerole.save() + + device = Device(name='Device 1', site=site, device_type=devicetype, device_role=devicerole) + device.save() + + InventoryItem.objects.bulk_create([ + InventoryItem(device=device, name='Inventory Item 1'), + InventoryItem(device=device, name='Inventory Item 2'), + InventoryItem(device=device, name='Inventory Item 3'), + ]) + + def test_inventoryitem_list(self): + + url = reverse('dcim:inventoryitem_list') + params = { + "device_id": Device.objects.first().pk, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_inventoryitem(self): + + inventoryitem = InventoryItem.objects.first() + response = self.client.get(inventoryitem.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class CableTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + site = Site(name='Site 1', slug='site-1') + site.save() + + manufacturer = Manufacturer(name='Manufacturer 1', slug='manufacturer-1') + manufacturer.save() + + devicetype = DeviceType(model='Device Type 1', manufacturer=manufacturer) + devicetype.save() + + devicerole = DeviceRole(name='Device Role 1', slug='device-role-1') + devicerole.save() + + device1 = Device(name='Device 1', site=site, device_type=devicetype, device_role=devicerole) + device1.save() + device2 = Device(name='Device 2', site=site, device_type=devicetype, device_role=devicerole) + device2.save() + + iface1 = Interface(device=device1, name='Interface 1', form_factor=IFACE_FF_1GE_FIXED) + iface1.save() + iface2 = Interface(device=device1, name='Interface 2', form_factor=IFACE_FF_1GE_FIXED) + iface2.save() + iface3 = Interface(device=device1, name='Interface 3', form_factor=IFACE_FF_1GE_FIXED) + iface3.save() + iface4 = Interface(device=device2, name='Interface 1', form_factor=IFACE_FF_1GE_FIXED) + iface4.save() + iface5 = Interface(device=device2, name='Interface 2', form_factor=IFACE_FF_1GE_FIXED) + iface5.save() + iface6 = Interface(device=device2, name='Interface 3', form_factor=IFACE_FF_1GE_FIXED) + iface6.save() + + Cable(termination_a=iface1, termination_b=iface4, type=CABLE_TYPE_CAT6).save() + Cable(termination_a=iface2, termination_b=iface5, type=CABLE_TYPE_CAT6).save() + Cable(termination_a=iface3, termination_b=iface6, type=CABLE_TYPE_CAT6).save() + + def test_cable_list(self): + + url = reverse('dcim:cable_list') + params = { + "type": CABLE_TYPE_CAT6, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_cable(self): + + cable = Cable.objects.first() + response = self.client.get(cable.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class VirtualMachineTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + site = Site.objects.create(name='Site 1', slug='site-1') + manufacturer = Manufacturer.objects.create(name='Manufacturer', slug='manufacturer-1') + device_type = DeviceType.objects.create( + manufacturer=manufacturer, model='Device Type 1', slug='device-type-1' + ) + device_role = DeviceRole.objects.create( + name='Device Role', slug='device-role-1' + ) + + # Create 9 member Devices + device1 = Device.objects.create( + device_type=device_type, device_role=device_role, name='Device 1', site=site + ) + device2 = Device.objects.create( + device_type=device_type, device_role=device_role, name='Device 2', site=site + ) + device3 = Device.objects.create( + device_type=device_type, device_role=device_role, name='Device 3', site=site + ) + device4 = Device.objects.create( + device_type=device_type, device_role=device_role, name='Device 4', site=site + ) + device5 = Device.objects.create( + device_type=device_type, device_role=device_role, name='Device 5', site=site + ) + device6 = Device.objects.create( + device_type=device_type, device_role=device_role, name='Device 6', site=site + ) + + # Create three VirtualChassis with two members each + vc1 = VirtualChassis.objects.create(master=device1, domain='test-domain-1') + Device.objects.filter(pk=device2.pk).update(virtual_chassis=vc1, vc_position=2) + vc2 = VirtualChassis.objects.create(master=device3, domain='test-domain-2') + Device.objects.filter(pk=device4.pk).update(virtual_chassis=vc2, vc_position=2) + vc3 = VirtualChassis.objects.create(master=device5, domain='test-domain-3') + Device.objects.filter(pk=device6.pk).update(virtual_chassis=vc3, vc_position=2) + + def test_virtualchassis_list(self): + + url = reverse('dcim:virtualchassis_list') + + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + + def test_virtualchassis(self): + + virtualchassis = VirtualChassis.objects.first() + response = self.client.get(virtualchassis.get_absolute_url()) + self.assertEqual(response.status_code, 200) diff --git a/netbox/extras/tests/test_views.py b/netbox/extras/tests/test_views.py new file mode 100644 index 000000000..d478f069c --- /dev/null +++ b/netbox/extras/tests/test_views.py @@ -0,0 +1,105 @@ +import urllib.parse +import uuid + +from django.contrib.auth.models import User +from django.test import Client, TestCase +from django.urls import reverse +from taggit.models import Tag + +from dcim.models import Site +from extras.models import ConfigContext, ObjectChange + + +class TagTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + Tag.objects.bulk_create([ + Tag(name='Tag 1', slug='tag-1'), + Tag(name='Tag 2', slug='tag-2'), + Tag(name='Tag 3', slug='tag-3'), + ]) + + def test_tag_list(self): + + url = reverse('extras:tag_list') + params = { + "q": "tag", + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + +class ConfigContextTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + site = Site(name='Site 1', slug='site-1') + site.save() + + # Create three ConfigContexts + for i in range(1, 4): + configcontext = ConfigContext( + name='Config Context {}'.format(i), + data='{{"foo": {}}}'.format(i) + ) + configcontext.save() + configcontext.sites.add(site) + + def test_configcontext_list(self): + + url = reverse('extras:configcontext_list') + params = { + "q": "foo", + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_configcontext(self): + + configcontext = ConfigContext.objects.first() + response = self.client.get(configcontext.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class ObjectChangeTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + user = User(username='testuser', email='testuser@example.com') + user.save() + + site = Site(name='Site 1', slug='site-1') + site.save() + + # Create three ObjectChanges + for i in range(1, 4): + site.log_change( + user=user, + request_id=uuid.uuid4(), + action=2 + ) + + def test_objectchange_list(self): + + url = reverse('extras:objectchange_list') + params = { + "user": User.objects.first(), + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_objectchange(self): + + objectchange = ObjectChange.objects.first() + response = self.client.get(objectchange.get_absolute_url()) + self.assertEqual(response.status_code, 200) diff --git a/netbox/ipam/tests/test_views.py b/netbox/ipam/tests/test_views.py new file mode 100644 index 000000000..20c16df9b --- /dev/null +++ b/netbox/ipam/tests/test_views.py @@ -0,0 +1,282 @@ +from netaddr import IPNetwork +import urllib.parse + +from django.test import Client, TestCase +from django.urls import reverse + +from dcim.models import Device, DeviceRole, DeviceType, Manufacturer, Site +from ipam.constants import IP_PROTOCOL_TCP +from ipam.models import Aggregate, IPAddress, Prefix, RIR, Role, Service, VLAN, VLANGroup, VRF + + +class VRFTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + VRF.objects.bulk_create([ + VRF(name='VRF 1', rd='65000:1'), + VRF(name='VRF 2', rd='65000:2'), + VRF(name='VRF 3', rd='65000:3'), + ]) + + def test_vrf_list(self): + + url = reverse('ipam:vrf_list') + params = { + "q": "65000", + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_configcontext(self): + + vrf = VRF.objects.first() + response = self.client.get(vrf.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class RIRTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + RIR.objects.bulk_create([ + RIR(name='RIR 1', slug='rir-1'), + RIR(name='RIR 2', slug='rir-2'), + RIR(name='RIR 3', slug='rir-3'), + ]) + + def test_rir_list(self): + + url = reverse('ipam:rir_list') + + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + + def test_rir(self): + + rir = RIR.objects.first() + response = self.client.get(rir.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class AggregateTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + rir = RIR(name='RIR 1', slug='rir-1') + rir.save() + + Aggregate.objects.bulk_create([ + Aggregate(family=4, prefix=IPNetwork('10.1.0.0/16'), rir=rir), + Aggregate(family=4, prefix=IPNetwork('10.2.0.0/16'), rir=rir), + Aggregate(family=4, prefix=IPNetwork('10.3.0.0/16'), rir=rir), + ]) + + def test_aggregate_list(self): + + url = reverse('ipam:aggregate_list') + params = { + "rir": RIR.objects.first().slug, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_aggregate(self): + + aggregate = Aggregate.objects.first() + response = self.client.get(aggregate.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class RoleTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + Role.objects.bulk_create([ + Role(name='Role 1', slug='role-1'), + Role(name='Role 2', slug='role-2'), + Role(name='Role 3', slug='role-3'), + ]) + + def test_role_list(self): + + url = reverse('ipam:role_list') + + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + + +class PrefixTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + site = Site(name='Site 1', slug='site-1') + site.save() + + Prefix.objects.bulk_create([ + Prefix(family=4, prefix=IPNetwork('10.1.0.0/16'), site=site), + Prefix(family=4, prefix=IPNetwork('10.2.0.0/16'), site=site), + Prefix(family=4, prefix=IPNetwork('10.3.0.0/16'), site=site), + ]) + + def test_prefix_list(self): + + url = reverse('ipam:prefix_list') + params = { + "site": Site.objects.first().slug, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_prefix(self): + + prefix = Prefix.objects.first() + response = self.client.get(prefix.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class IPAddressTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + vrf = VRF(name='VRF 1', rd='65000:1') + vrf.save() + + IPAddress.objects.bulk_create([ + IPAddress(family=4, address=IPNetwork('10.1.0.0/16'), vrf=vrf), + IPAddress(family=4, address=IPNetwork('10.2.0.0/16'), vrf=vrf), + IPAddress(family=4, address=IPNetwork('10.3.0.0/16'), vrf=vrf), + ]) + + def test_ipaddress_list(self): + + url = reverse('ipam:ipaddress_list') + params = { + "vrf": VRF.objects.first().rd, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_ipaddress(self): + + ipaddress = IPAddress.objects.first() + response = self.client.get(ipaddress.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class VLANGroupTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + site = Site(name='Site 1', slug='site-1') + site.save() + + VLANGroup.objects.bulk_create([ + VLANGroup(name='VLAN Group 1', slug='vlan-group-1', site=site), + VLANGroup(name='VLAN Group 2', slug='vlan-group-2', site=site), + VLANGroup(name='VLAN Group 3', slug='vlan-group-3', site=site), + ]) + + def test_vlangroup_list(self): + + url = reverse('ipam:vlangroup_list') + params = { + "site": Site.objects.first().slug, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + +class VLANTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + vlangroup = VLANGroup(name='VLAN Group 1', slug='vlan-group-1') + vlangroup.save() + + VLAN.objects.bulk_create([ + VLAN(group=vlangroup, vid=101, name='VLAN101'), + VLAN(group=vlangroup, vid=102, name='VLAN102'), + VLAN(group=vlangroup, vid=103, name='VLAN103'), + ]) + + def test_vlan_list(self): + + url = reverse('ipam:vlan_list') + params = { + "group": VLANGroup.objects.first().slug, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_vlan(self): + + vlan = VLAN.objects.first() + response = self.client.get(vlan.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class ServiceTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + site = Site(name='Site 1', slug='site-1') + site.save() + + manufacturer = Manufacturer(name='Manufacturer 1', slug='manufacturer-1') + manufacturer.save() + + devicetype = DeviceType(manufacturer=manufacturer, model='Device Type 1') + devicetype.save() + + devicerole = DeviceRole(name='Device Role 1', slug='device-role-1') + devicerole.save() + + device = Device(name='Device 1', site=site, device_type=devicetype, device_role=devicerole) + device.save() + + Service.objects.bulk_create([ + Service(device=device, name='Service 1', protocol=IP_PROTOCOL_TCP, port=101), + Service(device=device, name='Service 2', protocol=IP_PROTOCOL_TCP, port=102), + Service(device=device, name='Service 3', protocol=IP_PROTOCOL_TCP, port=103), + ]) + + def test_service_list(self): + + url = reverse('ipam:service_list') + params = { + "device_id": Device.objects.first(), + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_service(self): + + service = Service.objects.first() + response = self.client.get(service.get_absolute_url()) + self.assertEqual(response.status_code, 200) diff --git a/netbox/secrets/tests/test_views.py b/netbox/secrets/tests/test_views.py new file mode 100644 index 000000000..f9985db28 --- /dev/null +++ b/netbox/secrets/tests/test_views.py @@ -0,0 +1,82 @@ +import urllib.parse + +from django.contrib.auth import get_user_model +from django.test import Client, TestCase +from django.urls import reverse + +from dcim.models import Device, DeviceRole, DeviceType, Manufacturer, Site +from secrets.models import Secret, SecretRole + + +class SecretRoleTestCase(TestCase): + + def setUp(self): + + TEST_USERNAME = 'testuser' + TEST_PASSWORD = 'testpassword' + + User = get_user_model() + User.objects.create(username=TEST_USERNAME, email='testuser@example.com', password=TEST_PASSWORD) + + self.client = Client() + self.client.login(username=TEST_USERNAME, password=TEST_PASSWORD) + + SecretRole.objects.bulk_create([ + SecretRole(name='Secret Role 1', slug='secret-role-1'), + SecretRole(name='Secret Role 2', slug='secret-role-2'), + SecretRole(name='Secret Role 3', slug='secret-role-3'), + ]) + + def test_secretrole_list(self): + + url = reverse('secrets:secret_list') + + response = self.client.get(url, follow=True) + self.assertEqual(response.status_code, 200) + + +class SecretTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + site = Site(name='Site 1', slug='site-1') + site.save() + + manufacturer = Manufacturer(name='Manufacturer 1', slug='manufacturer-1') + manufacturer.save() + + devicetype = DeviceType(manufacturer=manufacturer, model='Device Type 1') + devicetype.save() + + devicerole = DeviceRole(name='Device Role 1', slug='device-role-1') + devicerole.save() + + device = Device(name='Device 1', site=site, device_type=devicetype, device_role=devicerole) + device.save() + + secretrole = SecretRole(name='Secret Role 1', slug='secret-role-1') + secretrole.save() + + Secret.objects.bulk_create([ + Secret(device=device, role=secretrole, name='Secret 1', ciphertext=b'1234567890'), + Secret(device=device, role=secretrole, name='Secret 2', ciphertext=b'1234567890'), + Secret(device=device, role=secretrole, name='Secret 3', ciphertext=b'1234567890'), + ]) + + def test_secret_list(self): + + url = reverse('secrets:secret_list') + params = { + "role": SecretRole.objects.first().slug, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params)), follow=True) + self.assertEqual(response.status_code, 200) + + def test_configcontext(self): + + secret = Secret.objects.first() + response = self.client.get(secret.get_absolute_url(), follow=True) + self.assertEqual(response.status_code, 200) diff --git a/netbox/tenancy/tests/test_views.py b/netbox/tenancy/tests/test_views.py new file mode 100644 index 000000000..a6ca8f358 --- /dev/null +++ b/netbox/tenancy/tests/test_views.py @@ -0,0 +1,58 @@ +import urllib.parse + +from django.test import Client, TestCase +from django.urls import reverse + +from tenancy.models import Tenant, TenantGroup + + +class TenantGroupTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + TenantGroup.objects.bulk_create([ + TenantGroup(name='Tenant Group 1', slug='tenant-group-1'), + TenantGroup(name='Tenant Group 2', slug='tenant-group-2'), + TenantGroup(name='Tenant Group 3', slug='tenant-group-3'), + ]) + + def test_tenantgroup_list(self): + + url = reverse('tenancy:tenantgroup_list') + + response = self.client.get(url, follow=True) + self.assertEqual(response.status_code, 200) + + +class TenantTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + tenantgroup = TenantGroup(name='Tenant Group 1', slug='tenant-group-1') + tenantgroup.save() + + Tenant.objects.bulk_create([ + Tenant(name='Tenant 1', slug='tenant-1', group=tenantgroup), + Tenant(name='Tenant 2', slug='tenant-2', group=tenantgroup), + Tenant(name='Tenant 3', slug='tenant-3', group=tenantgroup), + ]) + + def test_tenant_list(self): + + url = reverse('tenancy:tenant_list') + params = { + "group": TenantGroup.objects.first().slug, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params)), follow=True) + self.assertEqual(response.status_code, 200) + + def test_tenant(self): + + tenant = Tenant.objects.first() + response = self.client.get(tenant.get_absolute_url(), follow=True) + self.assertEqual(response.status_code, 200) diff --git a/netbox/virtualization/tests/test_views.py b/netbox/virtualization/tests/test_views.py new file mode 100644 index 000000000..1b86e2015 --- /dev/null +++ b/netbox/virtualization/tests/test_views.py @@ -0,0 +1,117 @@ +import urllib.parse + +from django.test import Client, TestCase +from django.urls import reverse + +from virtualization.models import Cluster, ClusterGroup, ClusterType, VirtualMachine + + +class ClusterGroupTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + ClusterGroup.objects.bulk_create([ + ClusterGroup(name='Cluster Group 1', slug='cluster-group-1'), + ClusterGroup(name='Cluster Group 2', slug='cluster-group-2'), + ClusterGroup(name='Cluster Group 3', slug='cluster-group-3'), + ]) + + def test_clustergroup_list(self): + + url = reverse('virtualization:clustergroup_list') + + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + + +class ClusterTypeTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + ClusterType.objects.bulk_create([ + ClusterType(name='Cluster Type 1', slug='cluster-type-1'), + ClusterType(name='Cluster Type 2', slug='cluster-type-2'), + ClusterType(name='Cluster Type 3', slug='cluster-type-3'), + ]) + + def test_clustertype_list(self): + + url = reverse('virtualization:clustertype_list') + + response = self.client.get(url) + self.assertEqual(response.status_code, 200) + + +class ClusterTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + clustergroup = ClusterGroup(name='Cluster Group 1', slug='cluster-group-1') + clustergroup.save() + + clustertype = ClusterType(name='Cluster Type 1', slug='cluster-type-1') + clustertype.save() + + Cluster.objects.bulk_create([ + Cluster(name='Cluster 1', group=clustergroup, type=clustertype), + Cluster(name='Cluster 2', group=clustergroup, type=clustertype), + Cluster(name='Cluster 3', group=clustergroup, type=clustertype), + ]) + + def test_cluster_list(self): + + url = reverse('virtualization:cluster_list') + params = { + "group": ClusterGroup.objects.first().slug, + "type": ClusterType.objects.first().slug, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_cluster(self): + + cluster = Cluster.objects.first() + response = self.client.get(cluster.get_absolute_url()) + self.assertEqual(response.status_code, 200) + + +class VirtualMachineTestCase(TestCase): + + def setUp(self): + + self.client = Client() + + clustertype = ClusterType(name='Cluster Type 1', slug='cluster-type-1') + clustertype.save() + + cluster = Cluster(name='Cluster 1', type=clustertype) + cluster.save() + + VirtualMachine.objects.bulk_create([ + VirtualMachine(name='Virtual Machine 1', cluster=cluster), + VirtualMachine(name='Virtual Machine 2', cluster=cluster), + VirtualMachine(name='Virtual Machine 3', cluster=cluster), + ]) + + def test_virtualmachine_list(self): + + url = reverse('virtualization:virtualmachine_list') + params = { + "cluster_id": Cluster.objects.first().pk, + } + + response = self.client.get('{}?{}'.format(url, urllib.parse.urlencode(params))) + self.assertEqual(response.status_code, 200) + + def test_virtualmachine(self): + + virtualmachine = VirtualMachine.objects.first() + response = self.client.get(virtualmachine.get_absolute_url()) + self.assertEqual(response.status_code, 200)