More optimisation and cleanup (#420)

RIGS/tests/conftest.py

@@ -0,0 +1,108 @@
+from RIGS import models
+import pytest
+from django.utils import timezone
+
+
+@pytest.fixture
+def basic_event(db):
+    event = models.Event.objects.create(name="TE E1", start_date=timezone.now())
+    yield event
+    event.delete()
+
+
+@pytest.fixture
+def ra(basic_event, admin_user):
+    ra = models.RiskAssessment.objects.create(event=basic_event, nonstandard_equipment=False, nonstandard_use=False,
+                                              contractors=False, other_companies=False, crew_fatigue=False,
+                                              big_power=False, power_mic=admin_user, generators=False,
+                                              other_companies_power=False, nonstandard_equipment_power=False,
+                                              multiple_electrical_environments=False, noise_monitoring=False,
+                                              known_venue=True, safe_loading=True, safe_storage=True,
+                                              area_outside_of_control=True, barrier_required=True,
+                                              nonstandard_emergency_procedure=True, special_structures=False,
+                                              suspended_structures=False, outside=False)
+    yield ra
+    ra.delete()
+
+
+@pytest.fixture
+def medium_ra(ra):
+    ra.big_power = True
+    ra.save()
+    yield ra
+    ra.big_power = False
+    ra.save()
+
+
+@pytest.fixture
+def venue(db):
+    venue = models.Venue.objects.create(name="Venue 1")
+    yield venue
+    venue.delete()
+
+
+@pytest.fixture  # TODO parameterise with Event sizes
+def checklist(basic_event, venue, admin_user, ra):
+    checklist = models.EventChecklist.objects.create(event=basic_event, power_mic=admin_user, safe_parking=False,
+                                                     safe_packing=False, exits=False, trip_hazard=False, warning_signs=False,
+                                                     ear_plugs=False, hs_location="Locked away safely",
+                                                     extinguishers_location="Somewhere, I forgot", earthing=False, pat=False,
+                                                     date=timezone.now(), venue=venue)
+    yield checklist
+    checklist.delete()
+
+
+@pytest.fixture
+def many_events(db, admin_user, scope="class"):
+    many_events = {
+        # produce 7 normal events - 5 current
+        1: models.Event.objects.create(name="TE E1", start_date=date.today() + timedelta(days=6),
+                                       description="start future no end"),
+        2: models.Event.objects.create(name="TE E2", start_date=date.today(), description="start today no end"),
+        3: models.Event.objects.create(name="TE E3", start_date=date.today(), end_date=date.today(),
+                                       description="start today with end today"),
+        4: models.Event.objects.create(name="TE E4", start_date='2014-03-20', description="start past no end"),
+        5: models.Event.objects.create(name="TE E5", start_date='2014-03-20', end_date='2014-03-21',
+                                       description="start past with end past"),
+        6: models.Event.objects.create(name="TE E6", start_date=date.today() - timedelta(days=2),
+                                       end_date=date.today() + timedelta(days=2),
+                                       description="start past, end future"),
+        7: models.Event.objects.create(name="TE E7", start_date=date.today() + timedelta(days=2),
+                                       end_date=date.today() + timedelta(days=2),
+                                       description="start + end in future"),
+
+        # 2 cancelled - 1 current
+        8: models.Event.objects.create(name="TE E8", start_date=date.today() + timedelta(days=2),
+                                       end_date=date.today() + timedelta(days=2), status=models.Event.CANCELLED,
+                                       description="cancelled in future"),
+        9: models.Event.objects.create(name="TE E9", start_date=date.today() - timedelta(days=1),
+                                       end_date=date.today() + timedelta(days=2), status=models.Event.CANCELLED,
+                                       description="cancelled and started"),
+
+        # 5 dry hire - 3 current
+        10: models.Event.objects.create(name="TE E10", start_date=date.today(), dry_hire=True,
+                                        description="dryhire today"),
+        11: models.Event.objects.create(name="TE E11", start_date=date.today(), dry_hire=True,
+                                        checked_in_by=admin_user,
+                                        description="dryhire today, checked in"),
+        12: models.Event.objects.create(name="TE E12", start_date=date.today() - timedelta(days=1), dry_hire=True,
+                                        status=models.Event.BOOKED, description="dryhire past"),
+        13: models.Event.objects.create(name="TE E13", start_date=date.today() - timedelta(days=2), dry_hire=True,
+                                        checked_in_by=admin_user, description="dryhire past checked in"),
+        14: models.Event.objects.create(name="TE E14", start_date=date.today(), dry_hire=True,
+                                        status=models.Event.CANCELLED, description="dryhire today cancelled"),
+
+        # 4 non rig - 3 current
+        15: models.Event.objects.create(name="TE E15", start_date=date.today(), is_rig=False,
+                                        description="non rig today"),
+        16: models.Event.objects.create(name="TE E16", start_date=date.today() + timedelta(days=1), is_rig=False,
+                                        description="non rig tomorrow"),
+        17: models.Event.objects.create(name="TE E17", start_date=date.today() - timedelta(days=1), is_rig=False,
+                                        description="non rig yesterday"),
+        18: models.Event.objects.create(name="TE E18", start_date=date.today(), is_rig=False,
+                                        status=models.Event.CANCELLED,
+                                        description="non rig today cancelled"),
+    }
+    yield many_events
+    for event in many_events:
+        event.delete()

RIGS/tests/pages.py

@@ -52,7 +52,7 @@ class EventDetail(BasePage):
     URL_TEMPLATE = 'event/{event_id}'
 
     # TODO Refactor into regions to match template fragmentation
-    _event_name_selector = (By.XPATH, '//h1')
+    _event_name_selector = (By.XPATH, '//h2')
     _person_panel_selector = (By.XPATH, '//div[contains(text(), "Contact Details")]/..')
     _name_selector = (By.XPATH, '//dt[text()="Person"]/following-sibling::dd[1]')
     _email_selector = (By.XPATH, '//dt[text()="Email"]/following-sibling::dd[1]')
@@ -230,9 +230,11 @@ class CreateEventChecklist(FormPage):
     URL_TEMPLATE = 'event/{event_id}/checklist'
 
     _submit_locator = (By.XPATH, "//button[@type='submit' and contains(., 'Save')]")
-    _power_mic_selector = (By.XPATH, "//div[@id='id_power_mic-group']//div[contains(@class, 'bootstrap-select')]")
+    _power_mic_selector = (By.XPATH, "//div[select[@id='id_power_mic']]")
     _add_vehicle_locator = (By.XPATH, "//button[contains(., 'Vehicle')]")
     _add_crew_locator = (By.XPATH, "//button[contains(., 'Crew')]")
+    _vehicle_row_locator = ('xpath', "//tr[@id[starts-with(., 'vehicle') and not(contains(.,'new'))]]")
+    _crew_row_locator = ('xpath', "//tr[@id[starts-with(., 'crew') and not(contains(.,'new'))]]")
 
     form_items = {
         'safe_parking': (regions.CheckBox, (By.ID, 'id_safe_parking')),
@@ -271,11 +273,61 @@ class CreateEventChecklist(FormPage):
     def power_mic(self):
         return regions.BootstrapSelectElement(self, self.find_element(*self._power_mic_selector))
 
+    @property
+    def vehicles(self):
+        return [self.VehicleRow(self, el) for el in self.find_elements(*self._vehicle_row_locator)]
+
+    class VehicleRow(Region):
+        _name_locator = ('xpath', ".//input")
+        _select_locator = ('xpath', ".//div[contains(@class,'bootstrap-select')]/..")
+
+        @property
+        def name(self):
+            return regions.TextBox(self, self.root.find_element(*self._name_locator))
+
+        @property
+        def vehicle(self):
+            return regions.BootstrapSelectElement(self, self.root.find_element(*self._select_locator))
+
+    @property
+    def crew(self):
+        return [self.CrewRow(self, el) for el in self.find_elements(*self._crew_row_locator)]
+
+    class CrewRow(Region):
+        _select_locator = ('xpath', ".//div[contains(@class,'bootstrap-select')]/..")
+        _start_time_locator = ('xpath', ".//input[@name[starts-with(., 'start') and not(contains(.,'new'))]]")
+        _end_time_locator = ('xpath', ".//input[@name[starts-with(., 'end') and not(contains(.,'new'))]]")
+        _role_locator = ('xpath', ".//input[@name[starts-with(., 'role') and not(contains(.,'new'))]]")
+
+        @property
+        def crewmember(self):
+            return regions.BootstrapSelectElement(self, self.root.find_element(*self._select_locator))
+
+        @property
+        def start_time(self):
+            return regions.DateTimePicker(self, self.root.find_element(*self._start_time_locator))
+
+        @property
+        def end_time(self):
+            return regions.DateTimePicker(self, self.root.find_element(*self._end_time_locator))
+
+        @property
+        def role(self):
+            return regions.TextBox(self, self.root.find_element(*self._role_locator))
+
     @property
     def success(self):
         return '{event_id}' not in self.driver.current_url
 
 
+class EditEventChecklist(CreateEventChecklist):
+    URL_TEMPLATE = '/event/checklist/{pk}/edit'
+
+    @property
+    def success(self):
+        return 'edit' not in self.driver.current_url
+
+
 class GenericList(BasePage):
     _search_selector = (By.CSS_SELECTOR, 'div.input-group:nth-child(2) > input:nth-child(1)')
     _search_go_selector = (By.ID, 'id_search')

RIGS/tests/test_functional.py

@@ -8,54 +8,12 @@ from django.http import HttpResponseBadRequest
 from django.test import TestCase
 from django.urls import reverse
 
+import PyRIGS.tests.base
 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 +42,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)
@@ -138,7 +108,7 @@ def test_duplicate_warning(client, admin_user):
     assertContains(response, 'amount has changed')
 
 
-@pytest.mark.django_db(transaction=True)
+@pytest.mark.django_db
 def test_email_sent(admin_client, admin_user, mailoutbox):
     event = setup_event()
     auth_data, hmac, url = setup_mail(event, admin_user)
@@ -152,36 +122,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

RIGS/tests/test_interaction.py

@@ -15,6 +15,11 @@ from PyRIGS.tests.pages import animation_is_finished
 from RIGS import models
 from RIGS.tests import regions
 from . import pages
+import pytest
+import time as t
+
+
+pytestmark = pytest.mark.django_db(transaction=True)
 
 
 @screenshot_failure_cls
@@ -307,13 +312,13 @@ class TestEventDuplicate(BaseRigboardTest):
         # TODO Rewrite when EventDetail page is implemented
         newEvent = models.Event.objects.latest('pk')
 
-        self.assertEqual(newEvent.auth_request_to, None)
+        assert newEvent.auth_request_to == ''
         self.assertEqual(newEvent.auth_request_by, None)
         self.assertEqual(newEvent.auth_request_at, None)
 
         self.assertFalse(newEvent.authorised)
 
-        self.assertNotIn("N%05d" % self.testEvent.pk, self.driver.find_element_by_xpath('//h1').text)
+        self.assertNotIn("N%05d" % self.testEvent.pk, self.driver.find_element_by_xpath('//h2').text)
         self.assertNotIn("Event data duplicated but not yet saved", self.page.warning)  # Check info message not visible
 
         # Check the new items are visible
@@ -445,7 +450,7 @@ class TestEventDetail(BaseRigboardTest):
         self.assertIn("N%05d | %s" % (self.testEvent.pk, self.testEvent.name), self.page.event_name)
         self.assertEqual(self.client.name, self.page.name)
         self.assertEqual(self.client.email, self.page.email)
-        self.assertEqual(self.client.phone, None)
+        assert self.client.phone == ''
 
 
 @screenshot_failure_cls
@@ -633,270 +638,190 @@ class TestCalendar(BaseRigboardTest):
             else:
                 self.assertNotContains(response, "TE E" + str(test) + " ")
 
-    def test_calendar_buttons(self):  # If FullCalendar fails to load for whatever reason, the buttons don't work
-        self.page = pages.CalendarPage(self.driver, self.live_server_url).open()
-        self.assertIn(timezone.now().strftime("%Y-%m"), self.driver.current_url)
 
-        target_date = datetime.date(2020, 1, 1)
-        self.page.target_date.set_value(target_date)
-        self.page.go()
-        self.assertIn(self.page.target_date.value.strftime("%Y-%m"), self.driver.current_url)
+def test_calendar_buttons(logged_in_browser, live_server):  # If FullCalendar fails to load for whatever reason, the buttons don't work
+    page = pages.CalendarPage(logged_in_browser.driver, live_server.url).open()
+    assert timezone.now().strftime("%Y-%m") in logged_in_browser.url
 
-        self.page.next()
-        target_date += datetime.timedelta(days=32)
-        self.assertIn(target_date.strftime("%m"), self.driver.current_url)
+    target_date = datetime.date(2020, 1, 1)
+    page.target_date.set_value(target_date)
+    page.go()
+    assert page.target_date.value.strftime("%Y-%m") in logged_in_browser.url
+
+    page.next()
+    target_date += datetime.timedelta(days=32)
+    assert target_date.strftime("%m") in logged_in_browser.url
 
 
-@screenshot_failure_cls
-class TestHealthAndSafety(BaseRigboardTest):
-    def setUp(self):
-        super().setUp()
-        self.profile = models.Profile.objects.get_or_create(
-            first_name='Test',
-            last_name='TEC User',
-            username='eventtest',
-            email='teccie@functional.test',
-            is_superuser=True  # lazily grant all permissions
-        )[0]
-        self.venue = models.Venue.objects.create(name="Venue 1")
+def test_ra_edit(logged_in_browser, live_server, ra):
+    page = pages.EditRiskAssessment(logged_in_browser.driver, live_server.url, pk=ra.pk).open()
+    page.nonstandard_equipment = nse = True
+    page.general_notes = gn = "There are some notes, but I've not written them here as that would be helpful"
+    page.submit()
+    assert not page.success
+    page.supervisor_consulted = True
+    page.submit()
+    assert page.success
+    # Check that data is right
+    ra = models.RiskAssessment.objects.get(pk=ra.pk)
+    assert ra.general_notes == gn
+    assert ra.nonstandard_equipment == nse
 
-        self.testEvent = models.Event.objects.create(name="TE E1", status=models.Event.PROVISIONAL,
-                                                     start_date=date.today() + timedelta(days=6),
-                                                     description="start future no end",
-                                                     purchase_order='TESTPO',
-                                                     person=self.client,
-                                                     venue=self.venue)
-        self.testEvent2 = models.Event.objects.create(name="TE E2", status=models.Event.PROVISIONAL,
-                                                      start_date=date.today() + timedelta(days=6),
-                                                      description="start future no end",
-                                                      purchase_order='TESTPO',
-                                                      person=self.client,
-                                                      venue=self.venue)
-        self.testEvent3 = models.Event.objects.create(name="TE E3", status=models.Event.PROVISIONAL,
-                                                      start_date=date.today() + timedelta(days=6),
-                                                      description="start future no end",
-                                                      purchase_order='TESTPO',
-                                                      person=self.client,
-                                                      venue=self.venue)
-        self.testRA = models.RiskAssessment.objects.create(event=self.testEvent2, supervisor_consulted=False, nonstandard_equipment=False,
-                                                           nonstandard_use=False,
-                                                           contractors=False,
-                                                           other_companies=False,
-                                                           crew_fatigue=False,
-                                                           big_power=False,
-                                                           generators=False,
-                                                           other_companies_power=False,
-                                                           nonstandard_equipment_power=False,
-                                                           multiple_electrical_environments=False,
-                                                           noise_monitoring=False,
-                                                           known_venue=True,
-                                                           safe_loading=True,
-                                                           safe_storage=True,
-                                                           area_outside_of_control=False,
-                                                           barrier_required=False,
-                                                           nonstandard_emergency_procedure=False,
-                                                           special_structures=False,
-                                                           suspended_structures=False,
-                                                           outside=False)
-        self.testRA2 = models.RiskAssessment.objects.create(event=self.testEvent3, supervisor_consulted=False, nonstandard_equipment=False,
-                                                            nonstandard_use=False,
-                                                            contractors=False,
-                                                            other_companies=False,
-                                                            crew_fatigue=False,
-                                                            big_power=True,
-                                                            generators=False,
-                                                            other_companies_power=False,
-                                                            nonstandard_equipment_power=False,
-                                                            multiple_electrical_environments=False,
-                                                            noise_monitoring=False,
-                                                            known_venue=True,
-                                                            safe_loading=True,
-                                                            safe_storage=True,
-                                                            area_outside_of_control=False,
-                                                            barrier_required=False,
-                                                            nonstandard_emergency_procedure=False,
-                                                            special_structures=False,
-                                                            suspended_structures=False,
-                                                            outside=False)
-        self.page = pages.EventDetail(self.driver, self.live_server_url, event_id=self.testEvent.pk).open()
 
-    # TODO Can I loop through all the boolean fields and test them at once?
-    def test_ra_creation(self):
-        self.page = pages.CreateRiskAssessment(self.driver, self.live_server_url, event_id=self.testEvent.pk).open()
+def small_ec(page, admin_user):
+    page.safe_parking = True
+    page.safe_packing = True
+    page.exits = True
+    page.trip_hazard = True
+    page.warning_signs = True
+    page.ear_plugs = True
+    page.hs_location = "The Moon"
+    page.extinguishers_location = "With the rest of the fire"
+    # If we do this first the search fails, for ... reasons
+    page.power_mic.search(admin_user.name)
+    page.power_mic.toggle()
+    assert not page.power_mic.is_open
+    page.earthing = True
+    page.rcds = True
+    page.supply_test = True
+    page.pat = True
 
-        # Check there are no defaults
-        self.assertIsNone(self.page.nonstandard_equipment)
 
-        # No database side validation, only HTML5.
+def test_ec_create_small(logged_in_browser, live_server, admin_user, ra):
+    page = pages.CreateEventChecklist(logged_in_browser.driver, live_server.url, event_id=ra.event.pk).open()
+    small_ec(page, admin_user)
+    page.submit()
+    assert page.success
 
-        self.page.nonstandard_equipment = False
-        self.page.nonstandard_use = False
-        self.page.contractors = False
-        self.page.other_companies = False
-        self.page.crew_fatigue = False
-        self.page.general_notes = "There are no notes."
-        self.page.big_power = False
-        self.page.outside = False
-        self.page.power_mic.search(self.profile.name)
-        self.page.power_mic.set_option(self.profile.name, True)
-        # TODO This should not be necessary, normally closes automatically
-        self.page.power_mic.toggle()
-        self.assertFalse(self.page.power_mic.is_open)
-        self.page.generators = False
-        self.page.other_companies_power = False
-        self.page.nonstandard_equipment_power = False
-        self.page.multiple_electrical_environments = False
-        self.page.power_notes = "Remember to bring some power"
-        self.page.noise_monitoring = False
-        self.page.sound_notes = "Loud, but not too loud"
-        self.page.known_venue = False
-        self.page.safe_loading = False
-        self.page.safe_storage = False
-        self.page.area_outside_of_control = False
-        self.page.barrier_required = False
-        self.page.nonstandard_emergency_procedure = False
-        self.page.special_structures = False
-        # self.page.persons_responsible_structures = "Nobody and her cat, She"
 
-        self.page.suspended_structures = True
-        # TODO Test for this proper
-        self.page.rigging_plan = "https://nottinghamtec.sharepoint.com/test/"
-        self.page.submit()
-        self.assertFalse(self.page.success)
+def test_ec_create_medium(logged_in_browser, live_server, admin_user, medium_ra):
+    page = pages.CreateEventChecklist(logged_in_browser.driver, live_server.url, event_id=medium_ra.event.pk).open()
 
-        self.page.suspended_structures = False
-        self.page.submit()
-        self.assertTrue(self.page.success)
+    page.safe_parking = True
+    page.safe_packing = True
+    page.exits = True
+    page.trip_hazard = True
+    page.warning_signs = True
+    page.ear_plugs = True
+    page.hs_location = "Death Valley"
+    page.extinguishers_location = "With the rest of the fire"
+    # If we do this first the search fails, for ... reasons
+    page.power_mic.search(admin_user.name)
+    page.power_mic.toggle()
+    assert not page.power_mic.is_open
 
-        # Test that we can't make another one
-        self.page = pages.CreateRiskAssessment(self.driver, self.live_server_url, event_id=self.testEvent.pk).open()
-        self.assertIn('edit', self.driver.current_url)
+    # Gotta scroll to make the button clickable
+    logged_in_browser.driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
 
-    def test_ra_edit(self):
-        self.page = pages.EditRiskAssessment(self.driver, self.live_server_url, pk=self.testRA.pk).open()
-        self.page.nonstandard_equipment = nse = True
-        self.page.general_notes = gn = "There are some notes, but I've not written them here as that would be helpful"
-        self.page.submit()
-        self.assertFalse(self.page.success)
-        self.page.supervisor_consulted = True
-        self.page.submit()
-        self.assertTrue(self.page.success)
-        # Check that data is right
-        ra = models.RiskAssessment.objects.get(pk=self.testRA.pk)
-        self.assertEqual(ra.general_notes, gn)
-        self.assertEqual(ra.nonstandard_equipment, nse)
+    page.earthing = True
+    page.pat = True
+    page.source_rcd = True
+    page.labelling = True
+    page.fd_voltage_l1 = 240
+    page.fd_voltage_l2 = 235
+    page.fd_voltage_l3 = 0
+    page.fd_phase_rotation = True
+    page.fd_earth_fault = 666
+    page.fd_pssc = 1984
+    page.w1_description = "In the carpark, by the bins"
+    page.w1_polarity = True
+    page.w1_voltage = 240
+    page.w1_earth_fault = 333
 
-    def test_ec_create_small(self):
-        self.page = pages.CreateEventChecklist(self.driver, self.live_server_url, event_id=self.testEvent2.pk).open()
+    page.submit()
+    assert page.success
 
-        self.page.safe_parking = True
-        self.page.safe_packing = True
-        self.page.exits = True
-        self.page.trip_hazard = True
-        self.page.warning_signs = True
-        self.page.ear_plugs = True
-        self.page.hs_location = "The Moon"
-        self.page.extinguishers_location = "With the rest of the fire"
-        # If we do this first the search fails, for ... reasons
-        self.page.power_mic.search(self.profile.name)
-        self.page.power_mic.toggle()
-        self.assertFalse(self.page.power_mic.is_open)
 
-        # Gotta scroll to make the button clickable
-        self.driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
+def test_ec_create_vehicle(logged_in_browser, live_server, admin_user, checklist):
+    page = pages.EditEventChecklist(logged_in_browser.driver, live_server.url, pk=checklist.pk).open()
+    small_ec(page, admin_user)
+    page.add_vehicle()
+    assert len(page.vehicles) == 1
+    vehicle_name = 'Brian'
+    page.vehicles[0].name.set_value(vehicle_name)
+    # Appears we're moving too fast for javascript...
+    t.sleep(1)
+    page.vehicles[0].vehicle.search(admin_user.first_name)
+    t.sleep(1)
+    page.submit()
+    assert page.success
+    # Check data is correct
+    checklist.refresh_from_db()
+    vehicle = models.EventChecklistVehicle.objects.get(checklist=checklist.pk)
+    assert vehicle_name == vehicle.vehicle
 
-        self.page.earthing = True
-        self.page.rcds = True
-        self.page.supply_test = True
-        self.page.pat = True
 
-        self.page.submit()
-        self.assertTrue(self.page.success)
+# TODO Test validation of end before start
+def test_ec_create_crew(logged_in_browser, live_server, admin_user, checklist):
+    page = pages.EditEventChecklist(logged_in_browser.driver, live_server.url, pk=checklist.pk).open()
+    small_ec(page, admin_user)
+    page.add_crew()
+    assert len(page.crew) == 1
+    role = "MIC"
+    start_time = timezone.make_aware(datetime.datetime(2015, 1, 1, 9, 0))
+    end_time = timezone.make_aware(datetime.datetime(2015, 1, 1, 10, 30))
+    crew = page.crew[0]
+    t.sleep(2)
+    crew.crewmember.search(admin_user.first_name)
+    t.sleep(2)
+    crew.role.set_value(role)
+    crew.start_time.set_value(start_time)
+    crew.end_time.set_value(end_time)
+    page.submit()
+    assert page.success
+    # Check data is correct
+    crew_obj = models.EventChecklistCrew.objects.get(checklist=checklist.pk)
+    assert admin_user.pk == crew_obj.crewmember.pk
+    assert role == crew_obj.role
+    assert start_time == crew_obj.start
+    assert end_time == crew_obj.end
 
-    def test_ec_create_medium(self):
-        self.page = pages.CreateEventChecklist(self.driver, self.live_server_url, event_id=self.testEvent3.pk).open()
 
-        self.page.safe_parking = True
-        self.page.safe_packing = True
-        self.page.exits = True
-        self.page.trip_hazard = True
-        self.page.warning_signs = True
-        self.page.ear_plugs = True
-        self.page.hs_location = "Death Valley"
-        self.page.extinguishers_location = "With the rest of the fire"
-        # If we do this first the search fails, for ... reasons
-        self.page.power_mic.search(self.profile.name)
-        self.page.power_mic.toggle()
-        self.assertFalse(self.page.power_mic.is_open)
+# TODO Can I loop through all the boolean fields and test them at once?
+def test_ra_creation(logged_in_browser, live_server, admin_user, basic_event):
+    page = pages.CreateRiskAssessment(logged_in_browser.driver, live_server.url, event_id=basic_event.pk).open()
 
-        # Gotta scroll to make the button clickable
-        self.driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
+    # Check there are no defaults
+    assert page.nonstandard_equipment is None
 
-        self.page.earthing = True
-        self.page.pat = True
-        self.page.source_rcd = True
-        self.page.labelling = True
-        self.page.fd_voltage_l1 = 240
-        self.page.fd_voltage_l2 = 235
-        self.page.fd_voltage_l3 = 0
-        self.page.fd_phase_rotation = True
-        self.page.fd_earth_fault = 666
-        self.page.fd_pssc = 1984
-        self.page.w1_description = "In the carpark, by the bins"
-        self.page.w1_polarity = True
-        self.page.w1_voltage = 240
-        self.page.w1_earth_fault = 333
+    # No database side validation, only HTML5.
+    page.nonstandard_equipment = False
+    page.nonstandard_use = False
+    page.contractors = False
+    page.other_companies = False
+    page.crew_fatigue = False
+    page.general_notes = "There are no notes."
+    page.big_power = False
+    page.outside = False
+    page.power_mic.search(admin_user.first_name)
+    page.generators = False
+    page.other_companies_power = False
+    page.nonstandard_equipment_power = False
+    page.multiple_electrical_environments = False
+    page.power_notes = "Remember to bring some power"
+    page.noise_monitoring = False
+    page.sound_notes = "Loud, but not too loud"
+    page.known_venue = False
+    page.safe_loading = False
+    page.safe_storage = False
+    page.area_outside_of_control = False
+    page.barrier_required = False
+    page.nonstandard_emergency_procedure = False
+    page.special_structures = False
+    # self.page.persons_responsible_structures = "Nobody and her cat, She"
 
-        self.page.submit()
-        self.assertTrue(self.page.success)
+    page.suspended_structures = True
+    # TODO Test for this proper
+    page.rigging_plan = "https://nottinghamtec.sharepoint.com/test/"
+    page.submit()
+    assert not page.success
 
-    def test_ec_create_extras(self):
-        eid = self.testEvent2.pk
-        self.page = pages.CreateEventChecklist(self.driver, self.live_server_url, event_id=eid).open()
-        self.page.add_vehicle()
-        self.page.add_crew()
+    page.suspended_structures = False
+    page.submit()
+    assert page.success
 
-        self.page.safe_parking = True
-        self.page.safe_packing = True
-        self.page.exits = True
-        self.page.trip_hazard = True
-        self.page.warning_signs = True
-        self.page.ear_plugs = True
-        self.page.hs_location = "The Moon"
-        self.page.extinguishers_location = "With the rest of the fire"
-        # If we do this first the search fails, for ... reasons
-        self.page.power_mic.search(self.profile.name)
-        self.page.power_mic.toggle()
-        self.assertFalse(self.page.power_mic.is_open)
 
-        vehicle_name = 'Brian'
-        self.driver.find_element(By.XPATH, '//*[@name="vehicle_-1"]').send_keys(vehicle_name)
-        driver = base_regions.BootstrapSelectElement(self.page, self.driver.find_element(By.XPATH, '//tr[@id="vehicles_-1"]//div[contains(@class, "bootstrap-select")]'))
-        driver.search(self.profile.name)
-
-        crew = self.profile
-        role = "MIC"
-        crew_select = base_regions.BootstrapSelectElement(self.page, self.driver.find_element(By.XPATH, '//tr[@id="crew_-1"]//div[contains(@class, "bootstrap-select")]'))
-        start_time = base_regions.DateTimePicker(self.page, self.driver.find_element(By.XPATH, '//*[@name="start_-1"]'))
-        end_time = base_regions.DateTimePicker(self.page, self.driver.find_element(By.XPATH, '//*[@name="end_-1"]'))
-
-        start_time.set_value(timezone.make_aware(datetime.datetime(2015, 1, 1, 9, 0)))
-        # TODO Test validation of end before start
-        end_time.set_value(timezone.make_aware(datetime.datetime(2015, 1, 1, 10, 30)))
-        crew_select.search(crew.name)
-        self.driver.find_element(By.XPATH, '//*[@name="role_-1"]').send_keys(role)
-
-        self.page.earthing = True
-        self.page.rcds = True
-        self.page.supply_test = True
-        self.page.pat = True
-
-        self.page.submit()
-        self.assertTrue(self.page.success)
-
-        checklist = models.EventChecklist.objects.get(event=eid)
-        vehicle = models.EventChecklistVehicle.objects.get(checklist=checklist.pk)
-        self.assertEqual(vehicle_name, vehicle.vehicle)
-        crew_obj = models.EventChecklistCrew.objects.get(checklist=checklist.pk)
-        self.assertEqual(crew.pk, crew_obj.crewmember.pk)
-        self.assertEqual(role, crew_obj.role)
+def test_ra_no_duplicates(logged_in_browser, live_server, ra):
+    # Test that we can't make another one
+    page = pages.CreateRiskAssessment(logged_in_browser.driver, live_server.url, event_id=ra.event.pk).open()
+    assert 'edit' in logged_in_browser.url

RIGS/tests/test_models.py

@@ -2,6 +2,7 @@ from datetime import date, timedelta, datetime, time
 from decimal import *
 
 import pytz
+import pytest
 from django.conf import settings
 from django.test import TestCase
 from reversion import revisions as reversion
@@ -9,110 +10,56 @@ from reversion import revisions as reversion
 from RIGS import models
 
 
-class ProfileTestCase(TestCase):
-    def test_str(self):
-        profile = models.Profile(first_name='Test', last_name='Case')
-        self.assertEqual(str(profile), 'Test Case')
-        profile.initials = 'TC'
-        self.assertEqual(str(profile), 'Test Case "TC"')
+def assert_decimal_equality(d1, d2):
+    assert float(d1) == pytest.approx(float(d2))
 
 
-class VatRateTestCase(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        cls.rates = {
-            0: models.VatRate.objects.create(start_at='2014-03-01', rate=0.20, comment='test1'),
-            1: models.VatRate.objects.create(start_at='2016-03-01', rate=0.15, comment='test2'),
-        }
-
-    def test_find_correct(self):
-        r = models.VatRate.objects.find_rate('2015-03-01')
-        self.assertEqual(r, self.rates[0])
-        r = models.VatRate.objects.find_rate('2016-03-01')
-        self.assertEqual(r, self.rates[1])
-
-    def test_percent_correct(self):
-        self.assertEqual(self.rates[0].as_percent, 20)
+def test_str():
+    profile = models.Profile(first_name='Test', last_name='Case')
+    assert str(profile) == 'Test Case'
+    profile.initials = 'TC'
+    assert str(profile) == 'Test Case "TC"'
 
 
-class EventTestCase(TestCase):
-    @classmethod
-    def setUpTestData(cls):
-        cls.all_events = set(range(1, 18))
-        cls.current_events = (1, 2, 3, 6, 7, 8, 10, 11, 12, 14, 15, 16, 18)
-        cls.not_current_events = set(cls.all_events) - set(cls.current_events)
+@pytest.mark.django_db
+def test_find_correct(vat_rate):
+    new_rate = models.VatRate.objects.create(start_at='2016-03-01', rate=0.15, comment='test2')
+    r = models.VatRate.objects.find_rate('2015-03-01')
+    assert_decimal_equality(r.rate, vat_rate.rate)
+    r = models.VatRate.objects.find_rate('2016-03-01')
+    assert_decimal_equality(r.rate, new_rate.rate)
 
-        cls.vatrate = models.VatRate.objects.create(start_at='2014-03-05', rate=0.20, comment='test1')
-        cls.profile = models.Profile.objects.create(username="testuser1", email="1@test.com")
 
-        cls.events = {
-            # produce 7 normal events - 5 current
-            1: models.Event.objects.create(name="TE E1", start_date=date.today() + timedelta(days=6),
-                                           description="start future no end"),
-            2: models.Event.objects.create(name="TE E2", start_date=date.today(), description="start today no end"),
-            3: models.Event.objects.create(name="TE E3", start_date=date.today(), end_date=date.today(),
-                                           description="start today with end today"),
-            4: models.Event.objects.create(name="TE E4", start_date='2014-03-20', description="start past no end"),
-            5: models.Event.objects.create(name="TE E5", start_date='2014-03-20', end_date='2014-03-21',
-                                           description="start past with end past"),
-            6: models.Event.objects.create(name="TE E6", start_date=date.today() - timedelta(days=2),
-                                           end_date=date.today() + timedelta(days=2),
-                                           description="start past, end future"),
-            7: models.Event.objects.create(name="TE E7", start_date=date.today() + timedelta(days=2),
-                                           end_date=date.today() + timedelta(days=2),
-                                           description="start + end in future"),
+def test_percent_correct(vat_rate):
+    assert vat_rate.as_percent == 20
 
-            # 2 cancelled - 1 current
-            8: models.Event.objects.create(name="TE E8", start_date=date.today() + timedelta(days=2),
-                                           end_date=date.today() + timedelta(days=2), status=models.Event.CANCELLED,
-                                           description="cancelled in future"),
-            9: models.Event.objects.create(name="TE E9", start_date=date.today() - timedelta(days=1),
-                                           end_date=date.today() + timedelta(days=2), status=models.Event.CANCELLED,
-                                           description="cancelled and started"),
 
-            # 5 dry hire - 3 current
-            10: models.Event.objects.create(name="TE E10", start_date=date.today(), dry_hire=True,
-                                            description="dryhire today"),
-            11: models.Event.objects.create(name="TE E11", start_date=date.today(), dry_hire=True,
-                                            checked_in_by=cls.profile,
-                                            description="dryhire today, checked in"),
-            12: models.Event.objects.create(name="TE E12", start_date=date.today() - timedelta(days=1), dry_hire=True,
-                                            status=models.Event.BOOKED, description="dryhire past"),
-            13: models.Event.objects.create(name="TE E13", start_date=date.today() - timedelta(days=2), dry_hire=True,
-                                            checked_in_by=cls.profile, description="dryhire past checked in"),
-            14: models.Event.objects.create(name="TE E14", start_date=date.today(), dry_hire=True,
-                                            status=models.Event.CANCELLED, description="dryhire today cancelled"),
+def test_related_vatrate(basic_event, vat_rate):
+    assert_decimal_equality(vat_rate.rate, basic_event.vat_rate.rate)
 
-            # 4 non rig - 3 current
-            15: models.Event.objects.create(name="TE E15", start_date=date.today(), is_rig=False,
-                                            description="non rig today"),
-            16: models.Event.objects.create(name="TE E16", start_date=date.today() + timedelta(days=1), is_rig=False,
-                                            description="non rig tomorrow"),
-            17: models.Event.objects.create(name="TE E17", start_date=date.today() - timedelta(days=1), is_rig=False,
-                                            description="non rig yesterday"),
-            18: models.Event.objects.create(name="TE E18", start_date=date.today(), is_rig=False,
-                                            status=models.Event.CANCELLED,
-                                            description="non rig today cancelled"),
-        }
 
-    def test_count(self):
-        # Santiy check we have the expected events created
-        self.assertEqual(models.Event.objects.count(), 18, "Incorrect number of events, check setup")
+class EventTest():
+    def test_count(many_events):
+        # Sanity check we have the expected events created
+        assert models.Event.objects.count() == 18
 
-    def test_rig_count(self):
+    def test_rig_count(many_events):
         # Changed to not include unreturned dry hires in rig count
-        self.assertEqual(models.Event.objects.rig_count(), 7)
+        assert models.Event.objects.rig_count() == 7
 
-    def test_current_events(self):
+    def test_current_events(many_events):
+        all_events = set(range(1, 18))
+        current_events = (1, 2, 3, 6, 7, 8, 10, 11, 12, 14, 15, 16, 18)
+        not_current_events = set(cls.all_events) - set(cls.current_events)
         current_events = models.Event.objects.current_events()
-        self.assertEqual(len(current_events), len(self.current_events))
-        for eid in self.current_events:
-            self.assertIn(models.Event.objects.get(name="TE E%d" % eid), current_events)
+        assert len(current_events) == len(self.current_events)
+        for eid in current_events:
+            assert models.Event.objects.get(name="TE E%d" % eid) in current_events
 
-        for eid in self.not_current_events:
-            self.assertNotIn(models.Event.objects.get(name="TE E%d" % eid), current_events)
+        for eid in not_current_events:
+            assert models.Event.objects.get(name="TE E%d" % eid) not in current_events
 
-    def test_related_venue(self):
+    def test_related(many_events):
         v1 = models.Venue.objects.create(name="TE V1")
         v2 = models.Venue.objects.create(name="TE V2")
 
@@ -127,16 +74,13 @@ class EventTestCase(TestCase):
                 e2.append(event)
             event.save()
 
-        self.assertCountEqual(e1, v1.latest_events)
-        self.assertCountEqual(e2, v2.latest_events)
+        assert set(e1) == set(v1.latest_events)
+        assert set(e2) == set(v2.latest_events)
+        # Cleanup
+        v1.delete()
+        v2.delete()
 
-        for (key, event) in self.events.items():
-            event.venue = None
-
-    def test_related_vatrate(self):
-        self.assertEqual(self.vatrate, models.Event.objects.all()[0].vat_rate)
-
-    def test_related_person(self):
+    def test_related_person(many_events):
         p1 = models.Person.objects.create(name="TE P1")
         p2 = models.Person.objects.create(name="TE P2")
 
@@ -151,13 +95,13 @@ class EventTestCase(TestCase):
                 e2.append(event)
             event.save()
 
-        self.assertCountEqual(e1, p1.latest_events)
-        self.assertCountEqual(e2, p2.latest_events)
+        assert set(e1) == set(p1.latest_events)
+        assert set(e2) == set(p2.latest_events)
 
-        for (key, event) in self.events.items():
-            event.person = None
+        p1.delete()
+        p2.delete()
 
-    def test_related_organisation(self):
+    def test_related_organisation(many_events):
         o1 = models.Organisation.objects.create(name="TE O1")
         o2 = models.Organisation.objects.create(name="TE O2")
 
@@ -172,13 +116,13 @@ class EventTestCase(TestCase):
                 e2.append(event)
             event.save()
 
-        self.assertCountEqual(e1, o1.latest_events)
-        self.assertCountEqual(e2, o2.latest_events)
+        assert set(e1) == set(o1.latest_events)
+        assert set(e1) == set(o2.latest_events)
 
         for (key, event) in self.events.items():
             event.organisation = None
 
-    def test_organisation_person_join(self):
+    def test_organisation_person_join(many_events):
         p1 = models.Person.objects.create(name="TE P1")
         p2 = models.Person.objects.create(name="TE P2")
         o1 = models.Organisation.objects.create(name="TE O1")
@@ -202,105 +146,109 @@ class EventTestCase(TestCase):
         events = models.Event.objects.all()
 
         # Check person's organisations
-        self.assertIn((o1, 2), p1.organisations)
-        self.assertIn((o2, 1), p1.organisations)
-        self.assertIn((o1, 2), p2.organisations)
-        self.assertEqual(len(p2.organisations), 1)
+        assert (o1, 2) in p1.organisations
+        assert (o2, 1) in p1.organisations
+        assert (o1, 2) in p2.organisations
+        assert len(p2.organisations) == 1
 
         # Check organisation's persons
-        self.assertIn((p1, 2), o1.persons)
-        self.assertIn((p2, 2), o1.persons)
-        self.assertIn((p1, 1), o2.persons)
-        self.assertEqual(len(o2.persons), 1)
+        assert (p1, 2) in o1.persons
+        assert (p2, 2) in o1.persons
+        assert (p1, 1) in o2.persons
+        assert len(o2.persons) == 1
 
-    def test_cancelled_property(self):
-        edit = self.events[1]
+    def test_cancelled_property(many_events):
+        edit = many_events[1]
         edit.status = models.Event.CANCELLED
         edit.save()
         event = models.Event.objects.get(pk=edit.pk)
-        self.assertEqual(event.status, models.Event.CANCELLED)
-        self.assertTrue(event.cancelled)
+        assert event.status == models.Event.CANCELLED
+        assert event.cancelled
         event.status = models.Event.PROVISIONAL
         event.save()
 
-    def test_confirmed_property(self):
-        edit = self.events[1]
+    def test_confirmed_property(many_events):
+        edit = many_events[1]
         edit.status = models.Event.CONFIRMED
         edit.save()
         event = models.Event.objects.get(pk=edit.pk)
-        self.assertEqual(event.status, models.Event.CONFIRMED)
-        self.assertTrue(event.confirmed)
+        assert event.status == models.Event.CONFIRMED
+        assert event.confirmed
         event.status = models.Event.PROVISIONAL
         event.save()
 
-    def test_earliest_time(self):
-        event = models.Event(name="TE ET", start_date=date(2016, 0o1, 0o1))
 
-        # Just a start date
-        self.assertEqual(event.earliest_time, date(2016, 0o1, 0o1))
+def test_earliest_time():
+    event = models.Event(name="TE ET", start_date=date(2016, 0o1, 0o1))
 
-        # With start time
-        event.start_time = time(9, 00)
-        self.assertEqual(event.earliest_time, self.create_datetime(2016, 1, 1, 9, 00))
+    # Just a start date
+    assert event.earliest_time == date(2016, 0o1, 0o1)
 
-        # With access time
-        event.access_at = self.create_datetime(2015, 12, 0o3, 9, 57)
-        self.assertEqual(event.earliest_time, event.access_at)
+    # With start time
+    event.start_time = time(9, 00)
+    assert event.earliest_time == create_datetime(2016, 1, 1, 9, 00)
 
-        # With meet time
-        event.meet_at = self.create_datetime(2015, 12, 0o3, 9, 55)
-        self.assertEqual(event.earliest_time, event.meet_at)
+    # With access time
+    event.access_at = create_datetime(2015, 12, 0o3, 9, 57)
+    assert event.earliest_time == event.access_at
 
-        # Check order isn't important
-        event.start_date = date(2015, 12, 0o3)
-        self.assertEqual(event.earliest_time, self.create_datetime(2015, 12, 0o3, 9, 00))
+    # With meet time
+    event.meet_at = create_datetime(2015, 12, 0o3, 9, 55)
+    assert event.earliest_time == event.meet_at
 
-    def test_latest_time(self):
-        event = models.Event(name="TE LT", start_date=date(2016, 0o1, 0o1))
+    # Check order isn't important
+    event.start_date = date(2015, 12, 0o3)
+    assert event.earliest_time == create_datetime(2015, 12, 0o3, 9, 00)
 
-        # Just start date
-        self.assertEqual(event.latest_time, event.start_date)
 
-        # Just end date
-        event.end_date = date(2016, 1, 2)
-        self.assertEqual(event.latest_time, event.end_date)
+def test_latest_time():
+    event = models.Event(name="TE LT", start_date=date(2016, 0o1, 0o1))
 
-        # With end time
-        event.end_time = time(23, 00)
-        self.assertEqual(event.latest_time, self.create_datetime(2016, 1, 2, 23, 00))
+    # Just start date
+    assert event.latest_time == event.start_date
 
-    def test_in_bounds(self):
-        manager = models.Event.objects
-        events = [
-            manager.create(name="TE IB0", start_date='2016-01-02'),  # yes no
-            manager.create(name="TE IB1", start_date='2015-12-31', end_date='2016-01-04'),
+    # Just end date
+    event.end_date = date(2016, 1, 2)
+    assert event.latest_time == event.end_date
 
-            # basic checks
-            manager.create(name='TE IB2', start_date='2016-01-02', end_date='2016-01-04'),
-            manager.create(name='TE IB3', start_date='2015-12-31', end_date='2016-01-03'),
-            manager.create(name='TE IB4', start_date='2016-01-04',
-                           access_at=self.create_datetime(2016, 0o1, 0o3, 00, 00)),
-            manager.create(name='TE IB5', start_date='2016-01-04',
-                           meet_at=self.create_datetime(2016, 0o1, 0o2, 00, 00)),
+    # With end time
+    event.end_time = time(23, 00)
+    assert event.latest_time == create_datetime(2016, 1, 2, 23, 00)
 
-            # negative check
-            manager.create(name='TE IB6', start_date='2015-12-31', end_date='2016-01-01'),
-        ]
 
-        in_bounds = manager.events_in_bounds(self.create_datetime(2016, 1, 2, 0, 0),
-                                             self.create_datetime(2016, 1, 3, 0, 0))
-        self.assertIn(events[0], in_bounds)
-        self.assertIn(events[1], in_bounds)
-        self.assertIn(events[2], in_bounds)
-        self.assertIn(events[3], in_bounds)
-        self.assertIn(events[4], in_bounds)
-        self.assertIn(events[5], in_bounds)
+def test_in_bounds():
+    manager = models.Event.objects
+    events = [
+        manager.create(name="TE IB0", start_date='2016-01-02'),  # yes no
+        manager.create(name="TE IB1", start_date='2015-12-31', end_date='2016-01-04'),
 
-        self.assertNotIn(events[6], in_bounds)
+        # basic checks
+        manager.create(name='TE IB2', start_date='2016-01-02', end_date='2016-01-04'),
+        manager.create(name='TE IB3', start_date='2015-12-31', end_date='2016-01-03'),
+        manager.create(name='TE IB4', start_date='2016-01-04',
+                       access_at=create_datetime(2016, 0o1, 0o3, 00, 00)),
+        manager.create(name='TE IB5', start_date='2016-01-04',
+                       meet_at=create_datetime(2016, 0o1, 0o2, 00, 00)),
 
-    def create_datetime(self, year, month, day, hour, min):
-        tz = pytz.timezone(settings.TIME_ZONE)
-        return tz.localize(datetime(year, month, day, hour, min))
+        # negative check
+        manager.create(name='TE IB6', start_date='2015-12-31', end_date='2016-01-01'),
+    ]
+
+    in_bounds = manager.events_in_bounds(create_datetime(2016, 1, 2, 0, 0),
+                                         create_datetime(2016, 1, 3, 0, 0))
+    assert events[0] in in_bounds
+    assert events[1], in_bounds
+    assert events[2], in_bounds
+    assert events[3], in_bounds
+    assert events[4], in_bounds
+    assert events[5], in_bounds
+
+    assert events[6] not in in_bounds
+
+
+def create_datetime(year, month, day, hour, minute):
+    tz = pytz.timezone(settings.TIME_ZONE)
+    return tz.localize(datetime(year, month, day, hour, minute))
 
 
 class EventItemTestCase(TestCase):
@@ -331,7 +279,6 @@ class EventItemTestCase(TestCase):
 
 class EventPricingTestCase(TestCase):
     def setUp(self):
-        models.VatRate.objects.create(rate=0.20, comment="TP V1", start_at='2013-01-01')
         models.VatRate.objects.create(rate=0.10, comment="TP V2", start_at=date.today() - timedelta(days=1))
         self.e1 = models.Event.objects.create(name="TP E1", start_date=date.today() - timedelta(days=2))
         self.e2 = models.Event.objects.create(name="TP E2", start_date=date.today())
@@ -364,7 +311,6 @@ class EventPricingTestCase(TestCase):
 
 class EventAuthorisationTestCase(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',

RIGS/tests/test_unit.py

@@ -1,23 +1,25 @@
 from datetime import date
 
 from django.core.exceptions import ObjectDoesNotExist
-from django.core.management import call_command
 from django.test import TestCase
 from django.test.utils import override_settings
 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
+from PyRIGS.tests.base import assert_times_almost_equal, assert_oembed, login
 from RIGS import models
 
+import pytest
+
+pytestmark = pytest.mark.django_db
+
 
 class TestAdminMergeObjects(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.persons = {
             1: models.Person.objects.create(name="Person 1"),
             2: models.Person.objects.create(name="Person 2"),
@@ -168,9 +170,6 @@ class TestInvoiceDelete(TestCase):
     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 = {
             1: models.Event.objects.create(name="TE E1", start_date=date.today()),
             2: models.Event.objects.create(name="TE E2", start_date=date.today())
@@ -201,7 +200,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 +215,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))
@@ -227,9 +226,6 @@ class TestPrintPaperwork(TestCase):
     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 = {
             1: models.Event.objects.create(name="TE E1", start_date=date.today(),
                                            description="This is an event description\nthat for a very specific reason spans two lines."),
@@ -257,102 +253,50 @@ 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)
+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)
 
-        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())
-        }
+    # 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)
 
-        cls.invoices = {
-            1: models.Invoice.objects.create(event=cls.events[1]),
-            2: models.Invoice.objects.create(event=cls.events[2])
-        }
+    # Now login
+    login(client, django_user_model)
 
-        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)
+    # And check that it no longer redirects
+    response = client.get(request_url, follow=True)
+    assert len(response.redirect_chain) == 0
 
 
-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_cookie_warning(client):
+    login_url = reverse('login_embed')
+    response = client.post(login_url, follow=True)
+    assertContains(response, "Cookies do not seem to be enabled")
 
