mirror of
https://github.com/nottinghamtec/PyRIGS.git
synced 2026-01-17 13:32:15 +00:00
Arona Jones
2195a60438
Also rewrote some asset tests to be in the pytest style. May do some more. Some warnings cleaned up in the process.
308 lines
12 KiB
Python
308 lines
12 KiB
Python
from reversion import revisions as reversion
|
|
from django.conf import settings
|
|
from django.core.exceptions import ValidationError
|
|
from django.test import TestCase
|
|
from django.urls import reverse
|
|
from RIGS import models
|
|
from assets import models as amodels
|
|
from versioning import versioning
|
|
from datetime import date, timedelta, datetime, time
|
|
from decimal import *
|
|
from PyRIGS.tests.base import create_browser
|
|
|
|
|
|
# Model Tests
|
|
class RIGSVersionTestCase(TestCase):
|
|
def setUp(self):
|
|
models.VatRate.objects.create(rate=0.20, comment="TP V1", start_at='2013-01-01')
|
|
|
|
self.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]
|
|
with reversion.create_revision():
|
|
reversion.set_user(self.profile)
|
|
self.person = models.Person.objects.create(name='Authorisation Test Person')
|
|
|
|
with reversion.create_revision():
|
|
reversion.set_user(self.profile)
|
|
self.organisation = models.Organisation.objects.create(name='Authorisation Test Organisation')
|
|
|
|
with reversion.create_revision():
|
|
reversion.set_user(self.profile)
|
|
self.event = models.Event.objects.create(name="AuthorisationTestCase", person=self.person,
|
|
start_date=date.today())
|
|
|
|
with reversion.create_revision():
|
|
reversion.set_user(self.profile)
|
|
self.event.notes = "A new note on the event"
|
|
self.event.save()
|
|
|
|
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")
|
|
|
|
# Check the prev version is loaded correctly
|
|
previousVersion = currentVersion.parent
|
|
self.assertEqual(previousVersion._object_version.object.notes, None)
|
|
|
|
# Check that finding the parent of the first version fails gracefully
|
|
self.assertFalse(previousVersion.parent)
|
|
|
|
def test_changes_since(self):
|
|
# Find the most recent version
|
|
currentVersion = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
|
|
|
|
changes = currentVersion.changes
|
|
self.assertEqual(len(changes.field_changes), 1)
|
|
|
|
def test_manager(self):
|
|
objs = versioning.RIGSVersion.objects.get_for_multiple_models(
|
|
[models.Event, models.Person, models.Organisation])
|
|
self.assertEqual(len(objs), 4)
|
|
|
|
def test_text_field_types(self):
|
|
with reversion.create_revision():
|
|
reversion.set_user(self.profile)
|
|
self.event.name = "New event name" # Simple text
|
|
self.event.description = "hello world" # Long text
|
|
self.event.save()
|
|
|
|
# Find the most recent version
|
|
currentVersion = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
|
|
diff = currentVersion.changes
|
|
|
|
# There are two changes
|
|
self.assertEqual(len(diff.field_changes), 2)
|
|
self.assertFalse(currentVersion.changes.items_changed)
|
|
self.assertTrue(currentVersion.changes.fields_changed)
|
|
self.assertTrue(currentVersion.changes.anything_changed)
|
|
|
|
# Only one has "linebreaks"
|
|
self.assertEqual(sum([x.linebreaks for x in diff.field_changes]), 1)
|
|
|
|
# None are "long" (email address)
|
|
self.assertEqual(sum([x.long for x in diff.field_changes]), 0)
|
|
|
|
# Try changing email field in person
|
|
with reversion.create_revision():
|
|
reversion.set_user(self.profile)
|
|
self.person.email = "hello@world.com"
|
|
self.person.save()
|
|
|
|
# Find the most recent version
|
|
currentVersion = versioning.RIGSVersion.objects.get_for_object(self.person).latest('revision__date_created')
|
|
diff = currentVersion.changes
|
|
|
|
# Should be declared as long
|
|
self.assertTrue(diff.field_changes[0].long)
|
|
|
|
def test_text_diff(self):
|
|
with reversion.create_revision():
|
|
reversion.set_user(self.profile)
|
|
self.event.notes = "An old note on the event" # Simple text
|
|
self.event.save()
|
|
|
|
# Find the most recent version
|
|
currentVersion = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
|
|
|
|
# Check the diff is correct
|
|
self.assertEqual(currentVersion.changes.field_changes[0].diff,
|
|
[{'type': 'equal', 'text': "A"},
|
|
{'type': 'delete', 'text': " new"},
|
|
{'type': 'insert', 'text': "n old"},
|
|
{'type': 'equal', 'text': " note on the event"}
|
|
])
|
|
|
|
def test_choice_field(self):
|
|
with reversion.create_revision():
|
|
reversion.set_user(self.profile)
|
|
self.event.status = models.Event.CONFIRMED
|
|
self.event.save()
|
|
|
|
currentVersion = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
|
|
self.assertEqual(currentVersion.changes.field_changes[0].old, 'Provisional')
|
|
self.assertEqual(currentVersion.changes.field_changes[0].new, 'Confirmed')
|
|
|
|
def test_creation_behaviour(self):
|
|
firstVersion = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created').parent
|
|
diff = firstVersion.changes
|
|
|
|
# Mainly to check for exceptions:
|
|
self.assertTrue(len(diff.field_changes) > 0)
|
|
|
|
def test_event_items(self):
|
|
with reversion.create_revision():
|
|
reversion.set_user(self.profile)
|
|
item1 = models.EventItem.objects.create(event=self.event, name="TI I1", quantity=1, cost=1.00, order=1)
|
|
self.event.save()
|
|
|
|
# Find the most recent version
|
|
currentVersion = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
|
|
|
|
diffs = currentVersion.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(diffs[0].old is None)
|
|
self.assertEqual(diffs[0].new.name, "TI I1")
|
|
|
|
# Edit the item
|
|
with reversion.create_revision():
|
|
reversion.set_user(self.profile)
|
|
item1.name = "New Name"
|
|
item1.save()
|
|
self.event.save()
|
|
|
|
currentVersion = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
|
|
|
|
diffs = currentVersion.changes.item_changes
|
|
|
|
self.assertEqual(len(diffs), 1)
|
|
|
|
self.assertEqual(diffs[0].old.name, "TI I1")
|
|
self.assertEqual(diffs[0].new.name, "New Name")
|
|
|
|
# Check the diff
|
|
self.assertEqual(currentVersion.changes.item_changes[0].field_changes[0].diff,
|
|
[{'type': 'delete', 'text': "TI I1"},
|
|
{'type': 'insert', 'text': "New Name"},
|
|
])
|
|
|
|
# Delete the item
|
|
|
|
with reversion.create_revision():
|
|
item1.delete()
|
|
self.event.save()
|
|
|
|
# Find the most recent version
|
|
currentVersion = versioning.RIGSVersion.objects.get_for_object(self.event).latest('revision__date_created')
|
|
|
|
diffs = currentVersion.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.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)
|