Refactor buildsystem to NPM/Gulp, port to BS4 & rewrite RIGS tests accordingly... (#412)

* Start to seperate versioning into its own app

* Start reworking invoice things

* Reduced overall font size a touch

* Improvements to generic lists

* Tweak some colours to be a bit less OTT

I need to work out if I can seperate background and primary colours like BS3 did

* Improvements to event table mobile

* First pass at mobile-ising the generic list

* Item table fixes

* Fixed fullcalendar print css not included

* Asset list table improvements

* Tweak asset list to be more in line with other lists

* Versioning template improvements

//TODO Rather than have seperate asset templates, convert 'id' into a template variable

* Tweak versioning templates to allow ID overrides

Asset specific templates begone. Still need to bring back the ID formatting for the Rigboard.

* Asset form fixes

* Use the right autocompleter.js...

* Breakout (most) user stuff to separate module

The model remains in RIGS for now, as it's pretty painful to move...

* Python Format/import opt

* Test Refactor Part 1 - Shuffle things around

* Fix migrations

TODO - need to ensure moved models are *moved* rather than deleted and recreated!

* Start on new tests

* Initial work on event create test reimpl

* Init other tests, more rigs test faffery

* Desaturate theme colors even more

Much closer to BS3

* Fix event item adding

Bit too heavy handed with the deduplication there Arona

* Initial refactor of event item testing

* Upgrade bootstrap-select

* Updated bootstrap-select for BS4

* Initial port of duplicate testing

Needs the latter half rewriting once we have an EventDetail POM

* Refactor date validation test

So close to killing test_functional.EventTest!

* Deduplication of testing code

* pep8

* Fix some tests

And some things that were actually borked

* FIX: Prevent setting access time after start time 

Cherry pick of d274ea4606. Will close #405.

* Refactor calendar tests

* FIX: Don't show asset buttons/history for basic users

* Really ought to get a pre-commit hook for pep8...

* Fully replace test_functional

* Dedupe generic search logic

* Fix the remaining tests

* Ensure submit button is scrolled to in tests

* Fix asset creation test + actually verify its results

* Make CI use latest (stable) chromedriver rather than some ancient one

Since Travis uses the latest stable chrome, should always match. Bash oneliner \o/

* Of course | is part of YAML syntax, of course...

Maybe this works.

* Update python version

Trying to get CI to match my local environment as much as possible...

* Minor test futzing

* Well that wasn't clever of me

* That was even less clever of me

* Revert to old submit wait behaviour

* What about if I did this

* Try disabling chrome cache

* Added screenshot recording of test failures

* Fixed RIGS tests not being run

* Fixed Pep8 - I promise I'll make a pre-commit hook sometime!

* Very initial work at togglable darktheme.

Dammit @alexdaniel654 just when I had my scope creep kinda under control. It'll be v. nice to have though...!

* More dark theme wangling

* Fix some asset template things

* FIX: CI Locale Issues

* Fix sample command

* Initial work at integrating the risk assessment

#136. No clever database structure as yet...

* FIX: Don't set every boolean input to radios

* Different approach to RA linking

* Move text definitions to somewhere more authoratitive

* FIX: Undo breakage causing autopep8

o.O

* Expand detail template

* Use correct view for RA history

* Initial work at coercing activity feed into showing RAs

Also shows Asset/Supplier on the homepage feed.

* Refactor activity feed template logic

Yay for removing arbitrary if/else chains!

* Initial work on caching activity feed

Server side that is. Ref #162.

* Start RA list template

* Refactor RA creation stuff, again

* Add H&S Details to Event Detail View

* Display venue notes in event detail

Notes are no use if nobody reads them. Not sure on this one.

* Add ability to filter event archive by status

Closes #168.

* Fix lingering naive time

* Use locmem cache in sqlite environments

Otherwise the tests just lock up totally. Should close #162

* Update dependencies

Mirrors/supersedes 0e67da82e2

* Add global ctrl/meta-enter shortcut for form submission

Wants rewriting for better efficiency, but hey, it works!

* Update dependencies

* Fix for a situation that should be impossible

* Fix navbar alignment

* FEAT: Improve 'omni'search

- Partialised template
- Added to assets header
- Added ability to search assets/suppliers
- Improved selection logic
- Have it display current query

* Move closemodal into PyRIGS

* Fix tests for search improvements

* Dark mode colour improvements

* Fix table colors for dry hires

* further darktheme fixes

* Remove the dark header from light theme

* Fix reload loops when CSS/JS is changed

* Move dark theme SCSS to separate file, fix inactive pagination styling

* Genercise detail pages

* Testing something re notes

I wonder if I can make that global, rather than per-template...

* Dark theme palette shenanigans

I just can't decide

* Match darktheme palette to forum darktheme palette

Why reinvent the wheel.

* Make supplier detail use the generic template

* Disable mobile event table PoC for now

* Remove the defaults from the RA fields + make them required

* More RA fixes

* Fixes to revisions for RAs

* Add bootstrap 4 test page

* Bunch of dark mode fixes from test page

* Do not use Django 'required' for radio selects

As this requires them to be True, whereas we just need to require that an option be entered.

* Properly fixed popover darktheme

* Fixed search for events

* Style fixes to asset list

* Start RA 'mark review' feature

* Add reviewing to revision history, fix RA editing not working

Also actually commit all the files, that helps

* Fix Power MIC being lost on RA edit

Why it is subtly different to the Event Update behaviour? Who knows

* Invalidate RA review if it is edited after review

* Start work on event checklist

* Add a button for creating and instantly voiding invoices

Handy dandy for when you have loads of cancelled events, like say, a pandemic

* Mooooore status chips, mooore

* Initial shenanigans on storing my overly fancy EC form

* Proof of concept for JSON parsing/storage

\o/

* Add new line functionality for vehicles/drivers

Might it have been easier to create 'dummy' models like with EventItems? Probably...

* Alter rig_count to not include un-checked-in dry hires

* Insert a divider between still-out dry hires and actually upcoming events on rigboard

* Initial work on new checklist handling. No more JSON!

* Versioning module now does magic

Automatic creation of views/urls for anything registered with reversion, with a small amount of hackage to preserve legacy stuff. (and the DAMNED asset IDs!) I would never get distracted...

* Cleanup

* Event checklist crew works

Mostly - its not happy with timezones

* Medium event power stuff done, barring worst case stuff

* Misc fixes

* Validation of power reqs

* Worst case points on checklist

* Templating improvements to RA/EC stuff

* Do event table color logic at python level

* Audit template fixes

* Restrict versioning to one level of depth for speed

Also fixed the template for nested changes

* Event properties internal/authorised always return a explicit boolean rather than sometimes None

* Use template filter for notes

* Fix list templates

TODO: Sensible place to define the 'expected answer' stuff.

* Fix cable table template

* Rethink rigboard color logic again

Also revert some broken stuff

* Test fixes

* Modify auth test so it doesn't try and test for external authorisations

Cause that's not a thing

* Why does this work

Bloody overzealous autoformatter...

* Formatting...

* Initial work on RA tests

* Pages/start of tests for EventChecklists

* Much better coverage of H&S things

* Cleanup & Squash migrations

* Fix wrong variable name in settings.py

* Fix broken invoice list template

* Add revision history to invoices/payments.

Also patches previously introduced reversion permissions hole.

Supersedes and closes #337.

* Various misc fixes

* Fix for my fix

* Curse youuuuu pep8

* Invoice template improvements

* Minor fixes

* More tweaks

* More fixes

* Major improvements/fixes to authorisation templates

* Add ability to mark event checklists as Large Event

This just disables the checks to allow the rest of it to be filled out for large events, though I expect paper forms may still be used...

* Remove database ID from generic list

* Put power threshold values in a collapse

* Use template filter for consistent removal of 'None links'

Plus cleaner template markup! More HTML-in-Python tho, which always feels a bit CSS-in-JS

* Tweak asset list markup

* Begin to change add buttons success -> primary

Also change search primary -> info to avoid clash

* Begin to improve event checklist on mobile

* Asset detail template improvements

* Fix #326 (again)

* Fix errors being squashed

* Fix rigboard validation tests

* Initial work on BS4 button templatetag

Newfeatureitis strikes again

* Allow multiple event checklists per event

TODO: Status chip now needs rethinking

* Minor event detail fixes

* Fix tests

* Rework button tag

* Mobile fixes for search

* Fix event checklist on mobile

* Redo light theme palette

* Switch rigboard new button to primary

* Kill off excess whitespace on rigboard

* Rigboard Timing display tweaks

* Fix tests

* Properly handle eventauthorisations in new versioning

It's not great, not terrible...

* Prevent creating duplicate revisions on event

Potential fix for #322 - I couldn't reproduce even before this change...

* Template improvements

* Minor test fixes

* Revert "Prevent creating duplicate revisions on event"

Apparently it was too strong at preventing dupes...

This reverts commit cce0ad0f9f.

# Conflicts:
#	RIGS/models.py

* Better approach to generic list templates + other deduplication

* Also apply better approach to generic detail pages

* One of these days I'll remember to test BEFORE pushing...

* And now the same for generic forms

* Display tick/cross rather than true/false in boolean version diffs

* Upgrade dependencies

* Fixes fixes fixes

* Fix dependency hell

Probably

* Correct handling of spaces in paperwork filenames

Also normalises display of Invoice IDs. Partial fix for #391.

* Buggerit millennium hand and shrimp

Knew I was gonna forget to fix the tests

* FIX: Set duplicated event status to provisional

Closes #398.

Flip flop. Flip flop.

* Update polyfill for datetime-local

Bloody Firefox. We love to hate you. Proper CSS of the fill to come, SoonTM.

Closes #391

* Curses!

* Minor typo fixes

* Initial pass at soop-consult confirmation screen for RAs

* Fix migration

* Make venue/date editable on EC

For multi venue, multi day events

Defaults to date and venue set on the event. Also made power MIC default to that set in RA

* Clearer logic for RA inverted fields

* (probably) fix tests

* Give keyholders supplier edit perm

* Generic list only displays edit button if user has perm

* Same perm check for generic details

* H&S Details takes up free space on non-internal events

* Remove flash of content when loading new rig page

* First pass at clearer display of asset list filters

* Fix tests / default to headless tests

(fingers crossed)

* Fix autocompleter.js to properly disable edit links again

* Move status color logic back to template

Cause that somehow makes it work better??

* Display note icon on event detail page

* Fix caching

* Put rounded corners back where they belong

* Remove lingering use of 'page-header'

BS removed that style

* More search and replace for BS changes

Thought I'd got them all. Clearly not!

* Remove enforced linebreak on status chips

* Fix horizontal-ness on some forms

* Remove animation on prefers-reduced-motion/low referesh rate devices

Also normalises handling of asset list cable table & improves its use of space on large devices

* Make version changes badges more readable

* First pass at making the calendar less crap

* Fix event table success logic

Yay for copy paste fails >.>

* Use borders rather than block colors for coloured tables under darktheme

* First pass at porting calendar from FC V3 to V5

Two major versions and all they did was rename a bunch of names...TWICE.

* Rework version name method to avoid blank names on eventchecklist vehicles/crew

* Fix cable test

* Made radio button focus much more obvious on dark theme

* Implement Jerb's wording changes

* Fix one test, break another...

* Fix recent change stream list mutation issue

* FIX: Do not naively cache event table

Not that easy, it turns out. Duh.

* FEAT: Implement #413 show associated assets on cable type detail pg

Closes #413

* Allow H&S for non-events

* Update emergency contact number

* Improvements to profile detail page

* Implement some of Jonny's suggested changes

TODO:
- Define event size at RA time, pass through to EC
- Have later power questions be context dependent

* Test fixes

* Add space for power/rigging plans to be linked to RAs

* Start move of event size logic to RA from Ec

* Javascript required shenanigans for RA power

* More moving of event size logic

* Fixing tests for new logic etc

* Why does this work

Indeed, it may not

* FIX: Stupid typo in versioning.py

* Further minor fixes to versioning

* Add icons to H&S menu items

* Should fix calendar breaking in production

* Small alignment fix in asset list

* Squash migrations

Co-authored-by: Matthew Smith <psyms13@nottingham.ac.uk>

RIGS/tests/pages.py

@@ -0,0 +1,306 @@
+from pypom import Page, Region
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions
+from selenium.webdriver import Chrome
+from django.urls import reverse
+from PyRIGS.tests import regions
+from RIGS.tests import regions as rigs_regions
+from PyRIGS.tests.pages import BasePage, FormPage
+from selenium.common.exceptions import NoSuchElementException
+from selenium.webdriver.support import expected_conditions as EC
+
+
+class Index(BasePage):
+    URL_TEMPLATE = reverse('index')
+
+
+class Rigboard(BasePage):
+    URL_TEMPLATE = reverse('rigboard')
+
+    _add_item_selector = (By.XPATH, "//a[contains(@class,'btn-primary') and contains(., 'New')]")
+    _event_row_locator = (By.ID, 'event_row')
+
+    def add(self):
+        self.find_element(*self._add_item_selector).click()
+
+    class EventListRow(Region):
+        _event_number_locator = (By.ID, "event_number")
+        _event_dates_locator = (By.ID, "event_dates")
+        _event_details_locator = (By.ID, "event_details")
+        _event_mic_locator = (By.ID, "event_mic")
+
+        @property
+        def id(self):
+            return self.find_element(*self._event_number_locator).text
+
+        @property
+        def dates(self):
+            return self.find_element(*self._event_dates_locator).text
+
+        @property
+        def details(self):
+            return self.find_element(*self._event_details_locator).text
+
+        @property
+        def mic(self):
+            return self.find_element(*self._event_mic_locator).text
+
+    @property
+    def events(self):
+        return [self.EventListRow(self, i) for i in self.find_elements(*self._event_row_locator)]
+
+
+class EventDetail(BasePage):
+    URL_TEMPLATE = 'event/{event_id}'
+
+    # TODO Refactor into regions to match template fragmentation
+    _event_name_selector = (By.XPATH, '//h1')
+    _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]')
+    _phone_selector = (By.XPATH, '//dt[text()="Phone Number"]/following-sibling::dd[1]')
+    _event_table_selector = (By.ID, 'item-table')
+
+    @property
+    def event_name(self):
+        return self.find_element(*self._event_name_selector).text
+
+    @property
+    def name(self):
+        return self.find_element(*self._person_panel_selector).find_element(*self._name_selector).text
+
+    @property
+    def email(self):
+        return self.find_element(*self._person_panel_selector).find_element(*self._email_selector).text
+
+    @property
+    def phone(self):
+        return self.find_element(*self._person_panel_selector).find_element(*self._phone_selector).text
+
+    @property
+    def item_table(self):
+        return self.find_element(*self._event_table_selector)
+
+
+class CreateEvent(FormPage):
+    URL_TEMPLATE = reverse('event_create')
+
+    _is_rig_selector = (By.ID, 'is_rig-selector')
+    _submit_locator = (By.XPATH, "//button[@type='submit' and contains(., 'Save')]")
+    _person_selector_selector = (By.XPATH, '//*[@id="id_person"]/..')
+    _venue_selector_selector = (By.XPATH, '//*[@id="id_venue"]/..')
+    _mic_selector_selector = (By.XPATH, '//*[@id="form-hws"]/div[7]/div[1]/div/div')
+
+    _add_person_selector = (By.XPATH, '//a[@data-target="#id_person" and contains(@href, "add")]')
+    _add_item_selector = (By.XPATH, '//button[contains(@class, "item-add")]')
+
+    _event_table_selector = (By.ID, 'item-table')
+    _warning_selector = (By.XPATH, '/html/body/div[1]/div[1]')
+
+    form_items = {
+        'description': (regions.TextBox, (By.ID, 'id_description')),
+
+        'name': (regions.TextBox, (By.ID, 'id_name')),
+        'start_date': (regions.DatePicker, (By.ID, 'id_start_date')),
+        'start_time': (regions.TimePicker, (By.ID, 'id_start_time')),
+        'end_date': (regions.DatePicker, (By.ID, 'id_end_date')),
+        'end_time': (regions.TimePicker, (By.ID, 'id_end_time')),
+        'access_at': (regions.DateTimePicker, (By.ID, 'id_access_at')),
+        'meet_at': (regions.DateTimePicker, (By.ID, 'id_meet_at')),
+        'dry_hire': (regions.CheckBox, (By.ID, 'id_dry_hire')),
+        'status': (regions.SingleSelectPicker, (By.ID, 'id_status')),
+        'collected_by': (regions.TextBox, (By.ID, 'id_collector')),
+        'po': (regions.TextBox, (By.ID, 'id_purchase_order')),
+
+        'notes': (regions.TextBox, (By.ID, 'id_notes'))
+    }
+
+    def select_event_type(self, type_name):
+        self.find_element(By.XPATH, '//button[.="{}"]'.format(type_name)).click()
+
+    def item_row(self, ID):
+        return rigs_regions.ItemRow(self, self.find_element(By.ID, "item-" + ID))
+
+    @property
+    def item_table(self):
+        return self.find_element(*self._event_table_selector)
+
+    @property
+    def warning(self):
+        return self.find_element(*self._warning_selector).text
+
+    @property
+    def is_expanded(self):
+        return self.find_element(*self._submit_locator).is_displayed()
+
+    @property
+    def person_selector(self):
+        return regions.BootstrapSelectElement(self, self.find_element(*self._person_selector_selector))
+
+    @property
+    def venue_selector(self):
+        return regions.BootstrapSelectElement(self, self.find_element(*self._venue_selector_selector))
+
+    @property
+    def mic_selector(self):
+        return regions.BootstrapSelectElement(self, self.find_element(*self._mic_selector_selector))
+
+    def add_person(self):
+        self.find_element(*self._add_person_selector).click()
+        return regions.Modal(self, self.driver.find_element_by_id('modal'))
+
+    def add_event_item(self):
+        self.find_element(*self._add_item_selector).click()
+        element = self.driver.find_element_by_id('itemModal')
+        self.wait.until(EC.visibility_of(element))
+        return rigs_regions.ItemModal(self, element)
+
+    @property
+    def success(self):
+        return '/create' not in self.driver.current_url
+
+
+class DuplicateEvent(CreateEvent):
+    URL_TEMPLATE = 'event/{event_id}/duplicate'
+
+    @property
+    def success(self):
+        return '/duplicate' not in self.driver.current_url
+
+
+class EditEvent(CreateEvent):
+    URL_TEMPLATE = 'event/{event_id}/edit'
+
+    @property
+    def success(self):
+        return '/edit' not in self.driver.current_url
+
+
+class CreateRiskAssessment(FormPage):
+    URL_TEMPLATE = 'event/{event_id}/ra/'
+
+    _submit_locator = (By.XPATH, "//button[@type='submit' and contains(., 'Save')]")
+    _power_mic_selector = (By.CSS_SELECTOR, ".bootstrap-select")
+
+    form_items = {
+        'nonstandard_equipment': (regions.RadioSelect, (By.ID, 'id_nonstandard_equipment')),
+        'nonstandard_use': (regions.RadioSelect, (By.ID, 'id_nonstandard_use')),
+        'contractors': (regions.RadioSelect, (By.ID, 'id_contractors')),
+        'other_companies': (regions.RadioSelect, (By.ID, 'id_other_companies')),
+        'crew_fatigue': (regions.RadioSelect, (By.ID, 'id_crew_fatigue')),
+        'general_notes': (regions.TextBox, (By.ID, 'id_general_notes')),
+        'big_power': (regions.RadioSelect, (By.ID, 'id_big_power')),
+        'outside': (regions.RadioSelect, (By.ID, 'id_outside')),
+        'generators': (regions.RadioSelect, (By.ID, 'id_generators')),
+        'other_companies_power': (regions.RadioSelect, (By.ID, 'id_other_companies_power')),
+        'nonstandard_equipment_power': (regions.RadioSelect, (By.ID, 'id_nonstandard_equipment_power')),
+        'multiple_electrical_environments': (regions.RadioSelect, (By.ID, 'id_multiple_electrical_environments')),
+        'power_notes': (regions.TextBox, (By.ID, 'id_power_notes')),
+        'noise_monitoring': (regions.RadioSelect, (By.ID, 'id_noise_monitoring')),
+        'sound_notes': (regions.TextBox, (By.ID, 'id_sound_notes')),
+        'known_venue': (regions.RadioSelect, (By.ID, 'id_known_venue')),
+        'safe_loading': (regions.RadioSelect, (By.ID, 'id_safe_loading')),
+        'safe_storage': (regions.RadioSelect, (By.ID, 'id_safe_storage')),
+        'area_outside_of_control': (regions.RadioSelect, (By.ID, 'id_area_outside_of_control')),
+        'barrier_required': (regions.RadioSelect, (By.ID, 'id_barrier_required')),
+        'nonstandard_emergency_procedure': (regions.RadioSelect, (By.ID, 'id_nonstandard_emergency_procedure')),
+        'special_structures': (regions.RadioSelect, (By.ID, 'id_special_structures')),
+        'persons_responsible_structures': (regions.TextBox, (By.ID, 'id_persons_responsible_structures')),
+        'suspended_structures': (regions.RadioSelect, (By.ID, 'id_suspended_structures')),
+        'supervisor_consulted': (regions.CheckBox, (By.ID, 'id_supervisor_consulted')),
+        'rigging_plan': (regions.TextBox, (By.ID, 'id_rigging_plan')),
+    }
+
+    @property
+    def power_mic(self):
+        return regions.BootstrapSelectElement(self, self.find_element(*self._power_mic_selector))
+
+    @property
+    def success(self):
+        return '/event/ra' in self.driver.current_url
+
+
+class EditRiskAssessment(CreateRiskAssessment):
+    URL_TEMPLATE = 'event/ra/{pk}/edit'
+
+    @property
+    def success(self):
+        return '/edit' not in self.driver.current_url
+
+
+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')]")
+    _add_vehicle_locator = (By.XPATH, "//button[contains(., 'Vehicle')]")
+    _add_crew_locator = (By.XPATH, "//button[contains(., 'Crew')]")
+
+    form_items = {
+        'safe_parking': (regions.CheckBox, (By.ID, 'id_safe_parking')),
+        'safe_packing': (regions.CheckBox, (By.ID, 'id_safe_packing')),
+        'exits': (regions.CheckBox, (By.ID, 'id_exits')),
+        'trip_hazard': (regions.CheckBox, (By.ID, 'id_trip_hazard')),
+        'warning_signs': (regions.CheckBox, (By.ID, 'id_warning_signs')),
+        'ear_plugs': (regions.CheckBox, (By.ID, 'id_ear_plugs')),
+        'hs_location': (regions.TextBox, (By.ID, 'id_hs_location')),
+        'extinguishers_location': (regions.TextBox, (By.ID, 'id_extinguishers_location')),
+        'rcds': (regions.CheckBox, (By.ID, 'id_rcds')),
+        'supply_test': (regions.CheckBox, (By.ID, 'id_supply_test')),
+        'earthing': (regions.CheckBox, (By.ID, 'id_earthing')),
+        'pat': (regions.CheckBox, (By.ID, 'id_pat')),
+        'source_rcd': (regions.CheckBox, (By.ID, 'id_source_rcd')),
+        'labelling': (regions.CheckBox, (By.ID, 'id_labelling')),
+        'fd_voltage_l1': (regions.TextBox, (By.ID, 'id_fd_voltage_l1')),
+        'fd_voltage_l2': (regions.TextBox, (By.ID, 'id_fd_voltage_l2')),
+        'fd_voltage_l3': (regions.TextBox, (By.ID, 'id_fd_voltage_l3')),
+        'fd_phase_rotation': (regions.CheckBox, (By.ID, 'id_fd_phase_rotation')),
+        'fd_earth_fault': (regions.TextBox, (By.ID, 'id_fd_earth_fault')),
+        'fd_pssc': (regions.TextBox, (By.ID, 'id_fd_pssc')),
+        'w1_description': (regions.TextBox, (By.ID, 'id_w1_description')),
+        'w1_polarity': (regions.CheckBox, (By.ID, 'id_w1_polarity')),
+        'w1_voltage': (regions.TextBox, (By.ID, 'id_w1_voltage')),
+        'w1_earth_fault': (regions.TextBox, (By.ID, 'id_w1_earth_fault')),
+    }
+
+    def add_vehicle(self):
+        self.find_element(*self._add_vehicle_locator).click()
+
+    def add_crew(self):
+        self.find_element(*self._add_crew_locator).click()
+
+    @property
+    def power_mic(self):
+        return regions.BootstrapSelectElement(self, self.find_element(*self._power_mic_selector))
+
+    @property
+    def success(self):
+        return '{event_id}' 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')
+    _add_item_selector = (By.CSS_SELECTOR, '.btn-success')
+
+
+class UserPage(BasePage):
+    URL_TEMPLATE = 'user/'
+
+    _api_key_selector = (By.ID, 'api-key')
+    _cal_url_selector = (By.ID, 'cal-url')
+    _generation_button_selector = (By.LINK_TEXT, 'Generate API Key')
+
+    @property
+    def api_key(self):
+        return self.find_element(*self._api_key_selector).text
+
+    @property
+    def cal_url(self):
+        return self.find_element(*self._cal_url_selector).text
+
+    def toggle_filter(self, type_name):
+        self.find_element(By.XPATH, "//input[@value='" + type_name + "']").click()
+
+    def generate_key(self):
+        self.find_element(*self._generation_button_selector).click()

