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

Refactored the tests to remove a lot of boilerplate

Browse Source
This commit is contained in:
Jeremy Stretch 2018-08-03 11:39:26 -04:00
parent 1bdfcd1dbe
commit bd5e860be0
10 changed files with 153 additions and 279 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
netbox/circuits/tests/test_api.py
View File

@ -1,26 +1,21 @@
from __future__ import unicode_literals from __future__ import unicode_literals
from django.contrib.auth.models import User
from django.urls import reverse from django.urls import reverse
from rest_framework import status from rest_framework import status
from rest_framework.test import APITestCase
from circuits.constants import CIRCUIT_STATUS_ACTIVE, TERM_SIDE_A, TERM_SIDE_Z from circuits.constants import CIRCUIT_STATUS_ACTIVE, TERM_SIDE_A, TERM_SIDE_Z
from circuits.models import Circuit, CircuitTermination, CircuitType, Provider from circuits.models import Circuit, CircuitTermination, CircuitType, Provider
from dcim.models import Site from dcim.models import Site
from extras.constants import GRAPH_TYPE_PROVIDER from extras.constants import GRAPH_TYPE_PROVIDER
from extras.models import Graph from extras.models import Graph
from users.models import Token from utilities.testing import APITestCase
from utilities.testing import HttpStatusMixin
class ProviderTest(HttpStatusMixin, APITestCase): class ProviderTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(ProviderTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.provider1 = Provider.objects.create(name='Test Provider 1', slug='test-provider-1') self.provider1 = Provider.objects.create(name='Test Provider 1', slug='test-provider-1')
self.provider2 = Provider.objects.create(name='Test Provider 2', slug='test-provider-2') self.provider2 = Provider.objects.create(name='Test Provider 2', slug='test-provider-2')
@ -128,13 +123,11 @@ class ProviderTest(HttpStatusMixin, APITestCase):
self.assertEqual(Provider.objects.count(), 2) self.assertEqual(Provider.objects.count(), 2)
class CircuitTypeTest(HttpStatusMixin, APITestCase): class CircuitTypeTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(CircuitTypeTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.circuittype1 = CircuitType.objects.create(name='Test Circuit Type 1', slug='test-circuit-type-1') self.circuittype1 = CircuitType.objects.create(name='Test Circuit Type 1', slug='test-circuit-type-1')
self.circuittype2 = CircuitType.objects.create(name='Test Circuit Type 2', slug='test-circuit-type-2') self.circuittype2 = CircuitType.objects.create(name='Test Circuit Type 2', slug='test-circuit-type-2')
@ -195,13 +188,11 @@ class CircuitTypeTest(HttpStatusMixin, APITestCase):
self.assertEqual(CircuitType.objects.count(), 2) self.assertEqual(CircuitType.objects.count(), 2)
class CircuitTest(HttpStatusMixin, APITestCase): class CircuitTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(CircuitTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.provider1 = Provider.objects.create(name='Test Provider 1', slug='test-provider-1') self.provider1 = Provider.objects.create(name='Test Provider 1', slug='test-provider-1')
self.provider2 = Provider.objects.create(name='Test Provider 2', slug='test-provider-2') self.provider2 = Provider.objects.create(name='Test Provider 2', slug='test-provider-2')
@ -303,13 +294,11 @@ class CircuitTest(HttpStatusMixin, APITestCase):
self.assertEqual(Circuit.objects.count(), 2) self.assertEqual(Circuit.objects.count(), 2)
class CircuitTerminationTest(HttpStatusMixin, APITestCase): class CircuitTerminationTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(CircuitTerminationTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
provider = Provider.objects.create(name='Test Provider', slug='test-provider') provider = Provider.objects.create(name='Test Provider', slug='test-provider')
circuittype = CircuitType.objects.create(name='Test Circuit Type', slug='test-circuit-type') circuittype = CircuitType.objects.create(name='Test Circuit Type', slug='test-circuit-type')

196
netbox/dcim/tests/test_api.py
View File

@ -1,9 +1,7 @@
from __future__ import unicode_literals from __future__ import unicode_literals
from django.contrib.auth.models import User
from django.urls import reverse from django.urls import reverse
from rest_framework import status from rest_framework import status
from rest_framework.test import APITestCase
from dcim.constants import ( from dcim.constants import (
IFACE_FF_1GE_FIXED, IFACE_FF_LAG, IFACE_MODE_TAGGED, SITE_STATUS_ACTIVE, SUBDEVICE_ROLE_CHILD, IFACE_FF_1GE_FIXED, IFACE_FF_LAG, IFACE_MODE_TAGGED, SITE_STATUS_ACTIVE, SUBDEVICE_ROLE_CHILD,
@ -17,17 +15,14 @@ from dcim.models import (
) )
from ipam.models import VLAN from ipam.models import VLAN
from extras.models import Graph, GRAPH_TYPE_INTERFACE, GRAPH_TYPE_SITE from extras.models import Graph, GRAPH_TYPE_INTERFACE, GRAPH_TYPE_SITE
from users.models import Token from utilities.testing import APITestCase
from utilities.testing import HttpStatusMixin
class RegionTest(HttpStatusMixin, APITestCase): class RegionTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(RegionTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.region1 = Region.objects.create(name='Test Region 1', slug='test-region-1') self.region1 = Region.objects.create(name='Test Region 1', slug='test-region-1')
self.region2 = Region.objects.create(name='Test Region 2', slug='test-region-2') self.region2 = Region.objects.create(name='Test Region 2', slug='test-region-2')
@ -114,13 +109,11 @@ class RegionTest(HttpStatusMixin, APITestCase):
self.assertEqual(Region.objects.count(), 2) self.assertEqual(Region.objects.count(), 2)
class SiteTest(HttpStatusMixin, APITestCase): class SiteTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(SiteTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.region1 = Region.objects.create(name='Test Region 1', slug='test-region-1') self.region1 = Region.objects.create(name='Test Region 1', slug='test-region-1')
self.region2 = Region.objects.create(name='Test Region 2', slug='test-region-2') self.region2 = Region.objects.create(name='Test Region 2', slug='test-region-2')
@ -241,13 +234,11 @@ class SiteTest(HttpStatusMixin, APITestCase):
self.assertEqual(Site.objects.count(), 2) self.assertEqual(Site.objects.count(), 2)
class RackGroupTest(HttpStatusMixin, APITestCase): class RackGroupTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(RackGroupTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.site1 = Site.objects.create(name='Test Site 1', slug='test-site-1') self.site1 = Site.objects.create(name='Test Site 1', slug='test-site-1')
self.site2 = Site.objects.create(name='Test Site 2', slug='test-site-2') self.site2 = Site.objects.create(name='Test Site 2', slug='test-site-2')
@ -343,13 +334,11 @@ class RackGroupTest(HttpStatusMixin, APITestCase):
self.assertEqual(RackGroup.objects.count(), 2) self.assertEqual(RackGroup.objects.count(), 2)
class RackRoleTest(HttpStatusMixin, APITestCase): class RackRoleTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(RackRoleTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.rackrole1 = RackRole.objects.create(name='Test Rack Role 1', slug='test-rack-role-1', color='ff0000') self.rackrole1 = RackRole.objects.create(name='Test Rack Role 1', slug='test-rack-role-1', color='ff0000')
self.rackrole2 = RackRole.objects.create(name='Test Rack Role 2', slug='test-rack-role-2', color='00ff00') self.rackrole2 = RackRole.objects.create(name='Test Rack Role 2', slug='test-rack-role-2', color='00ff00')
@ -443,13 +432,11 @@ class RackRoleTest(HttpStatusMixin, APITestCase):
self.assertEqual(RackRole.objects.count(), 2) self.assertEqual(RackRole.objects.count(), 2)
class RackTest(HttpStatusMixin, APITestCase): class RackTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(RackTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.site1 = Site.objects.create(name='Test Site 1', slug='test-site-1') self.site1 = Site.objects.create(name='Test Site 1', slug='test-site-1')
self.site2 = Site.objects.create(name='Test Site 2', slug='test-site-2') self.site2 = Site.objects.create(name='Test Site 2', slug='test-site-2')
@ -569,25 +556,22 @@ class RackTest(HttpStatusMixin, APITestCase):
self.assertEqual(Rack.objects.count(), 2) self.assertEqual(Rack.objects.count(), 2)
class RackReservationTest(HttpStatusMixin, APITestCase): class RackReservationTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(RackReservationTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.user1 = user
self.site1 = Site.objects.create(name='Test Site 1', slug='test-site-1') self.site1 = Site.objects.create(name='Test Site 1', slug='test-site-1')
self.rack1 = Rack.objects.create(site=self.site1, name='Test Rack 1') self.rack1 = Rack.objects.create(site=self.site1, name='Test Rack 1')
self.rackreservation1 = RackReservation.objects.create( self.rackreservation1 = RackReservation.objects.create(
rack=self.rack1, units=[1, 2, 3], user=user, description='Reservation #1', rack=self.rack1, units=[1, 2, 3], user=self.user, description='Reservation #1',
) )
self.rackreservation2 = RackReservation.objects.create( self.rackreservation2 = RackReservation.objects.create(
rack=self.rack1, units=[4, 5, 6], user=user, description='Reservation #2', rack=self.rack1, units=[4, 5, 6], user=self.user, description='Reservation #2',
) )
self.rackreservation3 = RackReservation.objects.create( self.rackreservation3 = RackReservation.objects.create(
rack=self.rack1, units=[7, 8, 9], user=user, description='Reservation #3', rack=self.rack1, units=[7, 8, 9], user=self.user, description='Reservation #3',
) )
def test_get_rackreservation(self): def test_get_rackreservation(self):
@ -609,7 +593,7 @@ class RackReservationTest(HttpStatusMixin, APITestCase):
data = { data = {
'rack': self.rack1.pk, 'rack': self.rack1.pk,
'units': [10, 11, 12], 'units': [10, 11, 12],
'user': self.user1.pk, 'user': self.user.pk,
'description': 'Fourth reservation', 'description': 'Fourth reservation',
} }
@ -630,19 +614,19 @@ class RackReservationTest(HttpStatusMixin, APITestCase):
{ {
'rack': self.rack1.pk, 'rack': self.rack1.pk,
'units': [10, 11, 12], 'units': [10, 11, 12],
'user': self.user1.pk, 'user': self.user.pk,
'description': 'Reservation #4', 'description': 'Reservation #4',
}, },
{ {
'rack': self.rack1.pk, 'rack': self.rack1.pk,
'units': [13, 14, 15], 'units': [13, 14, 15],
'user': self.user1.pk, 'user': self.user.pk,
'description': 'Reservation #5', 'description': 'Reservation #5',
}, },
{ {
'rack': self.rack1.pk, 'rack': self.rack1.pk,
'units': [16, 17, 18], 'units': [16, 17, 18],
'user': self.user1.pk, 'user': self.user.pk,
'description': 'Reservation #6', 'description': 'Reservation #6',
}, },
] ]
@ -661,7 +645,7 @@ class RackReservationTest(HttpStatusMixin, APITestCase):
data = { data = {
'rack': self.rack1.pk, 'rack': self.rack1.pk,
'units': [10, 11, 12], 'units': [10, 11, 12],
'user': self.user1.pk, 'user': self.user.pk,
'description': 'Modified reservation', 'description': 'Modified reservation',
} }
@ -683,13 +667,11 @@ class RackReservationTest(HttpStatusMixin, APITestCase):
self.assertEqual(RackReservation.objects.count(), 2) self.assertEqual(RackReservation.objects.count(), 2)
class ManufacturerTest(HttpStatusMixin, APITestCase): class ManufacturerTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(ManufacturerTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.manufacturer1 = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') self.manufacturer1 = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
self.manufacturer2 = Manufacturer.objects.create(name='Test Manufacturer 2', slug='test-manufacturer-2') self.manufacturer2 = Manufacturer.objects.create(name='Test Manufacturer 2', slug='test-manufacturer-2')
@ -776,13 +758,11 @@ class ManufacturerTest(HttpStatusMixin, APITestCase):
self.assertEqual(Manufacturer.objects.count(), 2) self.assertEqual(Manufacturer.objects.count(), 2)
class DeviceTypeTest(HttpStatusMixin, APITestCase): class DeviceTypeTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(DeviceTypeTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.manufacturer1 = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') self.manufacturer1 = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
self.manufacturer2 = Manufacturer.objects.create(name='Test Manufacturer 2', slug='test-manufacturer-2') self.manufacturer2 = Manufacturer.objects.create(name='Test Manufacturer 2', slug='test-manufacturer-2')
@ -884,13 +864,11 @@ class DeviceTypeTest(HttpStatusMixin, APITestCase):
self.assertEqual(DeviceType.objects.count(), 2) self.assertEqual(DeviceType.objects.count(), 2)
class ConsolePortTemplateTest(HttpStatusMixin, APITestCase): class ConsolePortTemplateTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(ConsolePortTemplateTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') self.manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
self.devicetype = DeviceType.objects.create( self.devicetype = DeviceType.objects.create(
@ -986,13 +964,11 @@ class ConsolePortTemplateTest(HttpStatusMixin, APITestCase):
self.assertEqual(ConsolePortTemplate.objects.count(), 2) self.assertEqual(ConsolePortTemplate.objects.count(), 2)
class ConsoleServerPortTemplateTest(HttpStatusMixin, APITestCase): class ConsoleServerPortTemplateTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(ConsoleServerPortTemplateTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') self.manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
self.devicetype = DeviceType.objects.create( self.devicetype = DeviceType.objects.create(
@ -1088,13 +1064,11 @@ class ConsoleServerPortTemplateTest(HttpStatusMixin, APITestCase):
self.assertEqual(ConsoleServerPortTemplate.objects.count(), 2) self.assertEqual(ConsoleServerPortTemplate.objects.count(), 2)
class PowerPortTemplateTest(HttpStatusMixin, APITestCase): class PowerPortTemplateTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(PowerPortTemplateTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') self.manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
self.devicetype = DeviceType.objects.create( self.devicetype = DeviceType.objects.create(
@ -1190,13 +1164,11 @@ class PowerPortTemplateTest(HttpStatusMixin, APITestCase):
self.assertEqual(PowerPortTemplate.objects.count(), 2) self.assertEqual(PowerPortTemplate.objects.count(), 2)
class PowerOutletTemplateTest(HttpStatusMixin, APITestCase): class PowerOutletTemplateTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(PowerOutletTemplateTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') self.manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
self.devicetype = DeviceType.objects.create( self.devicetype = DeviceType.objects.create(
@ -1292,13 +1264,11 @@ class PowerOutletTemplateTest(HttpStatusMixin, APITestCase):
self.assertEqual(PowerOutletTemplate.objects.count(), 2) self.assertEqual(PowerOutletTemplate.objects.count(), 2)
class InterfaceTemplateTest(HttpStatusMixin, APITestCase): class InterfaceTemplateTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(InterfaceTemplateTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') self.manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
self.devicetype = DeviceType.objects.create( self.devicetype = DeviceType.objects.create(
@ -1394,13 +1364,11 @@ class InterfaceTemplateTest(HttpStatusMixin, APITestCase):
self.assertEqual(InterfaceTemplate.objects.count(), 2) self.assertEqual(InterfaceTemplate.objects.count(), 2)
class DeviceBayTemplateTest(HttpStatusMixin, APITestCase): class DeviceBayTemplateTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(DeviceBayTemplateTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') self.manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
self.devicetype = DeviceType.objects.create( self.devicetype = DeviceType.objects.create(
@ -1496,13 +1464,11 @@ class DeviceBayTemplateTest(HttpStatusMixin, APITestCase):
self.assertEqual(DeviceBayTemplate.objects.count(), 2) self.assertEqual(DeviceBayTemplate.objects.count(), 2)
class DeviceRoleTest(HttpStatusMixin, APITestCase): class DeviceRoleTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(DeviceRoleTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.devicerole1 = DeviceRole.objects.create( self.devicerole1 = DeviceRole.objects.create(
name='Test Device Role 1', slug='test-device-role-1', color='ff0000' name='Test Device Role 1', slug='test-device-role-1', color='ff0000'
@ -1602,13 +1568,11 @@ class DeviceRoleTest(HttpStatusMixin, APITestCase):
self.assertEqual(DeviceRole.objects.count(), 2) self.assertEqual(DeviceRole.objects.count(), 2)
class PlatformTest(HttpStatusMixin, APITestCase): class PlatformTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(PlatformTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.platform1 = Platform.objects.create(name='Test Platform 1', slug='test-platform-1') self.platform1 = Platform.objects.create(name='Test Platform 1', slug='test-platform-1')
self.platform2 = Platform.objects.create(name='Test Platform 2', slug='test-platform-2') self.platform2 = Platform.objects.create(name='Test Platform 2', slug='test-platform-2')
@ -1695,13 +1659,11 @@ class PlatformTest(HttpStatusMixin, APITestCase):
self.assertEqual(Platform.objects.count(), 2) self.assertEqual(Platform.objects.count(), 2)
class DeviceTest(HttpStatusMixin, APITestCase): class DeviceTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(DeviceTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.site1 = Site.objects.create(name='Test Site 1', slug='test-site-1') self.site1 = Site.objects.create(name='Test Site 1', slug='test-site-1')
self.site2 = Site.objects.create(name='Test Site 2', slug='test-site-2') self.site2 = Site.objects.create(name='Test Site 2', slug='test-site-2')
@ -1823,13 +1785,11 @@ class DeviceTest(HttpStatusMixin, APITestCase):
self.assertEqual(Device.objects.count(), 2) self.assertEqual(Device.objects.count(), 2)
class ConsolePortTest(HttpStatusMixin, APITestCase): class ConsolePortTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(ConsolePortTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
site = Site.objects.create(name='Test Site 1', slug='test-site-1') site = Site.objects.create(name='Test Site 1', slug='test-site-1')
manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
@ -1930,13 +1890,11 @@ class ConsolePortTest(HttpStatusMixin, APITestCase):
self.assertEqual(ConsolePort.objects.count(), 2) self.assertEqual(ConsolePort.objects.count(), 2)
class ConsoleServerPortTest(HttpStatusMixin, APITestCase): class ConsoleServerPortTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(ConsoleServerPortTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
site = Site.objects.create(name='Test Site 1', slug='test-site-1') site = Site.objects.create(name='Test Site 1', slug='test-site-1')
manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
@ -2033,13 +1991,11 @@ class ConsoleServerPortTest(HttpStatusMixin, APITestCase):
self.assertEqual(ConsoleServerPort.objects.count(), 2) self.assertEqual(ConsoleServerPort.objects.count(), 2)
class PowerPortTest(HttpStatusMixin, APITestCase): class PowerPortTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(PowerPortTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
site = Site.objects.create(name='Test Site 1', slug='test-site-1') site = Site.objects.create(name='Test Site 1', slug='test-site-1')
manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
@ -2140,13 +2096,11 @@ class PowerPortTest(HttpStatusMixin, APITestCase):
self.assertEqual(PowerPort.objects.count(), 2) self.assertEqual(PowerPort.objects.count(), 2)
class PowerOutletTest(HttpStatusMixin, APITestCase): class PowerOutletTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(PowerOutletTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
site = Site.objects.create(name='Test Site 1', slug='test-site-1') site = Site.objects.create(name='Test Site 1', slug='test-site-1')
manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
@ -2243,13 +2197,11 @@ class PowerOutletTest(HttpStatusMixin, APITestCase):
self.assertEqual(PowerOutlet.objects.count(), 2) self.assertEqual(PowerOutlet.objects.count(), 2)
class InterfaceTest(HttpStatusMixin, APITestCase): class InterfaceTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(InterfaceTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
site = Site.objects.create(name='Test Site 1', slug='test-site-1') site = Site.objects.create(name='Test Site 1', slug='test-site-1')
manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
@ -2433,13 +2385,11 @@ class InterfaceTest(HttpStatusMixin, APITestCase):
self.assertEqual(Interface.objects.count(), 2) self.assertEqual(Interface.objects.count(), 2)
class DeviceBayTest(HttpStatusMixin, APITestCase): class DeviceBayTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(DeviceBayTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
site = Site.objects.create(name='Test Site 1', slug='test-site-1') site = Site.objects.create(name='Test Site 1', slug='test-site-1')
manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
@ -2548,13 +2498,11 @@ class DeviceBayTest(HttpStatusMixin, APITestCase):
self.assertEqual(DeviceBay.objects.count(), 2) self.assertEqual(DeviceBay.objects.count(), 2)
class InventoryItemTest(HttpStatusMixin, APITestCase): class InventoryItemTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(InventoryItemTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
site = Site.objects.create(name='Test Site 1', slug='test-site-1') site = Site.objects.create(name='Test Site 1', slug='test-site-1')
self.manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') self.manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
@ -2666,13 +2614,11 @@ class InventoryItemTest(HttpStatusMixin, APITestCase):
self.assertEqual(InventoryItem.objects.count(), 2) self.assertEqual(InventoryItem.objects.count(), 2)
class ConsoleConnectionTest(HttpStatusMixin, APITestCase): class ConsoleConnectionTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(ConsoleConnectionTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
site = Site.objects.create(name='Test Site 1', slug='test-site-1') site = Site.objects.create(name='Test Site 1', slug='test-site-1')
manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
@ -2709,13 +2655,11 @@ class ConsoleConnectionTest(HttpStatusMixin, APITestCase):
self.assertEqual(response.data['count'], 3) self.assertEqual(response.data['count'], 3)
class PowerConnectionTest(HttpStatusMixin, APITestCase): class PowerConnectionTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(PowerConnectionTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
site = Site.objects.create(name='Test Site 1', slug='test-site-1') site = Site.objects.create(name='Test Site 1', slug='test-site-1')
manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
@ -2752,13 +2696,11 @@ class PowerConnectionTest(HttpStatusMixin, APITestCase):
self.assertEqual(response.data['count'], 3) self.assertEqual(response.data['count'], 3)
class InterfaceConnectionTest(HttpStatusMixin, APITestCase): class InterfaceConnectionTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(InterfaceConnectionTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
site = Site.objects.create(name='Test Site 1', slug='test-site-1') site = Site.objects.create(name='Test Site 1', slug='test-site-1')
manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')
@ -2879,13 +2821,11 @@ class InterfaceConnectionTest(HttpStatusMixin, APITestCase):
self.assertEqual(InterfaceConnection.objects.count(), 2) self.assertEqual(InterfaceConnection.objects.count(), 2)
class ConnectedDeviceTest(HttpStatusMixin, APITestCase): class ConnectedDeviceTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(ConnectedDeviceTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.site1 = Site.objects.create(name='Test Site 1', slug='test-site-1') self.site1 = Site.objects.create(name='Test Site 1', slug='test-site-1')
self.site2 = Site.objects.create(name='Test Site 2', slug='test-site-2') self.site2 = Site.objects.create(name='Test Site 2', slug='test-site-2')
@ -2921,13 +2861,11 @@ class ConnectedDeviceTest(HttpStatusMixin, APITestCase):
self.assertEqual(response.data['name'], self.device1.name) self.assertEqual(response.data['name'], self.device1.name)
class VirtualChassisTest(HttpStatusMixin, APITestCase): class VirtualChassisTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(VirtualChassisTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
site = Site.objects.create(name='Test Site', slug='test-site') site = Site.objects.create(name='Test Site', slug='test-site')
manufacturer = Manufacturer.objects.create(name='Test Manufacturer', slug='test-manufacturer') manufacturer = Manufacturer.objects.create(name='Test Manufacturer', slug='test-manufacturer')

29
netbox/extras/tests/test_api.py
View File

@ -1,27 +1,22 @@
from __future__ import unicode_literals from __future__ import unicode_literals
from django.contrib.auth.models import User
from django.contrib.contenttypes.models import ContentType from django.contrib.contenttypes.models import ContentType
from django.urls import reverse from django.urls import reverse
from rest_framework import status from rest_framework import status
from rest_framework.test import APITestCase
from taggit.models import Tag from taggit.models import Tag
from dcim.models import Device, DeviceRole, DeviceType, Manufacturer, Platform, Region, Site from dcim.models import Device, DeviceRole, DeviceType, Manufacturer, Platform, Region, Site
from extras.constants import GRAPH_TYPE_SITE from extras.constants import GRAPH_TYPE_SITE
from extras.models import ConfigContext, Graph, ExportTemplate from extras.models import ConfigContext, Graph, ExportTemplate
from tenancy.models import Tenant, TenantGroup from tenancy.models import Tenant, TenantGroup
from users.models import Token from utilities.testing import APITestCase
from utilities.testing import HttpStatusMixin
class GraphTest(HttpStatusMixin, APITestCase): class GraphTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(GraphTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.graph1 = Graph.objects.create( self.graph1 = Graph.objects.create(
type=GRAPH_TYPE_SITE, name='Test Graph 1', source='http://example.com/graphs.py?site={{ obj.name }}&foo=1' type=GRAPH_TYPE_SITE, name='Test Graph 1', source='http://example.com/graphs.py?site={{ obj.name }}&foo=1'
@ -121,13 +116,11 @@ class GraphTest(HttpStatusMixin, APITestCase):
self.assertEqual(Graph.objects.count(), 2) self.assertEqual(Graph.objects.count(), 2)
class ExportTemplateTest(HttpStatusMixin, APITestCase): class ExportTemplateTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(ExportTemplateTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.content_type = ContentType.objects.get_for_model(Device) self.content_type = ContentType.objects.get_for_model(Device)
self.exporttemplate1 = ExportTemplate.objects.create( self.exporttemplate1 = ExportTemplate.objects.create(
@ -230,13 +223,11 @@ class ExportTemplateTest(HttpStatusMixin, APITestCase):
self.assertEqual(ExportTemplate.objects.count(), 2) self.assertEqual(ExportTemplate.objects.count(), 2)
class TagTest(HttpStatusMixin, APITestCase): class TagTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(TagTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.tag1 = Tag.objects.create(name='Test Tag 1', slug='test-tag-1') self.tag1 = Tag.objects.create(name='Test Tag 1', slug='test-tag-1')
self.tag2 = Tag.objects.create(name='Test Tag 2', slug='test-tag-2') self.tag2 = Tag.objects.create(name='Test Tag 2', slug='test-tag-2')
@ -323,13 +314,11 @@ class TagTest(HttpStatusMixin, APITestCase):
self.assertEqual(Tag.objects.count(), 2) self.assertEqual(Tag.objects.count(), 2)
class ConfigContextTest(HttpStatusMixin, APITestCase): class ConfigContextTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(ConfigContextTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.configcontext1 = ConfigContext.objects.create( self.configcontext1 = ConfigContext.objects.create(
name='Test Config Context 1', name='Test Config Context 1',

11
netbox/extras/tests/test_customfields.py
View File

@ -2,18 +2,15 @@ from __future__ import unicode_literals
from datetime import date from datetime import date
from django.contrib.auth.models import User
from django.contrib.contenttypes.models import ContentType from django.contrib.contenttypes.models import ContentType
from django.test import TestCase from django.test import TestCase
from django.urls import reverse from django.urls import reverse
from rest_framework import status from rest_framework import status
from rest_framework.test import APITestCase
from dcim.models import Site from dcim.models import Site
from extras.constants import CF_TYPE_TEXT, CF_TYPE_INTEGER, CF_TYPE_BOOLEAN, CF_TYPE_DATE, CF_TYPE_SELECT, CF_TYPE_URL from extras.constants import CF_TYPE_TEXT, CF_TYPE_INTEGER, CF_TYPE_BOOLEAN, CF_TYPE_DATE, CF_TYPE_SELECT, CF_TYPE_URL
from extras.models import CustomField, CustomFieldValue, CustomFieldChoice from extras.models import CustomField, CustomFieldValue, CustomFieldChoice
from users.models import Token from utilities.testing import APITestCase
from utilities.testing import HttpStatusMixin
class CustomFieldTest(TestCase): class CustomFieldTest(TestCase):
@ -102,13 +99,11 @@ class CustomFieldTest(TestCase):
cf.delete() cf.delete()
class CustomFieldAPITest(HttpStatusMixin, APITestCase): class CustomFieldAPITest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(CustomFieldAPITest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
content_type = ContentType.objects.get_for_model(Site) content_type = ContentType.objects.get_for_model(Site)

11
netbox/extras/tests/test_tags.py
View File

@ -1,25 +1,20 @@
from __future__ import unicode_literals from __future__ import unicode_literals
from django.contrib.auth.models import User
from django.urls import reverse from django.urls import reverse
from rest_framework import status from rest_framework import status
from rest_framework.test import APITestCase
from dcim.models import Site from dcim.models import Site
from users.models import Token from utilities.testing import APITestCase
from utilities.testing import HttpStatusMixin
class TaggedItemTest(HttpStatusMixin, APITestCase): class TaggedItemTest(APITestCase):
""" """
Test the application of Tags to and item (a Site, for example) upon creation (POST) and modification (PATCH). Test the application of Tags to and item (a Site, for example) upon creation (POST) and modification (PATCH).
""" """
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(TaggedItemTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
def test_create_tagged_item(self): def test_create_tagged_item(self):

59
netbox/ipam/tests/test_api.py
View File

@ -1,25 +1,20 @@
from __future__ import unicode_literals from __future__ import unicode_literals
from django.contrib.auth.models import User
from django.urls import reverse from django.urls import reverse
from netaddr import IPNetwork from netaddr import IPNetwork
from rest_framework import status from rest_framework import status
from rest_framework.test import APITestCase
from dcim.models import Device, DeviceRole, DeviceType, Manufacturer, Site from dcim.models import Device, DeviceRole, DeviceType, Manufacturer, Site
from ipam.constants import IP_PROTOCOL_TCP, IP_PROTOCOL_UDP from ipam.constants import IP_PROTOCOL_TCP, IP_PROTOCOL_UDP
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 users.models import Token from utilities.testing import APITestCase
from utilities.testing import HttpStatusMixin
class VRFTest(HttpStatusMixin, APITestCase): class VRFTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(VRFTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.vrf1 = VRF.objects.create(name='Test VRF 1', rd='65000:1') self.vrf1 = VRF.objects.create(name='Test VRF 1', rd='65000:1')
self.vrf2 = VRF.objects.create(name='Test VRF 2', rd='65000:2') self.vrf2 = VRF.objects.create(name='Test VRF 2', rd='65000:2')
@ -106,13 +101,11 @@ class VRFTest(HttpStatusMixin, APITestCase):
self.assertEqual(VRF.objects.count(), 2) self.assertEqual(VRF.objects.count(), 2)
class RIRTest(HttpStatusMixin, APITestCase): class RIRTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(RIRTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.rir1 = RIR.objects.create(name='Test RIR 1', slug='test-rir-1') self.rir1 = RIR.objects.create(name='Test RIR 1', slug='test-rir-1')
self.rir2 = RIR.objects.create(name='Test RIR 2', slug='test-rir-2') self.rir2 = RIR.objects.create(name='Test RIR 2', slug='test-rir-2')
@ -199,13 +192,11 @@ class RIRTest(HttpStatusMixin, APITestCase):
self.assertEqual(RIR.objects.count(), 2) self.assertEqual(RIR.objects.count(), 2)
class AggregateTest(HttpStatusMixin, APITestCase): class AggregateTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(AggregateTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.rir1 = RIR.objects.create(name='Test RIR 1', slug='test-rir-1') self.rir1 = RIR.objects.create(name='Test RIR 1', slug='test-rir-1')
self.rir2 = RIR.objects.create(name='Test RIR 2', slug='test-rir-2') self.rir2 = RIR.objects.create(name='Test RIR 2', slug='test-rir-2')
@ -294,13 +285,11 @@ class AggregateTest(HttpStatusMixin, APITestCase):
self.assertEqual(Aggregate.objects.count(), 2) self.assertEqual(Aggregate.objects.count(), 2)
class RoleTest(HttpStatusMixin, APITestCase): class RoleTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(RoleTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.role1 = Role.objects.create(name='Test Role 1', slug='test-role-1') self.role1 = Role.objects.create(name='Test Role 1', slug='test-role-1')
self.role2 = Role.objects.create(name='Test Role 2', slug='test-role-2') self.role2 = Role.objects.create(name='Test Role 2', slug='test-role-2')
@ -387,13 +376,11 @@ class RoleTest(HttpStatusMixin, APITestCase):
self.assertEqual(Role.objects.count(), 2) self.assertEqual(Role.objects.count(), 2)
class PrefixTest(HttpStatusMixin, APITestCase): class PrefixTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(PrefixTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.site1 = Site.objects.create(name='Test Site 1', slug='test-site-1') self.site1 = Site.objects.create(name='Test Site 1', slug='test-site-1')
self.vrf1 = VRF.objects.create(name='Test VRF 1', rd='65000:1') self.vrf1 = VRF.objects.create(name='Test VRF 1', rd='65000:1')
@ -614,13 +601,11 @@ class PrefixTest(HttpStatusMixin, APITestCase):
self.assertEqual(len(response.data), 8) self.assertEqual(len(response.data), 8)
class IPAddressTest(HttpStatusMixin, APITestCase): class IPAddressTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(IPAddressTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.vrf1 = VRF.objects.create(name='Test VRF 1', rd='65000:1') self.vrf1 = VRF.objects.create(name='Test VRF 1', rd='65000:1')
self.ipaddress1 = IPAddress.objects.create(address=IPNetwork('192.168.0.1/24')) self.ipaddress1 = IPAddress.objects.create(address=IPNetwork('192.168.0.1/24'))
@ -705,13 +690,11 @@ class IPAddressTest(HttpStatusMixin, APITestCase):
self.assertEqual(IPAddress.objects.count(), 2) self.assertEqual(IPAddress.objects.count(), 2)
class VLANGroupTest(HttpStatusMixin, APITestCase): class VLANGroupTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(VLANGroupTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.vlangroup1 = VLANGroup.objects.create(name='Test VLAN Group 1', slug='test-vlan-group-1') self.vlangroup1 = VLANGroup.objects.create(name='Test VLAN Group 1', slug='test-vlan-group-1')
self.vlangroup2 = VLANGroup.objects.create(name='Test VLAN Group 2', slug='test-vlan-group-2') self.vlangroup2 = VLANGroup.objects.create(name='Test VLAN Group 2', slug='test-vlan-group-2')
@ -798,13 +781,11 @@ class VLANGroupTest(HttpStatusMixin, APITestCase):
self.assertEqual(VLANGroup.objects.count(), 2) self.assertEqual(VLANGroup.objects.count(), 2)
class VLANTest(HttpStatusMixin, APITestCase): class VLANTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(VLANTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.vlan1 = VLAN.objects.create(vid=1, name='Test VLAN 1') self.vlan1 = VLAN.objects.create(vid=1, name='Test VLAN 1')
self.vlan2 = VLAN.objects.create(vid=2, name='Test VLAN 2') self.vlan2 = VLAN.objects.create(vid=2, name='Test VLAN 2')
@ -891,13 +872,11 @@ class VLANTest(HttpStatusMixin, APITestCase):
self.assertEqual(VLAN.objects.count(), 2) self.assertEqual(VLAN.objects.count(), 2)
class ServiceTest(HttpStatusMixin, APITestCase): class ServiceTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(ServiceTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
site = Site.objects.create(name='Test Site 1', slug='test-site-1') site = Site.objects.create(name='Test Site 1', slug='test-site-1')
manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1') manufacturer = Manufacturer.objects.create(name='Test Manufacturer 1', slug='test-manufacturer-1')

29
netbox/secrets/tests/test_api.py
View File

@ -2,15 +2,12 @@ from __future__ import unicode_literals
import base64 import base64
from django.contrib.auth.models import User
from django.urls import reverse from django.urls import reverse
from rest_framework import status from rest_framework import status
from rest_framework.test import APITestCase
from dcim.models import Device, DeviceRole, DeviceType, Manufacturer, Site from dcim.models import Device, DeviceRole, DeviceType, Manufacturer, Site
from secrets.models import Secret, SecretRole, SessionKey, UserKey from secrets.models import Secret, SecretRole, SessionKey, UserKey
from users.models import Token from utilities.testing import APITestCase
from utilities.testing import HttpStatusMixin
# Dummy RSA key pair for testing use only # Dummy RSA key pair for testing use only
PRIVATE_KEY = """-----BEGIN RSA PRIVATE KEY----- PRIVATE_KEY = """-----BEGIN RSA PRIVATE KEY-----
@ -52,13 +49,11 @@ qQIDAQAB
-----END PUBLIC KEY-----""" -----END PUBLIC KEY-----"""
class SecretRoleTest(HttpStatusMixin, APITestCase): class SecretRoleTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(SecretRoleTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.secretrole1 = SecretRole.objects.create(name='Test Secret Role 1', slug='test-secret-role-1') self.secretrole1 = SecretRole.objects.create(name='Test Secret Role 1', slug='test-secret-role-1')
self.secretrole2 = SecretRole.objects.create(name='Test Secret Role 2', slug='test-secret-role-2') self.secretrole2 = SecretRole.objects.create(name='Test Secret Role 2', slug='test-secret-role-2')
@ -145,21 +140,20 @@ class SecretRoleTest(HttpStatusMixin, APITestCase):
self.assertEqual(SecretRole.objects.count(), 2) self.assertEqual(SecretRole.objects.count(), 2)
class SecretTest(HttpStatusMixin, APITestCase): class SecretTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(SecretTest, self).setUp()
token = Token.objects.create(user=user)
userkey = UserKey(user=user, public_key=PUBLIC_KEY) userkey = UserKey(user=self.user, public_key=PUBLIC_KEY)
userkey.save() userkey.save()
self.master_key = userkey.get_master_key(PRIVATE_KEY) self.master_key = userkey.get_master_key(PRIVATE_KEY)
session_key = SessionKey(userkey=userkey) session_key = SessionKey(userkey=userkey)
session_key.save(self.master_key) session_key.save(self.master_key)
self.header = { self.header = {
'HTTP_AUTHORIZATION': 'Token {}'.format(token.key), 'HTTP_AUTHORIZATION': 'Token {}'.format(self.token.key),
'HTTP_X_SESSION_KEY': base64.b64encode(session_key.key), 'HTTP_X_SESSION_KEY': base64.b64encode(session_key.key),
} }
@ -288,21 +282,20 @@ class SecretTest(HttpStatusMixin, APITestCase):
self.assertEqual(Secret.objects.count(), 2) self.assertEqual(Secret.objects.count(), 2)
class GetSessionKeyTest(HttpStatusMixin, APITestCase): class GetSessionKeyTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(GetSessionKeyTest, self).setUp()
token = Token.objects.create(user=user)
userkey = UserKey(user=user, public_key=PUBLIC_KEY) userkey = UserKey(user=self.user, public_key=PUBLIC_KEY)
userkey.save() userkey.save()
master_key = userkey.get_master_key(PRIVATE_KEY) master_key = userkey.get_master_key(PRIVATE_KEY)
self.session_key = SessionKey(userkey=userkey) self.session_key = SessionKey(userkey=userkey)
self.session_key.save(master_key) self.session_key.save(master_key)
self.header = { self.header = {
'HTTP_AUTHORIZATION': 'Token {}'.format(token.key), 'HTTP_AUTHORIZATION': 'Token {}'.format(self.token.key),
} }
def test_get_session_key(self): def test_get_session_key(self):

17
netbox/tenancy/tests/test_api.py
View File

@ -1,22 +1,17 @@
from __future__ import unicode_literals from __future__ import unicode_literals
from django.contrib.auth.models import User
from django.urls import reverse from django.urls import reverse
from rest_framework import status from rest_framework import status
from rest_framework.test import APITestCase
from tenancy.models import Tenant, TenantGroup from tenancy.models import Tenant, TenantGroup
from users.models import Token from utilities.testing import APITestCase
from utilities.testing import HttpStatusMixin
class TenantGroupTest(HttpStatusMixin, APITestCase): class TenantGroupTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(TenantGroupTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.tenantgroup1 = TenantGroup.objects.create(name='Test Tenant Group 1', slug='test-tenant-group-1') self.tenantgroup1 = TenantGroup.objects.create(name='Test Tenant Group 1', slug='test-tenant-group-1')
self.tenantgroup2 = TenantGroup.objects.create(name='Test Tenant Group 2', slug='test-tenant-group-2') self.tenantgroup2 = TenantGroup.objects.create(name='Test Tenant Group 2', slug='test-tenant-group-2')
@ -103,13 +98,11 @@ class TenantGroupTest(HttpStatusMixin, APITestCase):
self.assertEqual(TenantGroup.objects.count(), 2) self.assertEqual(TenantGroup.objects.count(), 2)
class TenantTest(HttpStatusMixin, APITestCase): class TenantTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(TenantTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.tenantgroup1 = TenantGroup.objects.create(name='Test Tenant Group 1', slug='test-tenant-group-1') self.tenantgroup1 = TenantGroup.objects.create(name='Test Tenant Group 1', slug='test-tenant-group-1')
self.tenantgroup2 = TenantGroup.objects.create(name='Test Tenant Group 2', slug='test-tenant-group-2') self.tenantgroup2 = TenantGroup.objects.create(name='Test Tenant Group 2', slug='test-tenant-group-2')

22
netbox/utilities/testing.py
View File

@ -1,11 +1,25 @@
from __future__ import unicode_literals from __future__ import unicode_literals
from django.contrib.auth.models import User
from rest_framework.test import APITestCase as _APITestCase
from users.models import Token
class APITestCase(_APITestCase):
def setUp(self):
"""
Create a superuser and token for API calls.
"""
self.user = User.objects.create(username='testuser', is_superuser=True)
self.token = Token.objects.create(user=self.user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(self.token.key)}
class HttpStatusMixin(object):
"""
Custom mixin to provide more detail in the event of an unexpected HTTP response.
"""
def assertHttpStatus(self, response, expected_status): def assertHttpStatus(self, response, expected_status):
"""
Provide more detail in the event of an unexpected HTTP response.
"""
err_message = "Expected HTTP status {}; received {}: {}" err_message = "Expected HTTP status {}; received {}: {}"
self.assertEqual(response.status_code, expected_status, err_message.format( self.assertEqual(response.status_code, expected_status, err_message.format(
expected_status, response.status_code, response.data expected_status, response.status_code, response.data

29
netbox/virtualization/tests/test_api.py
View File

@ -1,22 +1,17 @@
from __future__ import unicode_literals from __future__ import unicode_literals
from django.contrib.auth.models import User
from django.urls import reverse from django.urls import reverse
from rest_framework import status from rest_framework import status
from rest_framework.test import APITestCase
from users.models import Token from utilities.testing import APITestCase
from utilities.testing import HttpStatusMixin
from virtualization.models import Cluster, ClusterGroup, ClusterType, VirtualMachine from virtualization.models import Cluster, ClusterGroup, ClusterType, VirtualMachine
class ClusterTypeTest(HttpStatusMixin, APITestCase): class ClusterTypeTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(ClusterTypeTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.clustertype1 = ClusterType.objects.create(name='Test Cluster Type 1', slug='test-cluster-type-1') self.clustertype1 = ClusterType.objects.create(name='Test Cluster Type 1', slug='test-cluster-type-1')
self.clustertype2 = ClusterType.objects.create(name='Test Cluster Type 2', slug='test-cluster-type-2') self.clustertype2 = ClusterType.objects.create(name='Test Cluster Type 2', slug='test-cluster-type-2')
@ -103,13 +98,11 @@ class ClusterTypeTest(HttpStatusMixin, APITestCase):
self.assertEqual(ClusterType.objects.count(), 2) self.assertEqual(ClusterType.objects.count(), 2)
class ClusterGroupTest(HttpStatusMixin, APITestCase): class ClusterGroupTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(ClusterGroupTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
self.clustergroup1 = ClusterGroup.objects.create(name='Test Cluster Group 1', slug='test-cluster-group-1') self.clustergroup1 = ClusterGroup.objects.create(name='Test Cluster Group 1', slug='test-cluster-group-1')
self.clustergroup2 = ClusterGroup.objects.create(name='Test Cluster Group 2', slug='test-cluster-group-2') self.clustergroup2 = ClusterGroup.objects.create(name='Test Cluster Group 2', slug='test-cluster-group-2')
@ -196,13 +189,11 @@ class ClusterGroupTest(HttpStatusMixin, APITestCase):
self.assertEqual(ClusterGroup.objects.count(), 2) self.assertEqual(ClusterGroup.objects.count(), 2)
class ClusterTest(HttpStatusMixin, APITestCase): class ClusterTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(ClusterTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
cluster_type = ClusterType.objects.create(name='Test Cluster Type 1', slug='test-cluster-type-1') cluster_type = ClusterType.objects.create(name='Test Cluster Type 1', slug='test-cluster-type-1')
cluster_group = ClusterGroup.objects.create(name='Test Cluster Group 1', slug='test-cluster-group-1') cluster_group = ClusterGroup.objects.create(name='Test Cluster Group 1', slug='test-cluster-group-1')
@ -301,13 +292,11 @@ class ClusterTest(HttpStatusMixin, APITestCase):
self.assertEqual(Cluster.objects.count(), 2) self.assertEqual(Cluster.objects.count(), 2)
class VirtualMachineTest(HttpStatusMixin, APITestCase): class VirtualMachineTest(APITestCase):
def setUp(self): def setUp(self):
user = User.objects.create(username='testuser', is_superuser=True) super(VirtualMachineTest, self).setUp()
token = Token.objects.create(user=user)
self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
cluster_type = ClusterType.objects.create(name='Test Cluster Type 1', slug='test-cluster-type-1') cluster_type = ClusterType.objects.create(name='Test Cluster Type 1', slug='test-cluster-type-1')
cluster_group = ClusterGroup.objects.create(name='Test Cluster Group 1', slug='test-cluster-group-1') cluster_group = ClusterGroup.objects.create(name='Test Cluster Group 1', slug='test-cluster-group-1')