arona/PyRIGS
1
0
Fork 0
mirror of https://github.com/nottinghamtec/PyRIGS.git synced 2026-01-17 05:22:16 +00:00
Code Issues Projects Releases Wiki Activity

Much test refactoring

Browse Source
This commit is contained in:
FreneticScribbler
2021-02-04 13:06:23 +00:00
parent 7eea868575
commit 3853ad0871
15 changed files with 360 additions and 379 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
PyRIGS/settings.py
View File

@@ -27,9 +27,7 @@ SECRET_KEY = env('SECRET_KEY', default='gxhy(a#5mhp289_=6xx$7jh=eh$ymxg^ymc+di*0
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = env('DEBUG', cast=bool, default=True)
STAGING = env('STAGING', cast=bool, default=False)
CI = env('CI', cast=bool, default=False)
ALLOWED_HOSTS = ['pyrigs.nottinghamtec.co.uk', 'rigs.nottinghamtec.co.uk', 'pyrigs.herokuapp.com']
@@ -55,6 +53,7 @@ if DEBUG:
# Application definition
INSTALLED_APPS = (
'whitenoise.runserver_nostatic',
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',

31
PyRIGS/tests/base.py
View File

@@ -13,10 +13,12 @@ from RIGS import models as rigsmodels
from . import pages
from envparse import env
from pytest_django.asserts import assertContains
def create_datetime(year, month, day, hour, min):
def create_datetime(year, month, day, hour, minute):
tz = pytz.timezone(settings.TIME_ZONE)
return tz.localize(datetime(year, month, day, hour, min)).astimezone(pytz.utc)
return tz.localize(datetime(year, month, day, hour, minute)).astimezone(tz)
def create_browser():
@@ -60,6 +62,7 @@ class AutoLoginTest(BaseTest):
login_page.login("EventTest", "EventTestPassword")
# FIXME Refactor as a pytest fixture
def screenshot_failure(func):
def wrapper_func(self, *args, **kwargs):
try:
@@ -85,3 +88,27 @@ def screenshot_failure_cls(cls):
def assert_times_equal(first_time, second_time):
assert first_time.replace(microsecond=0, second=0) == second_time.replace(microsecond=0, second=0)
def assert_oembed(alt_event_embed_url, alt_oembed_url, client, event_embed_url, event_url, oembed_url):
# Test the meta tag is in place
response = client.get(event_url, follow=True, HTTP_HOST='example.com')
assertContains(response, '<link rel="alternate" type="application/json+oembed"')
assertContains(response, oembed_url)
# Test that the JSON exists
response = client.get(oembed_url, follow=True, HTTP_HOST='example.com')
assert response.status_code == 200
assertContains(response, event_embed_url)
# Should also work for non-existant events
response = client.get(alt_oembed_url, follow=True, HTTP_HOST='example.com')
assert response.status_code == 200
assertContains(response, alt_event_embed_url)
def login(client, django_user_model):
pwd = 'testuser'
usr = 'TestUser'
user = django_user_model.objects.create_user(username=usr, email="TestUser@test.com", password=pwd, is_superuser=True,
is_active=True, is_staff=True)
assert client.login(username=usr, password=pwd)
return user

23
PyRIGS/tests/test_unit.py
View File

@@ -1,11 +1,12 @@
from PyRIGS import urls
from assets.tests.test_unit import create_asset_one
from django.core.management import call_command
import pytest
from django.urls import URLPattern, URLResolver, reverse
from django.urls.exceptions import NoReverseMatch
from django.test.utils import override_settings
from pytest_django.asserts import assertContains, assertRedirects, assertTemplateUsed, assertInHTML
pytestmark = pytest.mark.django_db
from django.template.defaultfilters import striptags
def find_urls_recursive(patterns):
@@ -14,7 +15,7 @@ def find_urls_recursive(patterns):
if isinstance(url, URLResolver):
urls_to_check += find_urls_recursive(url.url_patterns)
elif isinstance(url, URLPattern):
# Skip some thinks that actually don't need auth (mainly OEmbed JSONs that are essentially just a redirect)
# Skip some things that actually don't need auth (mainly OEmbed JSONs that are essentially just a redirect)
if url.name is not None and url.name != "closemodal" and "json" not in str(url):
urls_to_check.append(url)
return urls_to_check
@@ -22,7 +23,6 @@ def find_urls_recursive(patterns):
def get_request_url(url):
pattern = str(url.pattern)
request_url = ""
try:
kwargz = {}
if ":pk>" in pattern:
@@ -34,8 +34,18 @@ def get_request_url(url):
print("Couldn't test url " + pattern)
@pytest.fixture(scope='session')
def django_db_setup(django_db_setup, django_db_blocker):
with django_db_blocker.unblock():
from django.conf import settings
settings.DEBUG = True
call_command('generateSampleRIGSData') # We need stuff setup so we don't get 404 errors everywhere
create_asset_one()
settings.DEBUG = False
def test_unauthenticated(client): # Nothing should be available to the unauthenticated
create_asset_one()
for url in find_urls_recursive(urls.urlpatterns):
request_url = get_request_url(url)
if request_url and 'user' not in request_url: # User module is full of edge cases
@@ -52,12 +62,11 @@ def test_unauthenticated(client): # Nothing should be available to the unauthen
def test_page_titles(admin_client):
create_asset_one()
for url in filter((lambda u: "embed" not in u.name), find_urls_recursive(urls.urlpatterns)):
request_url = get_request_url(url)
response = admin_client.get(request_url)
if hasattr(response, "context_data") and "page_title" in response.context_data:
expected_title = response.context_data["page_title"]
expected_title = striptags(response.context_data["page_title"])
# try:
assertInHTML('<title>{} | Rig Information Gathering System'.format(expected_title), response.content.decode())
print("{} | {}".format(request_url, expected_title)) # If test fails, tell me where!

4
RIGS/management/commands/generateSampleData.py
View File

@@ -1,6 +1,7 @@
from django.core.management import call_command
from django.core.management.base import BaseCommand
import time
from RIGS import models
class Command(BaseCommand):
help = 'Adds sample data to use for testing'
@@ -9,3 +10,4 @@ class Command(BaseCommand):
def handle(self, *args, **options):
call_command('generateSampleRIGSData')
call_command('generateSampleAssetsData')
# call_command('createinitialrevisions') TODO

3
RIGS/management/commands/generateSampleRIGSData.py
View File

@@ -41,7 +41,7 @@ class Command(BaseCommand):
with transaction.atomic():
models.VatRate.objects.create(start_at='2014-03-05', rate=0.20, comment='test1')
self.setupGenericProfiles()
# self.setupGenericProfiles()
self.setupUsefulProfiles()
models.Profile.objects.bulk_create(self.profiles)
@@ -157,6 +157,7 @@ class Command(BaseCommand):
for i, name in enumerate(names):
pk = i + 1
newVenue = models.Venue(pk=pk, name=name)
if i % 2 == 0:
newVenue.three_phase_available = True

4
RIGS/rigboard.py
View File

@@ -27,7 +27,7 @@ from django.views import generic
from z3c.rml import rml2pdf
from PyRIGS import decorators
from PyRIGS.views import OEmbedView
from PyRIGS.views import OEmbedView, is_ajax
from RIGS import models, forms
__author__ = 'ghost'
@@ -349,7 +349,7 @@ class EventAuthorisationRequest(generic.FormView, generic.detail.SingleObjectMix
return self.get_object()
def get_success_url(self):
if self.request.is_ajax():
if is_ajax(self.request):
url = reverse_lazy('closemodal')
messages.info(self.request, "location.reload()")
else:

7
RIGS/tests/conftest.py Normal file
View File

@@ -0,0 +1,7 @@
from RIGS import models
import pytest
@pytest.fixture(autouse=True)
def vat_rate(db):
return models.VatRate.objects.create(start_at='2014-03-05', rate=0.20, comment='test1')

111
RIGS/tests/test_functional.py
View File

@@ -8,54 +8,13 @@ from django.http import HttpResponseBadRequest
from django.test import TestCase
from django.urls import reverse
import PyRIGS.tests.base
import PyRIGS.tests.test_unit
from RIGS import models
from pytest_django.asserts import assertContains, assertNotContains
class BaseCase(TestCase):
@classmethod
def setUpTestData(cls):
cls.vatrate = models.VatRate.objects.create(start_at='2014-03-05', rate=0.20, comment='test1')
cls.profile = models.Profile.objects.get_or_create(
first_name='Test',
last_name='TEC User',
username='eventauthtest',
email='teccie@functional.test',
is_superuser=True # lazily grant all permissions
)[0]
def setUp(self):
super().setUp()
self.profile.set_password('testuser')
self.profile.save()
self.assertTrue(self.client.login(username=self.profile.username, password='testuser'))
venue = models.Venue.objects.create(name='Authorisation Test Venue')
client = models.Person.objects.create(name='Authorisation Test Person', email='authorisation@functional.test')
organisation = models.Organisation.objects.create(name='Authorisation Test Organisation', union_account=True)
self.event = models.Event.objects.create(
name='Authorisation Test',
start_date=date.today(),
venue=venue,
person=client,
organisation=organisation,
)
class TestEventValidation(BaseCase):
def test_create(self):
url = reverse('event_create')
# end time before start access after start
response = self.client.post(url, {'start_date': datetime.date(2020, 1, 1), 'start_time': datetime.time(10, 00),
'end_time': datetime.time(9, 00),
'access_at': datetime.datetime(2020, 1, 5, 10)})
self.assertFormError(response, 'form', 'end_time',
"Unless you've invented time travel, the event can't finish before it has started.")
self.assertFormError(response, 'form', 'access_at',
"Regardless of what some clients might think, access time cannot be after the event has started.")
from pytest_django.asserts import assertContains, assertNotContains, assertFormError
def setup_event():
models.VatRate.objects.create(start_at='2014-03-05', rate=0.20, comment='test1')
venue = models.Venue.objects.create(name='Authorisation Test Venue')
client = models.Person.objects.create(name='Authorisation Test Person', email='authorisation@functional.test')
organisation = models.Organisation.objects.create(name='Authorisation Test Organisation', union_account=True)
@@ -84,6 +43,18 @@ def setup_mail(event, profile):
return auth_data, hmac, url
def test_create(admin_client):
url = reverse('event_create')
# end time before start access after start
response = admin_client.post(url, {'start_date': datetime.date(2020, 1, 1), 'start_time': datetime.time(10, 00),
'end_time': datetime.time(9, 00),
'access_at': datetime.datetime(2020, 1, 5, 10)})
assertFormError(response, 'form', 'end_time',
"Unless you've invented time travel, the event can't finish before it has started.")
assertFormError(response, 'form', 'access_at',
"Regardless of what some clients might think, access time cannot be after the event has started.")
def test_requires_valid_hmac(client, admin_user):
event = setup_event()
auth_data, hmac, url = setup_mail(event, admin_user)
@@ -152,36 +123,36 @@ def test_email_sent(admin_client, admin_user, mailoutbox):
assert mailoutbox[1].to == [settings.AUTHORISATION_NOTIFICATION_ADDRESS]
class TECEventAuthorisationTest(BaseCase):
def setUp(self):
super().setUp()
self.url = reverse('event_authorise_request', kwargs={'pk': self.event.pk})
def test_email_check(admin_client, admin_user):
event = setup_event()
url = reverse('event_authorise_request', kwargs={'pk': event.pk})
admin_user.email = 'teccie@someotherdomain.com'
admin_user.save()
def test_email_check(self):
self.profile.email = 'teccie@someotherdomain.com'
self.profile.save()
response = admin_client.post(url)
response = self.client.post(self.url)
assertContains(response, 'must have an @nottinghamtec.co.uk email address')
self.assertContains(response, 'must have an @nottinghamtec.co.uk email address')
def test_request_send(self):
self.profile.email = 'teccie@nottinghamtec.co.uk'
self.profile.save()
response = self.client.post(self.url)
self.assertContains(response, 'This field is required.')
def test_request_send(admin_client, admin_user):
event = setup_event()
url = reverse('event_authorise_request', kwargs={'pk': event.pk})
admin_user.email = 'teccie@nottinghamtec.co.uk'
admin_user.save()
response = admin_client.post(url)
assertContains(response, 'This field is required.')
mail.outbox = []
mail.outbox = []
response = self.client.post(self.url, {'email': 'client@functional.test'})
self.assertEqual(response.status_code, 302)
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertIn('client@functional.test', email.to)
self.assertIn('/event/%d/' % (self.event.pk), email.body)
response = admin_client.post(url, {'email': 'client@functional.test'})
assert response.status_code == 302
assert len(mail.outbox) == 1
email = mail.outbox[0]
assert 'client@functional.test' in email.to
assert '/event/%d/' % event.pk in email.body
# Check sent by details are populated
self.event.refresh_from_db()
self.assertEqual(self.event.auth_request_by, self.profile)
self.assertEqual(self.event.auth_request_to, 'client@functional.test')
self.assertIsNotNone(self.event.auth_request_at)
# Check sent by details are populated
event.refresh_from_db()
assert event.auth_request_by == admin_user
assert event.auth_request_to == 'client@functional.test'
assert event.auth_request_at is not None

162
RIGS/tests/test_unit.py
View File

@@ -8,9 +8,14 @@ from django.urls import reverse, reverse_lazy
from django.utils import timezone
from pytest_django.asserts import assertRedirects, assertNotContains, assertContains
from PyRIGS.tests.base import assert_times_equal
import PyRIGS.tests.test_unit
from PyRIGS.tests.base import assert_times_equal, assert_oembed, login
from RIGS import models
import pytest
pytestmark = pytest.mark.django_db
class TestAdminMergeObjects(TestCase):
@classmethod
@@ -201,7 +206,7 @@ class TestInvoiceDelete(TestCase):
self.assertTrue(models.Invoice.objects.get(pk=self.invoices[2].pk))
# Actually delete it
response = self.client.post(request_url, follow=True)
self.client.post(request_url, follow=True)
# Check the invoice is deleted
self.assertRaises(ObjectDoesNotExist, models.Invoice.objects.get, pk=self.invoices[2].pk)
@@ -216,7 +221,7 @@ class TestInvoiceDelete(TestCase):
self.assertTrue(models.Invoice.objects.get(pk=self.invoices[1].pk))
# Try to actually delete it
response = self.client.post(request_url, follow=True)
self.client.post(request_url, follow=True)
# Check this didn't work
self.assertTrue(models.Invoice.objects.get(pk=self.invoices[1].pk))
@@ -257,102 +262,71 @@ class TestPrintPaperwork(TestCase):
self.assertEqual(response.status_code, 200)
class TestEmbeddedViews(TestCase):
@classmethod
def setUpTestData(cls):
cls.profile = models.Profile.objects.create(username="testuser1", email="1@test.com", is_superuser=True,
is_active=True, is_staff=True)
cls.events = {
1: models.Event.objects.create(name="TE E1", start_date=date.today()),
2: models.Event.objects.create(name="TE E2", start_date=date.today())
}
cls.invoices = {
1: models.Invoice.objects.create(event=cls.events[1]),
2: models.Invoice.objects.create(event=cls.events[2])
}
cls.payments = {
1: models.Payment.objects.create(invoice=cls.invoices[1], date=date.today(), amount=12.34,
method=models.Payment.CASH)
}
def setUp(self):
self.profile.set_password('testuser')
self.profile.save()
def testLoginRedirect(self):
request_url = reverse('event_embed', kwargs={'pk': 1})
expected_url = "{0}?next={1}".format(reverse('login_embed'), request_url)
# Request the page and check it redirects
response = self.client.get(request_url, follow=True)
self.assertRedirects(response, expected_url, status_code=302, target_status_code=200)
# Now login
self.assertTrue(self.client.login(username=self.profile.username, password='testuser'))
# And check that it no longer redirects
response = self.client.get(request_url, follow=True)
self.assertEqual(len(response.redirect_chain), 0)
def testLoginCookieWarning(self):
login_url = reverse('login_embed')
response = self.client.post(login_url, follow=True)
self.assertContains(response, "Cookies do not seem to be enabled")
def testXFrameHeaders(self):
event_url = reverse('event_embed', kwargs={'pk': 1})
login_url = reverse('login_embed')
self.assertTrue(self.client.login(username=self.profile.username, password='testuser'))
response = self.client.get(event_url, follow=True)
with self.assertRaises(KeyError):
response._headers["X-Frame-Options"]
response = self.client.get(login_url, follow=True)
with self.assertRaises(KeyError):
response._headers["X-Frame-Options"]
def testOEmbed(self):
event_url = reverse('event_detail', kwargs={'pk': 1})
event_embed_url = reverse('event_embed', kwargs={'pk': 1})
oembed_url = reverse('event_oembed', kwargs={'pk': 1})
alt_oembed_url = reverse('event_oembed', kwargs={'pk': 999})
alt_event_embed_url = reverse('event_embed', kwargs={'pk': 999})
# Test the meta tag is in place
response = self.client.get(event_url, follow=True, HTTP_HOST='example.com')
self.assertContains(response, '<link rel="alternate" type="application/json+oembed"')
self.assertContains(response, oembed_url)
# Test that the JSON exists
response = self.client.get(oembed_url, follow=True, HTTP_HOST='example.com')
self.assertEqual(response.status_code, 200)
self.assertContains(response, event_embed_url)
# Should also work for non-existant events
response = self.client.get(alt_oembed_url, follow=True, HTTP_HOST='example.com')
self.assertEqual(response.status_code, 200)
self.assertContains(response, alt_event_embed_url)
def create_event():
return models.Event.objects.create(name="TE E1", start_date=date.today())
class TestSampleDataGenerator(TestCase):
@override_settings(DEBUG=True)
def test_generate_sample_data(self):
# Run the management command and check there are no exceptions
call_command('generateSampleRIGSData')
def test_login_redirect(client, django_user_model):
request_url = reverse('event_embed', kwargs={'pk': 1})
expected_url = "{0}?next={1}".format(reverse('login_embed'), request_url)
# Check there are lots of events
self.assertTrue(models.Event.objects.all().count() > 100)
# Request the page and check it redirects
response = client.get(request_url, follow=True)
assertRedirects(response, expected_url, status_code=302, target_status_code=200)
def test_production_exception(self):
from django.core.management.base import CommandError
# Now login
login(client, django_user_model)
self.assertRaisesRegex(CommandError, ".*production", call_command, 'generateSampleRIGSData')
# And check that it no longer redirects
response = client.get(request_url, follow=True)
assert len(response.redirect_chain) == 0
def test_login_cookie_warning(client):
login_url = reverse('login_embed')
response = client.post(login_url, follow=True)
assertContains(response, "Cookies do not seem to be enabled")
def test_xframe_headers(admin_client):
event = create_event()
event_url = reverse('event_embed', kwargs={'pk': event.pk})
login_url = reverse('login_embed')
response = admin_client.get(event_url, follow=True)
with pytest.raises(KeyError):
response._headers["X-Frame-Options"]
response = admin_client.get(login_url, follow=True)
with pytest.raises(KeyError):
response._headers["X-Frame-Options"]
def test_oembed(client):
event = create_event()
event_url = reverse('event_detail', kwargs={'pk': event.pk})
event_embed_url = reverse('event_embed', kwargs={'pk': event.pk})
oembed_url = reverse('event_oembed', kwargs={'pk': event.pk})
alt_oembed_url = reverse('event_oembed', kwargs={'pk': 999})
alt_event_embed_url = reverse('event_embed', kwargs={'pk': 999})
assert_oembed(alt_event_embed_url, alt_oembed_url, client, event_embed_url, event_url, oembed_url)
@override_settings(DEBUG=True)
def test_generate_sample_data():
# Run the management command and check there are no exceptions
call_command('generateSampleRIGSData')
# Check there are lots of events
assert models.Event.objects.all().count() > 100
def test_production_exception():
from django.core.management.base import CommandError
with pytest.raises(CommandError):
call_command("generateSampleRIGSData")
def search(client, url, found, notfound, arguments):

6
assets/management/commands/generateSampleAssetsData.py
View File

@@ -57,14 +57,14 @@ class Command(BaseCommand):
def create_categories(self):
choices = ['Case', 'Video', 'General', 'Sound', 'Lighting', 'Rigging']
pk = 1
pk = 99
for cat in choices:
self.categories.append(models.AssetCategory(pk=pk, name=cat))
pk += 1
def create_assets(self):
asset_description = ['Large cable', 'Shiny thing', 'New lights', 'Really expensive microphone', 'Box of fuse flaps', 'Expensive tool we didn\'t agree to buy', 'Cable drums', 'Boring amount of tape', 'Video stuff no one knows how to use', 'More amplifiers', 'Heatshrink']
pk = 1
pk = 9000
for i in range(100):
asset = models.Asset(
pk=pk,
@@ -89,7 +89,7 @@ class Command(BaseCommand):
csas = [0.75, 1.00, 1.25, 2.5, 4]
lengths = [1, 2, 5, 10, 15, 20, 25, 30, 50, 100]
pk = 102 # Offset to avoid other asset IDs
pk = 200 # Offset to avoid other asset IDs
for i in range(100):
asset = models.Asset(
pk=pk,

109
assets/tests/test_unit.py
View File

@@ -2,35 +2,16 @@ import datetime
import pytest
from django.core.management import call_command
from django.test import override_settings
from django.test.utils import override_settings
from django.urls import reverse
from pytest_django.asserts import assertFormError, assertRedirects, assertContains, assertNotContains
from assets import models, urls
from PyRIGS.tests.base import assert_oembed, login
pytestmark = pytest.mark.django_db # TODO
from assets import models
def login(client, django_user_model):
pwd = 'testuser'
usr = "TestUser"
django_user_model.objects.create_user(username=usr, email="TestUser@test.com", password=pwd, is_superuser=True, is_active=True, is_staff=True)
assert client.login(username=usr, password=pwd)
def create_test_asset():
working = models.AssetStatus.objects.create(name="Working", should_show=True)
lighting = models.AssetCategory.objects.create(name="Lighting")
asset = models.Asset.objects.create(asset_id="1991", description="Spaceflower", status=working, category=lighting, date_acquired=datetime.date(1991, 12, 26))
return asset
def create_test_cable():
category = models.AssetCategory.objects.create(name="Sound")
status = models.AssetStatus.objects.create(name="Broken", should_show=True)
connector = models.Connector.objects.create(description="16A IEC", current_rating=16, voltage_rating=240, num_pins=3)
cable_type = models.CableType.objects.create(circuits=11, cores=3, plug=connector, socket=connector)
return models.Asset.objects.create(asset_id="666", description="125A -> Jack", comments="The cable from Hell...", status=status, category=category, date_acquired=datetime.date(2006, 6, 6), is_cable=True, cable_type=cable_type, length=10, csa="1.5")
pytestmark = pytest.mark.django_db
def test_supplier_create(client, django_user_model):
@@ -103,20 +84,7 @@ def test_oembed(client):
alt_oembed_url = reverse('asset_oembed', kwargs={'pk': 999})
alt_asset_embed_url = reverse('asset_embed', kwargs={'pk': 999})
# Test the meta tag is in place
response = client.get(asset_url, follow=True, HTTP_HOST='example.com')
assert '<link rel="alternate" type="application/json+oembed"' in str(response.content)
assertContains(response, oembed_url)
# Test that the JSON exists
response = client.get(oembed_url, follow=True, HTTP_HOST='example.com')
assert response.status_code == 200
assertContains(response, asset_embed_url)
# Should also work for non-existant
response = client.get(alt_oembed_url, follow=True, HTTP_HOST='example.com')
assert response.status_code == 200
assertContains(response, alt_asset_embed_url)
assert_oembed(alt_asset_embed_url, alt_oembed_url, client, asset_embed_url, asset_url, oembed_url)
@override_settings(DEBUG=True)
@@ -149,38 +117,23 @@ def test_asset_create(client, django_user_model):
login(client, django_user_model)
response = client.post(reverse('asset_create'), {'date_sold': '2000-01-01', 'date_acquired': '2020-01-01', 'purchase_price': '-30', 'salvage_value': '-30'})
assertFormError(response, 'form', 'asset_id', 'This field is required.')
assertFormError(response, 'form', 'description', 'This field is required.')
assertFormError(response, 'form', 'status', 'This field is required.')
assertFormError(response, 'form', 'category', 'This field is required.')
assertFormError(response, 'form', 'date_sold', 'Cannot sell an item before it is acquired')
assertFormError(response, 'form', 'purchase_price', 'A price cannot be negative')
assertFormError(response, 'form', 'salvage_value', 'A price cannot be negative')
assert_asset_form_errors(response)
def test_cable_create(client, django_user_model):
login(client, django_user_model)
response = client.post(reverse('asset_create'), {'asset_id': 'X$%A', 'is_cable': True})
assertFormError(response, 'form', 'asset_id', 'An Asset ID can only consist of letters and numbers, with a final number')
assertFormError(response, 'form', 'cable_type', 'A cable must have a type')
assertFormError(response, 'form', 'length', 'The length of a cable must be more than 0')
assertFormError(response, 'form', 'csa', 'The CSA of a cable must be more than 0')
# Given that validation is done at model level it *shouldn't* need retesting...gonna do it anyway!
def test_asset_edit(client, django_user_model):
login(client, django_user_model)
url = reverse('asset_update', kwargs={'pk': create_test_asset().asset_id})
response = client.post(url, {'date_sold': '2000-12-01', 'date_acquired': '2020-12-01', 'purchase_price': '-50', 'salvage_value': '-50', 'description': "", 'status': "", 'category': ""})
# assertFormError(response, 'form', 'asset_id', 'This field is required.')
assertFormError(response, 'form', 'description', 'This field is required.')
assertFormError(response, 'form', 'status', 'This field is required.')
assertFormError(response, 'form', 'category', 'This field is required.')
assertFormError(response, 'form', 'date_sold', 'Cannot sell an item before it is acquired')
assertFormError(response, 'form', 'purchase_price', 'A price cannot be negative')
assertFormError(response, 'form', 'salvage_value', 'A price cannot be negative')
assert_asset_form_errors(response)
def test_cable_edit(client, django_user_model):
@@ -204,17 +157,7 @@ def test_asset_duplicate(client, django_user_model):
assertFormError(response, 'form', 'csa', 'The CSA of a cable must be more than 0')
@override_settings(DEBUG=True)
def create_asset_one():
# Shortcut to create the levels - bonus side effect of testing the command (hopefully) matches production
call_command('generateSampleData')
# Create an asset with ID 1 to make things easier in loops (we can always use pk=1)
category = models.AssetCategory.objects.create(name="Number One")
status = models.AssetStatus.objects.create(name="Probably Fine", should_show=True)
return models.Asset.objects.create(asset_id="1", description="Half Price Fish", status=status, category=category, date_acquired=datetime.date(2020, 2, 1))
def test_basic_access(client):
def test_basic_access(client, django_user_model):
create_asset_one()
client.login(username="basic", password="basic")
@@ -244,7 +187,7 @@ def test_basic_access(client):
assert response.status_code == 403
def test_keyholder_access(client):
def test_keyholder_access(client, django_user_model):
create_asset_one()
client.login(username="keyholder", password="keyholder")
@@ -258,3 +201,37 @@ def test_keyholder_access(client):
response = client.get(url)
assertContains(response, 'Purchase Details')
assertContains(response, 'View Revision History')
@override_settings(DEBUG=True)
def create_asset_one():
# Shortcut to create the levels - bonus side effect of testing the command (hopefully) matches production
call_command('generateSampleAssetsData')
# Create an asset with ID 1 to make things easier in loops (we can always use pk=1)
category = models.AssetCategory.objects.create(name="Number One")
status = models.AssetStatus.objects.create(name="Probably Fine", should_show=True)
return models.Asset.objects.create(asset_id="1", description="Half Price Fish", status=status, category=category, date_acquired=datetime.date(2020, 2, 1))
def assert_asset_form_errors(response):
assertFormError(response, 'form', 'description', 'This field is required.')
assertFormError(response, 'form', 'status', 'This field is required.')
assertFormError(response, 'form', 'category', 'This field is required.')
assertFormError(response, 'form', 'date_sold', 'Cannot sell an item before it is acquired')
assertFormError(response, 'form', 'purchase_price', 'A price cannot be negative')
assertFormError(response, 'form', 'salvage_value', 'A price cannot be negative')
def create_test_cable():
category = models.AssetCategory.objects.create(name="Sound")
status = models.AssetStatus.objects.create(name="Broken", should_show=True)
connector = models.Connector.objects.create(description="16A IEC", current_rating=16, voltage_rating=240, num_pins=3)
cable_type = models.CableType.objects.create(circuits=11, cores=3, plug=connector, socket=connector)
return models.Asset.objects.create(asset_id="666", description="125A -> Jack", comments="The cable from Hell...", status=status, category=category, date_acquired=datetime.date(2006, 6, 6), is_cable=True, cable_type=cable_type, length=10, csa="1.5")
def create_test_asset():
working = models.AssetStatus.objects.create(name="Working", should_show=True)
lighting = models.AssetCategory.objects.create(name="Lighting")
asset = models.Asset.objects.create(asset_id="1991", description="Spaceflower", status=working, category=lighting, date_acquired=datetime.date(1991, 12, 26))
return asset

13
conftest.py
View File

@@ -1,9 +1,22 @@
from django.conf import settings
import django
import pytest
def pytest_configure():
settings.PASSWORD_HASHERS = (
'django.contrib.auth.hashers.MD5PasswordHasher',
)
settings.STATICFILES_DIRS.append('static/') # FIXME
django.setup()
@pytest.fixture(scope='session')
def splinter_webdriver():
"""Override splinter webdriver name."""
return 'chrome'
@pytest.fixture(scope='session')
def splinter_screenshot_dir():
return 'screenshots/'

146
versioning/tests/test_versioning.py → versioning/tests/test_models.py
View File

@@ -1,15 +1,12 @@
from datetime import date
from django.test import TestCase
from django.urls import reverse
from reversion import revisions as reversion
from RIGS import models
from assets import models as amodels
from versioning import versioning
# Model Tests
class RIGSVersionTestCase(TestCase):
def setUp(self):
models.VatRate.objects.create(rate=0.20, comment="TP V1", start_at='2013-01-01')
@@ -41,11 +38,11 @@ class RIGSVersionTestCase(TestCase):
def test_find_parent_version(self):
# Find the most recent version
currentVersion = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
self.assertEqual(currentVersion._object_version.object.notes, "A new note on the event")
current_version = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
self.assertEqual(current_version._object_version.object.notes, "A new note on the event")
# Check the prev version is loaded correctly
previousVersion = currentVersion.parent
previousVersion = current_version.parent
self.assertEqual(previousVersion._object_version.object.notes, None)
# Check that finding the parent of the first version fails gracefully
@@ -140,14 +137,14 @@ class RIGSVersionTestCase(TestCase):
self.event.save()
# Find the most recent version
currentVersion = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
current_version = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
diffs = currentVersion.changes.item_changes
diffs = current_version.changes.item_changes
self.assertEqual(len(diffs), 1)
self.assertTrue(currentVersion.changes.items_changed)
self.assertFalse(currentVersion.changes.fields_changed)
self.assertTrue(currentVersion.changes.anything_changed)
self.assertTrue(current_version.changes.items_changed)
self.assertFalse(current_version.changes.fields_changed)
self.assertTrue(current_version.changes.anything_changed)
self.assertTrue(diffs[0].old is None)
self.assertEqual(diffs[0].new.name, "TI I1")
@@ -159,9 +156,9 @@ class RIGSVersionTestCase(TestCase):
item1.save()
self.event.save()
currentVersion = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
current_version = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
diffs = currentVersion.changes.item_changes
diffs = current_version.changes.item_changes
self.assertEqual(len(diffs), 1)
@@ -169,7 +166,7 @@ class RIGSVersionTestCase(TestCase):
self.assertEqual(diffs[0].new.name, "New Name")
# Check the diff
self.assertEqual(currentVersion.changes.item_changes[0].field_changes[0].diff,
self.assertEqual(current_version.changes.item_changes[0].field_changes[0].diff,
[{'type': 'delete', 'text': "TI I1"},
{'type': 'insert', 'text': "New Name"},
])
@@ -181,125 +178,14 @@ class RIGSVersionTestCase(TestCase):
self.event.save()
# Find the most recent version
currentVersion = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
current_version = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
diffs = currentVersion.changes.item_changes
diffs = current_version.changes.item_changes
self.assertEqual(len(diffs), 1)
self.assertTrue(currentVersion.changes.items_changed)
self.assertFalse(currentVersion.changes.fields_changed)
self.assertTrue(currentVersion.changes.anything_changed)
self.assertTrue(current_version.changes.items_changed)
self.assertFalse(current_version.changes.fields_changed)
self.assertTrue(current_version.changes.anything_changed)
self.assertEqual(diffs[0].old.name, "New Name")
self.assertTrue(diffs[0].new is None)
# Unit Tests
class TestVersioningViews(TestCase):
@classmethod
def setUpTestData(cls):
cls.profile = models.Profile.objects.create(username="testuser1", email="1@test.com", is_superuser=True,
is_active=True, is_staff=True)
cls.vatrate = models.VatRate.objects.create(start_at='2014-03-05', rate=0.20, comment='test1')
cls.events = {}
with reversion.create_revision():
reversion.set_user(cls.profile)
cls.events[1] = models.Event.objects.create(name="TE E1", start_date=date.today())
with reversion.create_revision():
reversion.set_user(cls.profile)
cls.events[2] = models.Event.objects.create(name="TE E2", start_date='2014-03-05')
with reversion.create_revision():
reversion.set_user(cls.profile)
cls.events[1].description = "A test description"
cls.events[1].save()
working = amodels.AssetStatus.objects.create(name="Working", should_show=True)
broken = amodels.AssetStatus.objects.create(name="Broken", should_show=False)
general = amodels.AssetCategory.objects.create(name="General")
lighting = amodels.AssetCategory.objects.create(name="Lighting")
cls.assets = {}
with reversion.create_revision():
reversion.set_user(cls.profile)
cls.assets[1] = amodels.Asset.objects.create(asset_id="1991", description="Spaceflower", status=broken, category=lighting, date_acquired=date.today())
with reversion.create_revision():
reversion.set_user(cls.profile)
cls.assets[2] = amodels.Asset.objects.create(asset_id="0001", description="Virgil", status=working, category=lighting, date_acquired=date.today())
with reversion.create_revision():
reversion.set_user(cls.profile)
cls.assets[1].status = working
cls.assets[1].save()
def setUp(self):
self.profile.set_password('testuser')
self.profile.save()
self.assertTrue(self.client.login(username=self.profile.username, password='testuser'))
def test_history_loads_successfully(self):
request_url = reverse('event_history', kwargs={'pk': self.events[1].pk})
response = self.client.get(request_url, follow=True)
self.assertEqual(response.status_code, 200)
request_url = reverse('asset_history', kwargs={'pk': self.assets[1].asset_id})
response = self.client.get(request_url, follow=True)
self.assertEqual(response.status_code, 200)
def test_activity_feed_loads_successfully(self):
request_url = reverse('activity_feed')
response = self.client.get(request_url, follow=True)
self.assertEqual(response.status_code, 200)
def test_activity_table_loads_successfully(self):
request_url = reverse('activity_table')
response = self.client.get(request_url, follow=True)
self.assertEqual(response.status_code, 200)
request_url = reverse('assets_activity_table')
response = self.client.get(request_url, follow=True)
self.assertEqual(response.status_code, 200)
# Some edge cases that have caused server errors in the past
def test_deleted_event(self):
request_url = reverse('activity_feed')
self.events[2].delete()
response = self.client.get(request_url, follow=True)
self.assertContains(response, "TE E2")
self.assertEqual(response.status_code, 200)
def test_deleted_relation(self):
request_url = reverse('activity_feed')
with reversion.create_revision():
person = models.Person.objects.create(name="Test Person")
with reversion.create_revision():
self.events[1].person = person
self.events[1].save()
# Check response contains person
response = self.client.get(request_url, follow=True)
self.assertContains(response, "Test Person")
self.assertEqual(response.status_code, 200)
# Delete person
person.delete()
# Check response still contains person
response = self.client.get(request_url, follow=True)
self.assertContains(response, "Test Person")
self.assertEqual(response.status_code, 200)

115
versioning/tests/test_unit.py Normal file
View File

@@ -0,0 +1,115 @@
from datetime import date
from django.urls import reverse
from reversion import revisions as reversion
from pytest_django.asserts import assertContains
from RIGS import models
from assets import models as amodels
def create_events(admin_user):
models.VatRate.objects.create(start_at='2014-03-05', rate=0.20, comment='test1')
events = {}
with reversion.create_revision():
reversion.set_user(admin_user)
events[1] = models.Event.objects.create(name="TE E1", start_date=date.today())
with reversion.create_revision():
reversion.set_user(admin_user)
events[2] = models.Event.objects.create(name="TE E2", start_date='2014-03-05')
with reversion.create_revision():
reversion.set_user(admin_user)
events[1].description = "A test description"
events[1].save()
return events
def create_assets(admin_user):
working = amodels.AssetStatus.objects.create(name="Working", should_show=True)
broken = amodels.AssetStatus.objects.create(name="Broken", should_show=False)
lighting = amodels.AssetCategory.objects.create(name="Lighting")
assets = {}
with reversion.create_revision():
reversion.set_user(admin_user)
assets[1] = amodels.Asset.objects.create(asset_id="1991", description="Spaceflower", status=broken,
category=lighting, date_acquired=date.today())
with reversion.create_revision():
reversion.set_user(admin_user)
assets[2] = amodels.Asset.objects.create(asset_id="0001", description="Virgil", status=working,
category=lighting, date_acquired=date.today())
with reversion.create_revision():
reversion.set_user(admin_user)
assets[1].status = working
assets[1].save()
return assets
def test_history_loads_successfully(admin_client, admin_user):
events = create_events(admin_user)
request_url = reverse('event_history', kwargs={'pk': events[1].pk})
response = admin_client.get(request_url, follow=True)
assert response.status_code == 200
assets = create_assets(admin_user)
request_url = reverse('asset_history', kwargs={'pk': assets[1].asset_id})
response = admin_client.get(request_url, follow=True)
assert response.status_code == 200
def test_activity_feed_loads_successfully(admin_client):
request_url = reverse('activity_feed')
response = admin_client.get(request_url, follow=True)
assert response.status_code == 200
def test_activity_table_loads_successfully(admin_client):
request_url = reverse('activity_table')
response = admin_client.get(request_url, follow=True)
assert response.status_code == 200
request_url = reverse('assets_activity_table')
response = admin_client.get(request_url, follow=True)
assert response.status_code == 200
# Some edge cases that have caused server errors in the past
def test_deleted_event(admin_client, admin_user):
events = create_events(admin_user)
request_url = reverse('activity_feed')
events[2].delete()
response = admin_client.get(request_url, follow=True)
assertContains(response, "TE E2")
assert response.status_code == 200
def test_deleted_relation(admin_client, admin_user):
events = create_events(admin_user)
request_url = reverse('activity_feed')
with reversion.create_revision():
person = models.Person.objects.create(name="Test Person")
with reversion.create_revision():
events[1].person = person
events[1].save()
# Check response contains person
response = admin_client.get(request_url, follow=True)
assertContains(response, "Test Person")
assert response.status_code == 200
# Delete person
person.delete()
# Check response still contains person
response = admin_client.get(request_url, follow=True)
assertContains(response, "Test Person")
assert response.status_code == 200