RIGS/tests/regions.py

@@ -0,0 +1,52 @@
+from pypom import Region
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions
+from selenium.webdriver.remote.webelement import WebElement
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support.select import Select
+import datetime
+from PyRIGS.tests.regions import TextBox, Modal
+
+
+class Header(Region):
+    def find_link(self, link_text):
+        return self.driver.find_element_by_partial_link_text(link_text)
+
+
+class ItemRow(Region):
+    _name_locator = (By.XPATH, '//span[@class="name"]')
+    _description_locator = (By.XPATH, '//div[@class="item-description"]')
+    _price_locator = (By.XPATH, '//span[@class="cost"]')
+    _quantity_locator = (By.XPATH, '//td[@class="quantity"]')
+    _subtotal_locator = (By.XPATH, '//span[@class="sub-total"]')
+
+    @property
+    def name(self):
+        return self.find_element(*self._name_locator).text
+
+    @property
+    def description(self):
+        return self.find_element(*self._description_locator).text
+
+    @property
+    def price(self):
+        return self.find_element(*self._price_locator).text
+
+    @property
+    def quantity(self):
+        return self.find_element(*self._quantity_locator).text
+
+    @property
+    def subtotal(self):
+        return self.find_element(*self._subtotal_locator).text
+
+
+class ItemModal(Modal):
+    _header_selector = (By.TAG_NAME, 'h4')
+
+    form_items = {
+        'name': (TextBox, (By.ID, 'item_name')),
+        'description': (TextBox, (By.ID, 'item_description')),
+        'quantity': (TextBox, (By.ID, 'item_quantity')),
+        'price': (TextBox, (By.ID, 'item_cost'))
+    }