-        # Check there are lots of events
-        self.assertTrue(models.Event.objects.all().count() > 100)
 
-    def test_production_exception(self):
-        from django.core.management.base import CommandError
+def test_xframe_headers(admin_client, basic_event):
+    event_url = reverse('event_embed', kwargs={'pk': basic_event.pk})
+    login_url = reverse('login_embed')
 
-        self.assertRaisesRegex(CommandError, ".*production", call_command, 'generateSampleRIGSData')
+    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, basic_event):
+    event_url = reverse('event_detail', kwargs={'pk': basic_event.pk})
+    event_embed_url = reverse('event_embed', kwargs={'pk': basic_event.pk})
+    oembed_url = reverse('event_oembed', kwargs={'pk': basic_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)
 
 
 def search(client, url, found, notfound, arguments):
@@ -391,45 +335,11 @@ def test_search(admin_client):
            ['name', 'id', 'address'])
 
 
-def setup_for_hs():
-    models.VatRate.objects.create(start_at='2014-03-05', rate=0.20, comment='test1')
-    venue = models.Venue.objects.create(name="Venue 1")
-    return venue, {
-        1: models.Event.objects.create(name="TE E1", start_date=date.today(),
-                                       description="This is an event description\nthat for a very specific reason spans two lines.",
-                                       venue=venue),
-        2: models.Event.objects.create(name="TE E2", start_date=date.today()),
-    }
-
-
-def create_ra(usr):
-    venue, events = setup_for_hs()
-    return models.RiskAssessment.objects.create(event=events[1], nonstandard_equipment=False, nonstandard_use=False,
-                                                contractors=False, other_companies=False, crew_fatigue=False,
-                                                big_power=False, power_mic=usr, generators=False,
-                                                other_companies_power=False, nonstandard_equipment_power=False,
-                                                multiple_electrical_environments=False, noise_monitoring=False,
-                                                known_venue=True, safe_loading=True, safe_storage=True,
-                                                area_outside_of_control=True, barrier_required=True,
-                                                nonstandard_emergency_procedure=True, special_structures=False,
-                                                suspended_structures=False, outside=False)
-
-
-def create_checklist(usr):
-    venue, events = setup_for_hs()
-    return models.EventChecklist.objects.create(event=events[1], power_mic=usr, safe_parking=False,
-                                                safe_packing=False, exits=False, trip_hazard=False, warning_signs=False,
-                                                ear_plugs=False, hs_location="Locked away safely",
-                                                extinguishers_location="Somewhere, I forgot", earthing=False, pat=False,
-                                                date=timezone.now(), venue=venue)
-
-
-def test_list(admin_client):
-    venue, events = setup_for_hs()
+def test_hs_list(admin_client, basic_event):
     request_url = reverse('hs_list')
     response = admin_client.get(request_url, follow=True)