RIGS/tests/test_functional.py

@@ -0,0 +1,168 @@
+import datetime
+from datetime import date, time, timedelta
+from urllib.parse import urlparse
+
+from django.conf import settings
+from django.core import mail, signing
+from django.core.management import call_command
+from django.db import transaction
+from django.http import HttpResponseBadRequest
+from django.test import TestCase
+from django.test.client import Client
+from django.test.utils import override_settings
+from django.urls import reverse
+from django.utils import timezone
+from reversion import revisions as reversion
+from RIGS import models, urls
+from RIGS.tests import regions
+
+from . import pages
+
+
+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.")
+
+
+class ClientEventAuthorisationTest(BaseCase):
+    auth_data = {
+        'name': 'Test ABC',
+        'po': '1234ABCZXY',
+        'account_code': 'ABC TEST 12345',
+        'uni_id': 1234567890,
+        'tos': True
+    }
+
+    def setUp(self):
+        super().setUp()
+        self.hmac = signing.dumps({'pk': self.event.pk, 'email': 'authemail@function.test',
+                                   'sent_by': self.profile.pk})
+        self.url = reverse('event_authorise', kwargs={'pk': self.event.pk, 'hmac': self.hmac})
+
+    def test_requires_valid_hmac(self):
+        bad_hmac = self.hmac[:-1]
+        url = reverse('event_authorise', kwargs={'pk': self.event.pk, 'hmac': bad_hmac})
+        response = self.client.get(url)
+        self.assertIsInstance(response, HttpResponseBadRequest)
+        # TODO: Add some form of sensbile user facing error
+        # self.assertIn(response.content, "new URL")  # check there is some level of sane instruction
+
+        response = self.client.get(self.url)
+        self.assertContains(response, self.event.organisation.name)
+
+    def test_validation(self):
+        response = self.client.get(self.url)
+        self.assertContains(response, "Terms of Hire")
+        self.assertContains(response, "Account code")
+        self.assertContains(response, "University ID")
+
+        response = self.client.post(self.url)
+        self.assertContains(response, "This field is required.", 5)
+
+        data = self.auth_data
+        data['amount'] = self.event.total + 1
+
+        response = self.client.post(self.url, data)
+        self.assertContains(response, "The amount authorised must equal the total for the event")
+        self.assertNotContains(response, "This field is required.")
+
+        data['amount'] = self.event.total
+        response = self.client.post(self.url, data)
+        self.assertContains(response, "Your event has been authorised")
+
+        self.event.refresh_from_db()
+        self.assertTrue(self.event.authorised)
+        self.assertEqual(self.event.authorisation.email, "authemail@function.test")
+
+    def test_duplicate_warning(self):
+        auth = models.EventAuthorisation.objects.create(event=self.event, name='Test ABC', email='dupe@functional.test',
+                                                        amount=self.event.total, sent_by=self.profile)
+        response = self.client.get(self.url)
+        self.assertContains(response, 'This event has already been authorised.')
+
+        auth.amount += 1
+        auth.save()
+
+        response = self.client.get(self.url)
+        self.assertContains(response, 'amount has changed')
+
+    def test_email_sent(self):
+        mail.outbox = []
+
+        data = self.auth_data
+        data['amount'] = self.event.total
+
+        response = self.client.post(self.url, data)
+        self.assertContains(response, "Your event has been authorised.")
+        self.assertEqual(len(mail.outbox), 2)
+
+        self.assertEqual(mail.outbox[0].to, ['authemail@function.test'])
+        self.assertEqual(mail.outbox[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(self):
+        self.profile.email = 'teccie@someotherdomain.com'
+        self.profile.save()
+
+        response = self.client.post(self.url)
+
+        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.')
+
+        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)
+
+        # 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)

RIGS/tests/test_interaction.py

@@ -0,0 +1,903 @@
+import datetime
+from datetime import date, time, timedelta
+from urllib.parse import urlparse
+
+from django.conf import settings
+from django.core import mail, signing
+from django.core.management import call_command
+from django.db import transaction
+from django.http import HttpResponseBadRequest
+from django.test.client import Client
+from django.test.utils import override_settings
+from django.urls import reverse
+from django.utils import timezone
+from PyRIGS.tests import base
+from PyRIGS.tests import regions as base_regions
+from PyRIGS.tests.base import (AutoLoginTest, BaseTest, animation_is_finished,
+                               screenshot_failure_cls)
+from reversion import revisions as reversion
+from RIGS import models, urls
+from RIGS.tests import regions
+from selenium.common.exceptions import NoSuchElementException
+from selenium.webdriver.common.action_chains import ActionChains
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.common.action_chains import ActionChains
+
+from . import pages
+
+
+@screenshot_failure_cls
+class BaseRigboardTest(AutoLoginTest):
+    def setUp(self):
+        self.vatrate = models.VatRate.objects.create(start_at='2014-03-05', rate=0.20, comment='test1')
+        super().setUp()
+        self.client = models.Person.objects.create(name='Rigboard Test Person', email='rigboard@functional.test')
+        self.wait = WebDriverWait(self.driver, 10)
+
+    def select_event_type(self, event_type):
+        self.wait.until(animation_is_finished())
+        self.assertFalse(self.page.is_expanded)
+        self.page.select_event_type(event_type)
+        self.wait.until(animation_is_finished())
+        self.assertTrue(self.page.is_expanded)
+
+
+@screenshot_failure_cls
+class TestRigboard(BaseRigboardTest):
+    def setUp(self):
+        super().setUp()
+        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,
+                                                     auth_request_by=self.profile,
+                                                     auth_request_at=base.create_datetime(2015, 0o6, 0o4, 10, 00),
+                                                     auth_request_to="some@email.address")
+
+        item1 = models.EventItem(
+            event=self.testEvent,
+            name="Test Item 1",
+            cost="10.00",
+            quantity="1",
+            order=1
+        ).save()
+        item2 = models.EventItem(
+            event=self.testEvent,
+            name="Test Item 2",
+            description="Foo",
+            cost="9.72",
+            quantity="3",
+            order=2,
+        ).save()
+        self.testEvent2 = models.Event.objects.create(name="TE E2", status=models.Event.PROVISIONAL,
+                                                      start_date=date.today() + timedelta(days=8),
+                                                      description="start future no end, later",
+                                                      purchase_order='TESTPO',
+                                                      person=self.client,
+                                                      auth_request_by=self.profile,
+                                                      auth_request_at=base.create_datetime(2015, 0o6, 0o4, 10, 00),
+                                                      auth_request_to="some@email.address")
+        self.page = pages.Rigboard(self.driver, self.live_server_url).open()
+
+    def test_buttons(self):
+        header = regions.Header(self.page, self.driver.find_element(By.CSS_SELECTOR, '.navbar'))
+        # TODO Switch to checking reversed links (difficult because of arguments)
+        header.find_link("Rigboard").click()
+        self.assertEqual(
+            self.live_server_url + '/rigboard/', self.driver.current_url)
+        header.find_link("Archive").click()
+        self.assertEqual(
+            self.live_server_url + '/event/archive/', self.driver.current_url)
+        # TODO - This fails for some reason
+        # header.find_link("New").click()
+        # self.assertEqual(
+        #    self.live_server_url + '/event/create/', self.driver.current_url)
+
+    def test_event_order(self):
+        self.assertIn(self.testEvent.start_date.strftime('%a %d/%m/%Y'), self.page.events[0].dates)
+        self.assertIn(self.testEvent2.start_date.strftime('%a %d/%m/%Y'), self.page.events[1].dates)
+
+    def test_add_button(self):
+        self.page.add()
+        self.assertIn('create', self.driver.current_url)
+        # Ideally get a response object to assert 200 on
+
+
+@screenshot_failure_cls
+class TestEventCreate(BaseRigboardTest):
+    def setUp(self):
+        super().setUp()
+        self.page = pages.CreateEvent(self.driver, self.live_server_url).open()
+
+    def test_rig_creation(self):
+        self.select_event_type("Rig")
+
+        self.page.person_selector.search(self.client.name)
+        self.page.person_selector.set_option(self.client.name, True)
+        self.page.person_selector.toggle()
+        self.assertFalse(self.page.person_selector.is_open)
+
+        self.page.name = "Test Rig"
+
+        # Both dates, no times, end before start
+        self.page.start_date = datetime.date(2020, 1, 10)
+        self.page.end_date = datetime.date(2020, 1, 1)
+        # Expected to fail
+        self.page.submit()
+        self.assertFalse(self.page.success)
+        self.assertIn("Unless you've invented time travel, the event can't finish before it has started.", self.page.errors["End date"])
+        self.wait.until(animation_is_finished())
+
+        # Fix it
+        self.page.end_date = datetime.date(2020, 1, 11)
+        self.page.access_at = datetime.datetime(2020, 1, 1, 9)
+        self.page.dry_hire = True
+        self.page.status = "Booked"
+        self.page.collected_by = "Fred"
+        self.page.po = "1234"
+        self.page.notes = "A note!"
+
+        self.page.submit()
+        self.assertTrue(self.page.success)
+
+    # TODO
+    def test_modals(self):
+        self.select_event_type("Rig")
+        # Create new person
+        modal = self.page.add_person()
+        # animation_is_finished doesn't work for whatever reason...
+        self.wait.until(EC.visibility_of_element_located((By.ID, 'modal')))
+        self.assertTrue(modal.is_open)
+        self.assertIn("Create Person", modal.header)
+
+        # Fill person form out and submit
+        person_name = "Test Person"
+        modal.name = person_name
+        modal.submit()
+        self.wait.until(EC.invisibility_of_element_located((By.ID, 'modal')))
+        self.assertFalse(modal.is_open)
+
+        # See new person selected
+        self.page.person_selector.toggle()
+        self.assertEqual(self.page.person_selector.options[0].name, person_name)
+        self.page.person_selector.toggle()
+
+        # Change mind and add another
+        self.wait.until(animation_is_finished())
+        modal = self.page.add_person()
+        self.wait.until(EC.visibility_of_element_located((By.ID, 'modal')))
+        self.assertTrue(modal.is_open)
+        self.assertIn("Create Person", modal.header)
+
+        person_name = "Test Person 2"
+        modal.name = person_name
+        modal.submit()
+        self.wait.until(EC.invisibility_of_element_located((By.ID, 'modal')))
+        self.assertFalse(modal.is_open)
+        self.page.person_selector.toggle()
+        self.assertEqual(self.page.person_selector.options[0].name, person_name)
+        self.page.person_selector.toggle()
+
+        # TODO
+
+    def test_event_item_creation(self):
+        self.select_event_type("Rig")
+
+        self.page.name = "Test Event with Items"
+
+        self.page.person_selector.search(self.client.name)
+        self.page.person_selector.set_option(self.client.name, True)
+        # TODO This should not be necessary, normally closes automatically
+        self.page.person_selector.toggle()
+        self.assertFalse(self.page.person_selector.is_open)
+
+        # Note to self, don't set dates before 2014, which is the beginning of VAT as far as the tests are concerned...
+        self.page.start_date = datetime.date(2084, 1, 1)
+
+        modal = self.page.add_event_item()
+        self.wait.until(animation_is_finished())
+        # See modal has opened
+        self.assertTrue(modal.is_open)
+        self.assertIn("New Event", modal.header)
+
+        modal.name = "Test Item 1"
+        modal.description = "This is an item description\nthat for reasons unknown spans two lines"
+        modal.quantity = "2"
+        modal.price = "23.95"
+        modal.submit()
+        self.wait.until(animation_is_finished())
+
+        # Confirm item has been saved to json field
+        objectitems = self.driver.execute_script("return objectitems;")
+        self.assertEqual(1, len(objectitems))
+        testitem = objectitems["-1"]['fields']  # as we are deliberately creating this we know the ID
+        self.assertEqual("Test Item 1", testitem['name'])
+        self.assertEqual("2", testitem['quantity'])  # test a couple of "worse case" fields
+
+        total = self.driver.find_element_by_id('total')
+        ActionChains(self.driver).move_to_element(total).perform()
+
+        # See new item appear in table
+        row = self.page.item_row("-1")  # ID number is known, see above
+        self.assertIn("Test Item 1", row.name)
+        self.assertIn("This is an item description",
+                      row.description)
+        self.assertEqual('23.95', row.price)
+        self.assertEqual("2", row.quantity)
+        self.assertEqual('47.90', row.subtotal)
+
+        # Check totals TODO convert to page properties
+        self.assertEqual("47.90", self.driver.find_element_by_id('sumtotal').text)
+        self.assertIn("(TBC)", self.driver.find_element_by_id('vat-rate').text)
+        self.assertEqual("9.58", self.driver.find_element_by_id('vat').text)
+        self.assertEqual("57.48", total.text)
+
+        self.page.submit()
+
+    # TODO Testing of internal rig (approval system interface)
+
+    def test_non_rig_creation(self):
+        self.select_event_type("Non-Rig")
+
+        self.assertFalse(self.page.person_selector.is_open)
+
+        rig_name = "Test Non-Rig"
+        self.page.name = rig_name
+
+        # Double-check we don't lose data when swapping
+        self.page.select_event_type("Rig")
+        self.wait.until(animation_is_finished())
+        self.assertEquals(self.page.name, rig_name)
+        self.wait.until(animation_is_finished())
+        self.page.select_event_type("Non-Rig")
+
+        self.page.start_date = datetime.date(2020, 1, 1)
+        self.page.status = "Confirmed"
+
+        self.page.submit()
+        self.assertTrue(self.page.success)
+
+
+@screenshot_failure_cls
+class TestEventDuplicate(BaseRigboardTest):
+    def setUp(self):
+        super().setUp()
+        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,
+                                                     auth_request_by=self.profile,
+                                                     auth_request_at=base.create_datetime(2015, 0o6, 0o4, 10, 00),
+                                                     auth_request_to="some@email.address")
+
+        item1 = models.EventItem(
+            event=self.testEvent,
+            name="Test Item 1",
+            cost="10.00",
+            quantity="1",
+            order=1
+        ).save()
+        item2 = models.EventItem(
+            event=self.testEvent,
+            name="Test Item 2",
+            description="Foo",
+            cost="9.72",
+            quantity="3",
+            order=2,
+        ).save()
+        self.page = pages.DuplicateEvent(self.driver, self.live_server_url, event_id=self.testEvent.pk).open()
+
+    def test_rig_duplicate(self):
+        table = self.page.item_table
+        self.assertIn("Test Item 1", table.text)
+        self.assertIn("Test Item 2", table.text)
+
+        # Check the info message is visible
+        self.assertIn("Event data duplicated but not yet saved", self.page.warning)
+
+        modal = self.page.add_event_item()
+        self.wait.until(animation_is_finished())
+        # See modal has opened
+        self.assertTrue(modal.is_open)
+        self.assertIn(self.testEvent.name, modal.header)
+
+        modal.name = "Test Item 3"
+        modal.description = "This is an item description\nthat for reasons unknown spans two lines"
+        modal.quantity = "2"
+        modal.price = "23.95"
+        modal.submit()
+        self.wait.until(animation_is_finished())
+
+        # Attempt to save
+        self.page.submit()
+
+        # TODO Rewrite when EventDetail page is implemented
+        newEvent = models.Event.objects.latest('pk')
+
+        self.assertEqual(newEvent.auth_request_to, None)
+        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("Event data duplicated but not yet saved", self.page.warning)  # Check info message not visible
+
+        # Check the new items are visible
+        table = self.page.item_table
+        self.assertIn("Test Item 1", table.text)
+        self.assertIn("Test Item 2", table.text)
+        self.assertIn("Test Item 3", table.text)
+
+        infoPanel = self.driver.find_element_by_xpath('//div[contains(text(), "Event Info")]/..')
+        self.assertIn("N%05d" % self.testEvent.pk,
+                      infoPanel.find_element_by_xpath('//dt[text()="Based On"]/following-sibling::dd[1]').text)
+        # Check the PO hasn't carried through
+        self.assertNotIn("TESTPO", infoPanel.find_element_by_xpath('//dt[text()="PO"]/following-sibling::dd[1]').text)
+
+        self.assertIn("N%05d" % self.testEvent.pk,
+                      infoPanel.find_element_by_xpath('//dt[text()="Based On"]/following-sibling::dd[1]').text)
+
+        self.driver.get(self.live_server_url + '/event/' + str(self.testEvent.pk))  # Go back to the old event
+
+        # Check that based-on hasn't crept into the old event
+        infoPanel = self.driver.find_element_by_xpath('//div[contains(text(), "Event Info")]/..')
+        self.assertNotIn("N%05d" % self.testEvent.pk,
+                         infoPanel.find_element_by_xpath('//dt[text()="Based On"]/following-sibling::dd[1]').text)
+        # Check the PO remains on the old event
+        self.assertIn("TESTPO", infoPanel.find_element_by_xpath('//dt[text()="PO"]/following-sibling::dd[1]').text)
+
+        self.assertNotIn("N%05d" % self.testEvent.pk,
+                         infoPanel.find_element_by_xpath('//dt[text()="Based On"]/following-sibling::dd[1]').text)
+
+        # Check the items are as they were
+        table = self.page.item_table  # ID number is known, see above
+        self.assertIn("Test Item 1", table.text)
+        self.assertIn("Test Item 2", table.text)
+        self.assertNotIn("Test Item 3", table.text)
+
+
+@screenshot_failure_cls
+class TestEventEdit(BaseRigboardTest):
+    def setUp(self):
+        super().setUp()
+        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,
+                                                     auth_request_by=self.profile,
+                                                     auth_request_at=base.create_datetime(2015, 0o6, 0o4, 10, 00),
+                                                     auth_request_to="some@email.address")
+
+        item1 = models.EventItem(
+            event=self.testEvent,
+            name="Test Item 1",
+            cost="10.00",
+            quantity="1",
+            order=1
+        ).save()
+        item2 = models.EventItem(
+            event=self.testEvent,
+            name="Test Item 2",
+            description="Foo",
+            cost="9.72",
+            quantity="3",
+            order=2,
+        ).save()
+        self.page = pages.EditEvent(self.driver, self.live_server_url, event_id=self.testEvent.pk).open()
+
+    def test_rig_edit(self):
+        self.page.name = "Edited Event"
+
+        modal = self.page.add_event_item()
+        self.wait.until(animation_is_finished())
+        # See modal has opened
+        self.assertTrue(modal.is_open)
+        self.assertIn(self.testEvent.name, modal.header)
+
+        modal.name = "Test Item 3"
+        modal.description = "This is an item description\nthat for reasons unknown spans two lines"
+        modal.quantity = "2"
+        modal.price = "23.95"
+        modal.submit()
+        self.wait.until(animation_is_finished())
+
+        # Attempt to save
+        ActionChains(self.driver).move_to_element(self.page.item_table).perform()
+        self.page.submit()
+
+        self.assertTrue(self.page.success)
+
+        self.page = pages.EventDetail(self.driver, self.live_server_url, event_id=self.testEvent.pk).open()
+        self.testEvent.refresh_from_db()
+        self.assertIn(self.testEvent.name, self.page.event_name)
+        self.assertEqual(self.page.name, self.testEvent.person.name)
+        # Check the new items are visible
+        table = self.page.item_table
+        self.assertIn("Test Item 3", table.text)
+
+
+@screenshot_failure_cls
+class TestEventDetail(BaseRigboardTest):
+    def setUp(self):
+        super().setUp()
+        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,
+                                                     auth_request_by=self.profile,
+                                                     auth_request_at=base.create_datetime(2015, 0o6, 0o4, 10, 00),
+                                                     auth_request_to="some@email.address")
+
+        item1 = models.EventItem(
+            event=self.testEvent,
+            name="Test Item 1",
+            cost="10.00",
+            quantity="1",
+            order=1
+        ).save()
+        item2 = models.EventItem(
+            event=self.testEvent,
+            name="Test Item 2",
+            description="Foo",
+            cost="9.72",
+            quantity="3",
+            order=2,
+        ).save()
+        self.page = pages.EventDetail(self.driver, self.live_server_url, event_id=self.testEvent.pk).open()
+
+    def test_rig_detail(self):
+        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)
+
+
+@screenshot_failure_cls
+class TestCalendar(BaseRigboardTest):
+    def setUp(self):
+        super().setUp()
+        self.all_events = set(range(1, 18))
+        self.current_events = (1, 2, 3, 6, 7, 8, 10, 11, 12, 14, 15, 16, 18)
+        self.not_current_events = set(self.all_events) - set(self.current_events)
+
+        # produce 7 normal events - 5 current - 1 last week - 1 two years ago - 2 provisional - 2 confirmed - 3 booked
+        models.Event.objects.create(name="TE E1", status=models.Event.PROVISIONAL,
+                                    start_date=date.today() + timedelta(days=6), description="start future no end")
+        models.Event.objects.create(name="TE E2", status=models.Event.PROVISIONAL, start_date=date.today(),
+                                    description="start today no end")
+        models.Event.objects.create(name="TE E3", status=models.Event.CONFIRMED, start_date=date.today(),
+                                    end_date=date.today(), description="start today with end today")
+        models.Event.objects.create(name="TE E4", status=models.Event.CONFIRMED,
+                                    start_date=date.today() - timedelta(weeks=104),
+                                    description="start past 2 years no end")
+        models.Event.objects.create(name="TE E5", status=models.Event.BOOKED,
+                                    start_date=date.today() - timedelta(days=7),
+                                    end_date=date.today() - timedelta(days=1),
+                                    description="start past 1 week with end past")
+        models.Event.objects.create(name="TE E6", status=models.Event.BOOKED,
+                                    start_date=date.today() - timedelta(days=2),
+                                    start_time=time(8, 00),
+                                    end_date=date.today() + timedelta(days=2),
+                                    end_time=time(23, 00), description="start past, end future")
+        models.Event.objects.create(name="TE E7", status=models.Event.BOOKED,
+                                    start_date=date.today() + timedelta(days=2),
+                                    end_date=date.today() + timedelta(days=2), description="start + end in future")
+
+        # 2 cancelled - 1 current
+        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")
+        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 - 1 cancelled
+        models.Event.objects.create(name="TE E10", start_date=date.today(), dry_hire=True, description="dryhire today")
+        models.Event.objects.create(name="TE E11", start_date=date.today(), dry_hire=True, checked_in_by=self.profile,
+                                    description="dryhire today, checked in")
+        models.Event.objects.create(name="TE E12", start_date=date.today() - timedelta(days=1), dry_hire=True,
+                                    status=models.Event.BOOKED, description="dryhire past")
+        models.Event.objects.create(name="TE E13", start_date=date.today() - timedelta(days=2), dry_hire=True,
+                                    checked_in_by=self.profile, description="dryhire past checked in")
+        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
+        models.Event.objects.create(name="TE E15", start_date=date.today(), is_rig=False, description="non rig today")
+        models.Event.objects.create(name="TE E16", start_date=date.today() + timedelta(days=1), is_rig=False,
+                                    description="non rig tomorrow")
+        models.Event.objects.create(name="TE E17", start_date=date.today() - timedelta(days=1), is_rig=False,
+                                    description="non rig yesterday")
+        models.Event.objects.create(name="TE E18", start_date=date.today(), is_rig=False, status=models.Event.CANCELLED,
+                                    description="non rig today cancelled")
+
+        self.page = pages.UserPage(self.driver, self.live_server_url).open()
+
+    def test_api_key_generation(self):
+        # Completes and comes back to /user/
+        # Checks that no api key is displayed
+        self.assertEqual("No API Key Generated", self.page.api_key)
+
+        # Now creates an API key, and check a URL is displayed one
+        self.page.generate_key()
+        self.assertIn("rigs.ics", self.page.cal_url)
+        self.assertNotIn("?", self.page.cal_url)
+
+        # Lets change everything so it's not the default value
+        self.page.toggle_filter('rig')
+        self.page.toggle_filter('non-rig')
+        self.page.toggle_filter('dry-hire')
+        self.page.toggle_filter('cancelled')
+        self.page.toggle_filter('provisional')
+        self.page.toggle_filter('confirmed')
+
+        # and then check the url is correct
+        self.assertIn(
+            "rigs.ics?rig=false&non-rig=false&dry-hire=false&cancelled=true&provisional=false&confirmed=false",
+            self.page.cal_url)
+
+        # Awesome - all seems to work
+
+    def test_ics_files(self):
+        specialEvent = models.Event.objects.get(name="TE E6")
+
+        # Now creates an API key, and check a URL is displayed one
+        self.page.generate_key()
+
+        c = Client()
+
+        # Default settings - should have all non-cancelled events
+        # Get the ical file (can't do this in selanium because reasons)
+        icalUrl = self.page.cal_url
+        response = c.get(self.page.cal_url)
+        self.assertEqual(200, response.status_code)
+
+        # content = response.content.decode('utf-8')
+
+        # Check has entire file
+        self.assertContains(response, "BEGIN:VCALENDAR")
+        self.assertContains(response, "END:VCALENDAR")
+
+        expectedIn = [1, 2, 3, 5, 6, 7, 10, 11, 12, 13, 15, 16, 17]
+        for test in range(1, 18):
+            if test in expectedIn:
+                self.assertContains(response, "TE E" + str(test) + " ")
+            else:
+                self.assertNotContains(response, "TE E" + str(test) + " ")
+
+        # Check that times have been included correctly
+        self.assertContains(response,
+                            specialEvent.start_date.strftime('%Y%m%d') + 'T' + specialEvent.start_time.strftime(
+                                '%H%M%S'))
+        self.assertContains(response,
+                            specialEvent.end_date.strftime('%Y%m%d'))
+        self.assertContains(response,
+                            specialEvent.end_time.strftime('%H%M%S'))
+
+        # Only non rigs
+        self.page.toggle_filter('rig')
+        self.page.toggle_filter('non-rig')
+
+        icalUrl = self.page.cal_url
+        response = c.get(icalUrl)
+        self.assertEqual(200, response.status_code)
+
+        expectedIn = [10, 11, 12, 13]
+        for test in range(1, 18):
+            if test in expectedIn:
+                self.assertContains(response, "TE E" + str(test) + " ")
+            else:
+                self.assertNotContains(response, "TE E" + str(test) + " ")
+
+        # Only provisional rigs
+        self.page.toggle_filter('rig')
+        self.page.toggle_filter('dry-hire')
+        self.page.toggle_filter('confirmed')
+
+        icalUrl = self.page.cal_url
+        response = c.get(icalUrl)
+        self.assertEqual(200, response.status_code)
+
+        expectedIn = [1, 2]
+        for test in range(1, 18):
+            if test in expectedIn:
+                self.assertContains(response, "TE E" + str(test) + " ")
+            else:
+                self.assertNotContains(response, "TE E" + str(test) + " ")
+
+        # Only cancelled non-rigs
+        self.page.toggle_filter('rig')
+        self.page.toggle_filter('non-rig')
+        self.page.toggle_filter('provisional')
+        self.page.toggle_filter('cancelled')
+
+        icalUrl = self.page.cal_url
+        response = c.get(icalUrl)
+        self.assertEqual(200, response.status_code)
+
+        expectedIn = [18]
+        for test in range(1, 18):
+            if test in expectedIn:
+                self.assertContains(response, "TE E" + str(test) + " ")
+            else:
+                self.assertNotContains(response, "TE E" + str(test) + " ")
+
+        # Nothing selected
+        self.page.toggle_filter('non-rig')
+        self.page.toggle_filter('cancelled')
+
+        icalUrl = self.page.cal_url
+        response = c.get(icalUrl)
+        self.assertEqual(200, response.status_code)
+
+        expectedIn = []
+        for test in range(1, 18):
+            if test in expectedIn:
+                self.assertContains(response, "TE E" + str(test) + " ")
+            else:
+                self.assertNotContains(response, "TE E" + str(test) + " ")
+
+                # Wow - that was a lot of tests
+
+
+@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")
+
+        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()
+
+        # Check there are no defaults
+        self.assertIsNone(self.page.nonstandard_equipment)
+
+        # No database side validation, only HTML5.
+
+        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)
+
+        self.page.suspended_structures = False
+        self.page.submit()
+        self.assertTrue(self.page.success)
+
+        # 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)
+
+    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)
+
+    def test_ec_create_small(self):
+        self.page = pages.CreateEventChecklist(self.driver, self.live_server_url, event_id=self.testEvent2.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 = "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);")
+
+        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)
+
+    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)
+
+        # Gotta scroll to make the button clickable
+        self.driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
+
+        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
+
+        self.page.submit()
+        self.assertTrue(self.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()
+
+        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)

RIGS/tests/test_models.py

@@ -0,0 +1,398 @@
+import pytz
+from reversion import revisions as reversion
+from django.conf import settings
+from django.core.exceptions import ValidationError
+from django.test import TestCase
+from RIGS import models
+from versioning import versioning
+from datetime import date, timedelta, datetime, time
+from decimal import *
+from PyRIGS.tests.base import create_browser
+
+
+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"')
+
+
+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)
+
+
+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)
+
+        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"),
+
+            # 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"),
+
+            # 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")
+
+    def test_rig_count(self):
+        # Changed to not include unreturned dry hires in rig count
+        self.assertEqual(models.Event.objects.rig_count(), 7)
+
+    def test_current_events(self):
+        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)
+
+        for eid in self.not_current_events:
+            self.assertNotIn(models.Event.objects.get(name="TE E%d" % eid), current_events)
+
+    def test_related_venue(self):
+        v1 = models.Venue.objects.create(name="TE V1")
+        v2 = models.Venue.objects.create(name="TE V2")
+
+        e1 = []
+        e2 = []
+        for (key, event) in self.events.items():
+            if event.pk % 2:
+                event.venue = v1
+                e1.append(event)
+            else:
+                event.venue = v2
+                e2.append(event)
+            event.save()
+
+        self.assertCountEqual(e1, v1.latest_events)
+        self.assertCountEqual(e2, v2.latest_events)
+
+        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):
+        p1 = models.Person.objects.create(name="TE P1")
+        p2 = models.Person.objects.create(name="TE P2")
+
+        e1 = []
+        e2 = []
+        for (key, event) in self.events.items():
+            if event.pk % 2:
+                event.person = p1
+                e1.append(event)
+            else:
+                event.person = p2
+                e2.append(event)
+            event.save()
+
+        self.assertCountEqual(e1, p1.latest_events)
+        self.assertCountEqual(e2, p2.latest_events)
+
+        for (key, event) in self.events.items():
+            event.person = None
+
+    def test_related_organisation(self):
+        o1 = models.Organisation.objects.create(name="TE O1")
+        o2 = models.Organisation.objects.create(name="TE O2")
+
+        e1 = []
+        e2 = []
+        for (key, event) in self.events.items():
+            if event.pk % 2:
+                event.organisation = o1
+                e1.append(event)
+            else:
+                event.organisation = o2
+                e2.append(event)
+            event.save()
+
+        self.assertCountEqual(e1, o1.latest_events)
+        self.assertCountEqual(e2, o2.latest_events)
+
+        for (key, event) in self.events.items():
+            event.organisation = None
+
+    def test_organisation_person_join(self):
+        p1 = models.Person.objects.create(name="TE P1")
+        p2 = models.Person.objects.create(name="TE P2")
+        o1 = models.Organisation.objects.create(name="TE O1")
+        o2 = models.Organisation.objects.create(name="TE O2")
+
+        events = models.Event.objects.all()
+        # p1 in o1 + o2, p2 in o1
+        for event in events[:2]:
+            event.person = p1
+            event.organisation = o1
+            event.save()
+        for event in events[3:4]:
+            event.person = p1
+            event.organisation = o2
+            event.save()
+        for event in events[5:7]:
+            event.person = p2
+            event.organisation = o1
+            event.save()
+
+        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)
+
+        # 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)
+
+    def test_cancelled_property(self):
+        edit = self.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)
+        event.status = models.Event.PROVISIONAL
+        event.save()
+
+    def test_confirmed_property(self):
+        edit = self.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)
+        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))
+
+        # With start time
+        event.start_time = time(9, 00)
+        self.assertEqual(event.earliest_time, self.create_datetime(2016, 1, 1, 9, 00))
+
+        # With access time
+        event.access_at = self.create_datetime(2015, 12, 0o3, 9, 57)
+        self.assertEqual(event.earliest_time, event.access_at)
+
+        # With meet time
+        event.meet_at = self.create_datetime(2015, 12, 0o3, 9, 55)
+        self.assertEqual(event.earliest_time, event.meet_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))
+
+    def test_latest_time(self):
+        event = models.Event(name="TE LT", start_date=date(2016, 0o1, 0o1))
+
+        # 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)
+
+        # With end time
+        event.end_time = time(23, 00)
+        self.assertEqual(event.latest_time, self.create_datetime(2016, 1, 2, 23, 00))
+
+    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'),
+
+            # 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)),
+
+            # 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)
+
+        self.assertNotIn(events[6], in_bounds)
+
+    def create_datetime(self, year, month, day, hour, min):
+        tz = pytz.timezone(settings.TIME_ZONE)
+        return tz.localize(datetime(year, month, day, hour, min))
+
+
+class EventItemTestCase(TestCase):
+    def setUp(self):
+        self.e1 = models.Event.objects.create(name="TI E1", start_date=date.today())
+        self.e2 = models.Event.objects.create(name="TI E2", start_date=date.today())
+
+    def test_item_cost(self):
+        item = models.EventItem.objects.create(event=self.e1, name="TI I1", quantity=1, cost=1.00, order=1)
+        self.assertEqual(item.total_cost, 1.00)
+
+        item.cost = 2.50
+        self.assertEqual(item.total_cost, 2.50)
+
+        item.quantity = 4
+        self.assertEqual(item.total_cost, 10.00)
+
+        # need to tidy up
+        item.delete()
+
+    def test_item_order(self):
+        i1 = models.EventItem.objects.create(event=self.e1, name="TI I1", quantity=1, cost=1.00, order=1)
+        i2 = models.EventItem.objects.create(event=self.e1, name="TI I2", quantity=1, cost=1.00, order=2)
+
+        items = self.e1.items.all()
+        self.assertListEqual([i1, i2], list(items))
+
+
+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())
+
+        # Create some items E1, total 70.40
+        # Create some items E2, total 381.20
+        self.i1 = models.EventItem.objects.create(event=self.e1, name="TP I1", quantity=1, cost=50.00, order=1)
+        self.i2 = models.EventItem.objects.create(event=self.e1, name="TP I2", quantity=2, cost=3.20, order=2)
+        self.i3 = models.EventItem.objects.create(event=self.e1, name="TP I3", quantity=7, cost=2.00, order=3)
+        self.i4 = models.EventItem.objects.create(event=self.e2, name="TP I4", quantity=2, cost=190.60, order=1)
+
+    # Decimal type is needed here as that is what is returned from the model.
+    # Using anything else results in a failure due to floating point arritmetic
+    def test_sum_totals(self):
+        self.assertEqual(self.e1.sum_total, Decimal('70.40'))
+        self.assertEqual(self.e2.sum_total, Decimal('381.20'))
+
+    def test_vat_rate(self):
+        self.assertEqual(self.e1.vat_rate.rate, Decimal('0.20'))
+        self.assertEqual(self.e2.vat_rate.rate, Decimal('0.10'))
+
+    def test_vat_ammount(self):
+        self.assertEqual(self.e1.vat, Decimal('14.08'))
+        self.assertEqual(self.e2.vat, Decimal('38.12'))
+
+    def test_grand_total(self):
+        self.assertEqual(self.e1.total, Decimal('84.48'))
+        self.assertEqual(self.e2.total, Decimal('419.32'))
+
+
+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',
+            username='eventauthtest',
+            email='teccie@functional.test',
+            is_superuser=True  # lazily grant all permissions
+        )[0]
+        self.person = models.Person.objects.create(name='Authorisation Test Person')
+        self.organisation = models.Organisation.objects.create(name='Authorisation Test Organisation', union_account=True)
+        self.event = models.Event.objects.create(name="AuthorisationTestCase", person=self.person, organisation=self.organisation,
+                                                 start_date=date.today())
+        # Add some items
+        models.EventItem.objects.create(event=self.event, name="Authorisation test item", quantity=2, cost=123.45,
+                                        order=1)
+
+    def test_event_property(self):
+        auth1 = models.EventAuthorisation.objects.create(event=self.event, email="authorisation@model.test.case",
+                                                         name="Test Auth 1", amount=self.event.total - 1,
+                                                         sent_by=self.profile)
+        self.assertFalse(self.event.authorised)
+        auth1.amount = self.event.total
+        auth1.save()
+        self.assertTrue(self.event.authorised)
+
+    def test_last_edited(self):
+        with reversion.create_revision():
+            auth = models.EventAuthorisation.objects.create(event=self.event, email="authorisation@model.test.case",
+                                                            name="Test Auth", amount=self.event.total,
+                                                            sent_by=self.profile)
+        self.assertIsNotNone(auth.last_edited_at)