-    assertContains(response, events[1].name)
-    assertContains(response, events[2].name)
+    assertContains(response, basic_event.name)
+    # assertContains(response, events[2].name)
     assertContains(response, 'Create')
 
 
@@ -439,19 +349,18 @@ def review(client, profile, obj, request_url):
     obj.refresh_from_db()
     assertContains(response, 'Reviewed by')
     assertContains(response, profile.name)
-    assert_times_equal(time, obj.reviewed_at)
+    assert_times_almost_equal(time, obj.reviewed_at)
 
 
-def test_ra_review(admin_client, admin_user):
-    review(admin_client, admin_user, create_ra(admin_user), 'ra_review')
+def test_ra_review(admin_client, admin_user, ra):
+    review(admin_client, admin_user, ra, 'ra_review')
 
 
-def test_checklist_review(admin_client, admin_user):
-    review(admin_client, admin_user, create_checklist(admin_user), 'ec_review')
+def test_checklist_review(admin_client, admin_user, checklist):
+    review(admin_client, admin_user, checklist, 'ec_review')
 
 
-def test_ra_redirect(admin_client, admin_user):
-    ra = create_ra(admin_user)
+def test_ra_redirect(admin_client, admin_user, ra):
     request_url = reverse('event_ra', kwargs={'pk': ra.event.pk})
     expected_url = reverse('ra_edit', kwargs={'pk': ra.pk})