RIGS/tests/test_unit.py

@@ -0,0 +1,556 @@
+from datetime import date
+
+from django.core.exceptions import ObjectDoesNotExist
+from django.core.management import call_command
+from django.urls import reverse
+from django.test import TestCase
+from django.test.utils import override_settings
+from django.utils import timezone
+
+from RIGS import models
+from reversion import revisions as reversion
+
+
+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"),
+            3: models.Person.objects.create(name="Person 3"),
+        }
+
+        cls.organisations = {
+            1: models.Organisation.objects.create(name="Organisation 1"),
+            2: models.Organisation.objects.create(name="Organisation 2"),
+            3: models.Organisation.objects.create(name="Organisation 3"),
+        }
+
+        cls.venues = {
+            1: models.Venue.objects.create(name="Venue 1"),
+            2: models.Venue.objects.create(name="Venue 2"),
+            3: models.Venue.objects.create(name="Venue 3"),
+        }
+
+        cls.events = {
+            1: models.Event.objects.create(name="TE E1", start_date=date.today(), person=cls.persons[1],
+                                           organisation=cls.organisations[3], venue=cls.venues[2]),
+            2: models.Event.objects.create(name="TE E2", start_date=date.today(), person=cls.persons[2],
+                                           organisation=cls.organisations[2], venue=cls.venues[3]),
+            3: models.Event.objects.create(name="TE E3", start_date=date.today(), person=cls.persons[3],
+                                           organisation=cls.organisations[1], venue=cls.venues[1]),
+            4: models.Event.objects.create(name="TE E4", start_date=date.today(), person=cls.persons[3],
+                                           organisation=cls.organisations[3], venue=cls.venues[3]),
+        }
+
+    def setUp(self):
+        self.profile.set_password('testuser')
+        self.profile.save()
+        self.assertTrue(self.client.login(username=self.profile.username, password='testuser'))
+
+    def test_merge_confirmation(self):
+        change_url = reverse('admin:RIGS_venue_changelist')
+        data = {
+            'action': 'merge',
+            '_selected_action': [str(val.pk) for key, val in self.venues.items()]
+
+        }
+        response = self.client.post(change_url, data, follow=True)
+
+        self.assertContains(response, "The following objects will be merged")
+        for key, venue in self.venues.items():
+            self.assertContains(response, venue.name)
+
+    def test_merge_no_master(self):
+        change_url = reverse('admin:RIGS_venue_changelist')
+        data = {'action': 'merge',
+                '_selected_action': [str(val.pk) for key, val in self.venues.items()],
+                'post': 'yes',
+                }
+        response = self.client.post(change_url, data, follow=True)
+
+        self.assertContains(response, "An error occured")
+
+    def test_venue_merge(self):
+        change_url = reverse('admin:RIGS_venue_changelist')
+
+        data = {'action': 'merge',
+                '_selected_action': [str(self.venues[1].pk), str(self.venues[2].pk)],
+                'post': 'yes',
+                'master': self.venues[1].pk
+                }
+
+        response = self.client.post(change_url, data, follow=True)
+        self.assertContains(response, "Objects successfully merged")
+        self.assertContains(response, self.venues[1].name)
+
+        # Check the master copy still exists
+        self.assertTrue(models.Venue.objects.get(pk=self.venues[1].pk))
+
+        # Check the un-needed venue has been disposed of
+        self.assertRaises(ObjectDoesNotExist, models.Venue.objects.get, pk=self.venues[2].pk)
+
+        # Check the one we didn't delete is still there
+        self.assertEqual(models.Venue.objects.get(pk=self.venues[3].pk), self.venues[3])
+
+        # Check the events have been moved to the master venue
+        for key, event in self.events.items():
+            updatedEvent = models.Event.objects.get(pk=event.pk)
+            if event.venue == self.venues[3]:  # The one we left in place
+                continue
+            self.assertEqual(updatedEvent.venue, self.venues[1])
+
+    def test_person_merge(self):
+        change_url = reverse('admin:RIGS_person_changelist')
+
+        data = {'action': 'merge',
+                '_selected_action': [str(self.persons[1].pk), str(self.persons[2].pk)],
+                'post': 'yes',
+                'master': self.persons[1].pk
+                }
+
+        response = self.client.post(change_url, data, follow=True)
+        self.assertContains(response, "Objects successfully merged")
+        self.assertContains(response, self.persons[1].name)
+
+        # Check the master copy still exists
+        self.assertTrue(models.Person.objects.get(pk=self.persons[1].pk))
+
+        # Check the un-needed people have been disposed of
+        self.assertRaises(ObjectDoesNotExist, models.Person.objects.get, pk=self.persons[2].pk)
+
+        # Check the one we didn't delete is still there
+        self.assertEqual(models.Person.objects.get(pk=self.persons[3].pk), self.persons[3])
+
+        # Check the events have been moved to the master person
+        for key, event in self.events.items():
+            updatedEvent = models.Event.objects.get(pk=event.pk)
+            if event.person == self.persons[3]:  # The one we left in place
+                continue
+            self.assertEqual(updatedEvent.person, self.persons[1])
+
+    def test_organisation_merge(self):
+        change_url = reverse('admin:RIGS_organisation_changelist')
+
+        data = {'action': 'merge',
+                '_selected_action': [str(self.organisations[1].pk), str(self.organisations[2].pk)],
+                'post': 'yes',
+                'master': self.organisations[1].pk
+                }
+
+        response = self.client.post(change_url, data, follow=True)
+        self.assertContains(response, "Objects successfully merged")
+        self.assertContains(response, self.organisations[1].name)
+
+        # Check the master copy still exists
+        self.assertTrue(models.Organisation.objects.get(pk=self.organisations[1].pk))
+
+        # Check the un-needed organisations have been disposed of
+        self.assertRaises(ObjectDoesNotExist, models.Organisation.objects.get, pk=self.organisations[2].pk)
+
+        # Check the one we didn't delete is still there
+        self.assertEqual(models.Organisation.objects.get(pk=self.organisations[3].pk), self.organisations[3])
+
+        # Check the events have been moved to the master organisation
+        for key, event in self.events.items():
+            updatedEvent = models.Event.objects.get(pk=event.pk)
+            if event.organisation == self.organisations[3]:  # The one we left in place
+                continue
+            self.assertEqual(updatedEvent.organisation, self.organisations[1])
+
+
+class TestInvoiceDelete(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 = {
+            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()
+        self.assertTrue(self.client.login(username=self.profile.username, password='testuser'))
+
+    def test_invoice_delete_allowed(self):
+        request_url = reverse('invoice_delete', kwargs={'pk': self.invoices[2].pk})
+
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, "Are you sure")
+
+        # Check the invoice still exists
+        self.assertTrue(models.Invoice.objects.get(pk=self.invoices[2].pk))
+
+        # Actually delete it
+        response = self.client.post(request_url, follow=True)
+
+        # Check the invoice is deleted
+        self.assertRaises(ObjectDoesNotExist, models.Invoice.objects.get, pk=self.invoices[2].pk)
+
+    def test_invoice_delete_not_allowed(self):
+        request_url = reverse('invoice_delete', kwargs={'pk': self.invoices[1].pk})
+
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, "To delete an invoice, delete the payments first.")
+
+        # Check the invoice still exists
+        self.assertTrue(models.Invoice.objects.get(pk=self.invoices[1].pk))
+
+        # Try to actually delete it
+        response = self.client.post(request_url, follow=True)
+
+        # Check this didn't work
+        self.assertTrue(models.Invoice.objects.get(pk=self.invoices[1].pk))
+
+
+class TestPrintPaperwork(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 = {
+            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."),
+        }
+
+        cls.invoices = {
+            1: models.Invoice.objects.create(event=cls.events[1]),
+        }
+
+    def setUp(self):
+        self.profile.set_password('testuser')
+        self.profile.save()
+        self.assertTrue(self.client.login(username=self.profile.username, password='testuser'))
+
+    def test_print_paperwork_success(self):
+        request_url = reverse('event_print', kwargs={'pk': self.events[1].pk})
+
+        response = self.client.get(request_url, follow=True)
+        self.assertEqual(response.status_code, 200)
+
+    def test_print_invoice_success(self):
+        request_url = reverse('invoice_print', kwargs={'pk': self.invoices[1].pk})
+
+        response = self.client.get(request_url, follow=True)
+        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)
+
+
+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')
+
+        # 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
+
+        self.assertRaisesRegex(CommandError, ".*production", call_command, 'generateSampleRIGSData')
+
+
+class TestSearchLogic(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="Right Person", phone="1234"),
+            2: models.Person.objects.create(name="Wrong Person", phone="5678"),
+        }
+
+        cls.organisations = {
+            1: models.Organisation.objects.create(name="Right Organisation", email="test@example.com"),
+            2: models.Organisation.objects.create(name="Wrong Organisation", email="check@fake.co.uk"),
+        }
+
+        cls.venues = {
+            1: models.Venue.objects.create(name="Right Venue", address="1 Test Street, EX1"),
+            2: models.Venue.objects.create(name="Wrong Venue", address="2 Check Way, TS2"),
+        }
+
+        cls.events = {
+            1: models.Event.objects.create(name="Right Event", start_date=date.today(), person=cls.persons[1],
+                                           organisation=cls.organisations[1], venue=cls.venues[1]),
+            2: models.Event.objects.create(name="Wrong Event", start_date=date.today(), person=cls.persons[2],
+                                           organisation=cls.organisations[2], venue=cls.venues[2]),
+        }
+
+    def setUp(self):
+        self.profile.set_password('testuser')
+        self.profile.save()
+        self.assertTrue(self.client.login(username=self.profile.username, password='testuser'))
+
+    def test_event_search(self):
+        # Test search by name
+        request_url = "%s?q=%s" % (reverse('event_archive'), self.events[1].name)
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, self.events[1].name)
+        self.assertNotContains(response, self.events[2].name)
+
+        # Test search by ID
+        request_url = "%s?q=%s" % (reverse('event_archive'), self.events[1].pk)
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, self.events[1].name)
+        self.assertNotContains(response, self.events[2].name)
+
+    def test_people_search(self):
+        # Test search by name
+        request_url = "%s?q=%s" % (reverse('person_list'), self.persons[1].name)
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, self.persons[1].name)
+        self.assertNotContains(response, self.persons[2].name)
+
+        # Test search by ID
+        request_url = "%s?q=%s" % (reverse('person_list'), self.persons[1].pk)
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, self.persons[1].name)
+        self.assertNotContains(response, self.persons[2].name)
+
+        # Test search by phone
+        request_url = "%s?q=%s" % (reverse('person_list'), self.persons[1].phone)
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, self.persons[1].name)
+        self.assertNotContains(response, self.persons[2].name)
+
+    def test_organisation_search(self):
+        # Test search by name
+        request_url = "%s?q=%s" % (reverse('organisation_list'), self.organisations[1].name)
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, self.organisations[1].name)
+        self.assertNotContains(response, self.organisations[2].name)
+
+        # Test search by ID
+        request_url = "%s?q=%s" % (reverse('organisation_list'), self.organisations[1].pk)
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, self.organisations[1].name)
+        self.assertNotContains(response, self.organisations[2].name)
+
+        # Test search by email
+        request_url = "%s?q=%s" % (reverse('organisation_list'), self.organisations[1].email)
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, self.organisations[1].email)
+        self.assertNotContains(response, self.organisations[2].email)
+
+    def test_venue_search(self):
+        # Test search by name
+        request_url = "%s?q=%s" % (reverse('venue_list'), self.venues[1].name)
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, self.venues[1].name)
+        self.assertNotContains(response, self.venues[2].name)
+
+        # Test search by ID
+        request_url = "%s?q=%s" % (reverse('venue_list'), self.venues[1].pk)
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, self.venues[1].name)
+        self.assertNotContains(response, self.venues[2].name)
+
+        # Test search by address
+        request_url = "%s?q=%s" % (reverse('venue_list'), self.venues[1].address)
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, self.venues[1].address)
+        self.assertNotContains(response, self.venues[2].address)
+
+
+class TestHSLogic(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.venue = models.Venue.objects.create(name="Venue 1")
+
+        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.",
+                                           venue=cls.venue),
+            2: models.Event.objects.create(name="TE E2", start_date=date.today()),
+        }
+
+        cls.ras = {
+            1: models.RiskAssessment.objects.create(event=cls.events[1],
+                                                    nonstandard_equipment=False,
+                                                    nonstandard_use=False,
+                                                    contractors=False,
+                                                    other_companies=False,
+                                                    crew_fatigue=False,
+                                                    big_power=False,
+                                                    power_mic=cls.profile,
+                                                    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),
+        }
+
+        cls.checklists = {
+            1: models.EventChecklist.objects.create(event=cls.events[1],
+                                                    power_mic=cls.profile,
+                                                    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=cls.venue),
+        }
+
+    def setUp(self):
+        self.profile.set_password('testuser')
+        self.profile.save()
+        self.assertTrue(self.client.login(username=self.profile.username, password='testuser'))
+
+    def test_list(self):
+        request_url = reverse('hs_list')
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, self.events[1].name)
+        self.assertContains(response, self.events[2].name)
+        self.assertContains(response, 'Create')
+
+    def test_ra_review(self):
+        request_url = reverse('ra_review', kwargs={'pk': self.ras[1].pk})
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, 'Reviewed by')
+        self.assertContains(response, self.profile.name)
+        ra = models.RiskAssessment.objects.get(event=self.events[1])
+        self.assertEqual(timezone.now().date(), ra.reviewed_at.date())
+        self.assertEqual(timezone.now().hour, ra.reviewed_at.hour)
+        self.assertEqual(timezone.now().minute, ra.reviewed_at.minute)
+
+    def test_checklist_review(self):
+        request_url = reverse('ec_review', kwargs={'pk': self.checklists[1].pk})
+        response = self.client.get(request_url, follow=True)
+        self.assertContains(response, 'Reviewed by')
+        self.assertContains(response, self.profile.name)
+        checklist = models.EventChecklist.objects.get(event=self.events[1])
+        self.assertEqual(timezone.now().date(), checklist.reviewed_at.date())
+        self.assertEqual(timezone.now().hour, checklist.reviewed_at.hour)
+        self.assertEqual(timezone.now().minute, checklist.reviewed_at.minute)
+
+    def test_ra_redirect(self):
+        request_url = reverse('event_ra', kwargs={'pk': self.events[1].pk})
+        expected_url = reverse('ra_edit', kwargs={'pk': self.ras[1].pk})
+
+        response = self.client.get(request_url, follow=True)
+        self.assertRedirects(response, expected_url, status_code=302, target_status_code=200)