def sea_level_window_json(self):
start = parse_datetime(self.TIDEPREDICTION_A['minute__datetime'])
end = parse_datetime(self.TIDEPREDICTION_C['minute__datetime'])
data = {
'duration':
{
'total_seconds': (float)((end - start).seconds + 60),
},
'start':
{
'sea_level': self.TIDEPREDICTION_A['tide_level'] +
self.SURGEPREDICTION_A['surge_level'],
'datetime': self.TIDEPREDICTION_A['minute__datetime'],
},
'end':
{
'sea_level': self.TIDEPREDICTION_C['tide_level'] +
self.SURGEPREDICTION_C['surge_level'],
'datetime': self.TIDEPREDICTION_C['minute__datetime'],
},
'high_tide':
{
'sea_level': self.TIDEPREDICTION_B['tide_level'] +
self.SURGEPREDICTION_B['surge_level'],
'datetime': self.TIDEPREDICTION_B['minute__datetime'],
},
}
return data
def sea_level_window_json(self):
start = parse_datetime(self.TIDEPREDICTION_A['minute__datetime'])
end = parse_datetime(self.TIDEPREDICTION_C['minute__datetime'])
data = {
'duration': {
'total_seconds': (float)((end - start).seconds + 60),
},
'start': {
'sea_level':
self.TIDEPREDICTION_A['tide_level'] +
self.SURGEPREDICTION_A['surge_level'],
'datetime':
self.TIDEPREDICTION_A['minute__datetime'],
},
'end': {
'sea_level':
self.TIDEPREDICTION_C['tide_level'] +
self.SURGEPREDICTION_C['surge_level'],
'datetime':
self.TIDEPREDICTION_C['minute__datetime'],
},
'high_tide': {
'sea_level':
self.TIDEPREDICTION_B['tide_level'] +
self.SURGEPREDICTION_B['surge_level'],
'datetime':
self.TIDEPREDICTION_B['minute__datetime'],
},
}
return data
def test_that_http_post_can_create_single_weather_prediction(self):
response = self._post_json([PREDICTION_WEATHER])
assert_equal(201, response.status_code)
assert_equal(1, WeatherPrediction.objects.all().count())
keys = map(lambda x: str.replace(x,
'valid_to',
'minute_to__datetime'),
PREDICTION_WEATHER.keys())
keys = map(lambda x: str.replace(x,
'valid_from',
'minute_from__datetime'),
keys)
prediction = WeatherPrediction.objects.get()
ser_data = self._serialize(prediction, keys)[0]
ser_data['valid_from'] = ser_data['minute_from__datetime']
ser_data['valid_to'] = ser_data['minute_to__datetime']
del ser_data['minute_from__datetime']
del ser_data['minute_to__datetime']
weather_data = copy.copy(PREDICTION_WEATHER)
weather_data['valid_from'] = parse_datetime(weather_data['valid_from'])
weather_data['valid_to'] = parse_datetime(weather_data['valid_to'])
assert_equal(weather_data, ser_data)
def test_event_sent_doesnt_requeue(self):
self.setUpPredictions()
broadcast = self.Broadcast.create_broadcast()
schedule = self.create_schedule()
self.assertEqual(1, QSchedule.objects.all().count())
event = self.get_event()
event.datetime_sent = timezone.now()
event.qschedule = None
event.save()
self.assertEqual(1, QSchedule.objects.all().count())
schedule.departure = parse_datetime(self.SCHEDULE_DATETIME_12_01)
schedule.save()
self.assertEqual(1, QSchedule.objects.all().count())
broadcast.minutes_before_departure = 45
broadcast.save()
self.assertEqual(1, QSchedule.objects.all().count())
schedule.delete()
broadcast.delete()
def test_event_sent_doesnt_requeue(self):
self.setUpPredictions()
broadcast = self.Broadcast.create_broadcast()
schedule = self.create_schedule()
self.assertEqual(1, QSchedule.objects.all().count())
event = self.get_event()
event.datetime_sent = timezone.now()
event.qschedule = None
event.save()
self.assertEqual(1, QSchedule.objects.all().count())
schedule.departure = parse_datetime(self.SCHEDULE_DATETIME_12_01)
schedule.save()
self.assertEqual(1, QSchedule.objects.all().count())
broadcast.minutes_before_departure = 45
broadcast.save()
self.assertEqual(1, QSchedule.objects.all().count())
schedule.delete()
broadcast.delete()
def test_that_http_comparison_updated2_schedule(self):
payload = self.payload_schedule()
schedule = self.create_schedule(payload=payload)
schedule.departure = parse_datetime(
self.SCHEDULE_COMPARISON_C['departure_actual'])
schedule.arrival = parse_datetime(
self.SCHEDULE_COMPARISON_C['arrival_actual'])
schedule.vessel = self.vessel2
schedule.save()
with freeze_time(payload['departure']):
self.assertGetScheduleComparisons(
200,
[self.SCHEDULE_COMPARISON_C],
url=_URL_COMPARISON_LIVERPOOL)
schedule.delete()
def test_that_update_schedule_updates_queue(self):
self.setUpPredictions()
broadcast = self.Broadcast.create_broadcast()
schedule = self.create_schedule()
schedule.departure = parse_datetime(self.SCHEDULE_DATETIME_12_01)
schedule.save()
self.assertNextRun(broadcast, schedule)
def test_that_update_schedule_updates_queue(self):
self.setUpPredictions()
broadcast = self.Broadcast.create_broadcast()
schedule = self.create_schedule()
schedule.departure = parse_datetime(self.SCHEDULE_DATETIME_12_01)
schedule.save()
self.assertNextRun(broadcast, schedule)
def test_that_update_broadcast_no_predictions_deletes(self):
self.setUpPredictions()
broadcast = self.Broadcast.create_broadcast()
schedule = self.create_schedule()
schedule.departure = parse_datetime(self.SCHEDULE_DATETIME_13)
schedule.save()
self.assertEqual(0, QSchedule.objects.all().count())
self.assertEventCount(0)
schedule.delete()
broadcast.delete()
def test_that_update_broadcast_no_predictions_deletes(self):
self.setUpPredictions()
broadcast = self.Broadcast.create_broadcast()
schedule = self.create_schedule()
schedule.departure = parse_datetime(self.SCHEDULE_DATETIME_13)
schedule.save()
self.assertEqual(0, QSchedule.objects.all().count())
self.assertEventCount(0)
schedule.delete()
broadcast.delete()
def test_update_schedule(self):
self.admin_create_broadcast()
# A schedule is created
schedule = self.create_schedule()
# The schedule is updated
schedule.departure = parse_datetime(self.SCHEDULE_DATETIME_12_01)
schedule.save()
# The django_q schedule is updated
minutes = self.Broadcast.DATA_A['minutes_before_departure']
self.assertScheduleNextRun(schedule, minutes)
schedule.delete()
def test_update_schedule(self):
self.admin_create_broadcast()
# A schedule is created
schedule = self.create_schedule()
# The schedule is updated
schedule.departure = parse_datetime(self.SCHEDULE_DATETIME_12_01)
schedule.save()
# The django_q schedule is updated
minutes = self.Broadcast.DATA_A['minutes_before_departure']
self.assertScheduleNextRun(schedule, minutes)
schedule.delete()
def test_comparison_retrieve(self):
# As a user, I wish to retrieve a comparision for a location
# with: code, vessel_original, vessel_actual, vesssel_changed
# departure_original, departure_actual, departure_changed
# departure_delay
# arrival_original, arrival_actual, arrival_changed,
# arrival_delay
# A schedule exists
schedule = self.create_schedule()
reference_time = self.SCHEDULE_A['departure']
url_departure = self.live_server_url + \
self.schedule_departures_comparison_endpoint.format(
location_slug='liverpool',
start=self.SCHEDULE_DATETIME_12,
end=self.SCHEDULE_DATETIME_14)
url_arrival = self.live_server_url + \
self.schedule_arrivals_comparison_endpoint.format(
location_slug='heysham',
start=self.SCHEDULE_DATETIME_12,
end=self.SCHEDULE_DATETIME_14)
# The user retrieves the comparisions
with freeze_time(arrow.get(reference_time).datetime):
data_departure = self.assertRecordJSONExists(url_departure)[0]
data_arrival = self.assertRecordJSONExists(url_arrival)[0]
# The user notices the comparisons are correct
self.assertDictEqual(self.SCHEDULE_COMPARISON_A, data_departure)
self.assertDictEqual(self.SCHEDULE_COMPARISON_A, data_arrival)
# The schedule has been revised
schedule.departure = parse_datetime('2016-03-26T12:05:00Z')
schedule.save()
# The user retrieves the comparisions
with freeze_time(arrow.get(reference_time).datetime):
data_departure = self.assertRecordJSONExists(url_departure)[0]
data_arrival = self.assertRecordJSONExists(url_arrival)[0]
# The user notices the comparisons are correct
self.assertDictEqual(self.SCHEDULE_COMPARISON_B, data_departure)
self.assertDictEqual(self.SCHEDULE_COMPARISON_B, data_arrival)
schedule.delete()
def test_comparison_retrieve(self):
# As a user, I wish to retrieve a comparision for a location
# with: code, vessel_original, vessel_actual, vesssel_changed
# departure_original, departure_actual, departure_changed
# departure_delay
# arrival_original, arrival_actual, arrival_changed,
# arrival_delay
# A schedule exists
schedule = self.create_schedule()
reference_time = self.SCHEDULE_A['departure']
url_departure = self.live_server_url + \
self.schedule_departures_comparison_endpoint.format(
location_slug='liverpool',
start=self.SCHEDULE_DATETIME_12,
end=self.SCHEDULE_DATETIME_14)
url_arrival = self.live_server_url + \
self.schedule_arrivals_comparison_endpoint.format(
location_slug='heysham',
start=self.SCHEDULE_DATETIME_12,
end=self.SCHEDULE_DATETIME_14)
# The user retrieves the comparisions
with freeze_time(arrow.get(reference_time).datetime):
data_departure = self.assertRecordJSONExists(url_departure)[0]
data_arrival = self.assertRecordJSONExists(url_arrival)[0]
# The user notices the comparisons are correct
self.assertDictEqual(self.SCHEDULE_COMPARISON_A, data_departure)
self.assertDictEqual(self.SCHEDULE_COMPARISON_A, data_arrival)
# The schedule has been revised
schedule.departure = parse_datetime('2016-03-26T12:05:00Z')
schedule.save()
# The user retrieves the comparisions
with freeze_time(arrow.get(reference_time).datetime):
data_departure = self.assertRecordJSONExists(url_departure)[0]
data_arrival = self.assertRecordJSONExists(url_arrival)[0]
# The user notices the comparisons are correct
self.assertDictEqual(self.SCHEDULE_COMPARISON_B, data_departure)
self.assertDictEqual(self.SCHEDULE_COMPARISON_B, data_arrival)
schedule.delete()
def related_payload(self, payload):
get_location = lambda x, y: Location.objects.get(slug=x[y + '__slug'])
get_minute = lambda x, y: \
Minute.objects.get_or_create(
datetime=parse_datetime(x[y + '__datetime']))[0]
get_vessel = lambda x, y: Vessel.objects.get(slug=x[y + '__slug'])
payload['origin'] = get_location(payload, 'origin')
payload['destination'] = get_location(payload, 'destination')
payload['departure'] = get_minute(payload, 'departure')
payload['arrival'] = get_minute(payload, 'arrival')
payload['vessel'] = get_vessel(payload, 'vessel')
del payload['origin__slug']
del payload['destination__slug']
del payload['departure__datetime']
del payload['arrival__datetime']
del payload['vessel__slug']
return payload
def test_that_http_post_can_create_single_weather_observation(self):
data = json.dumps([OBSERVATION_A])
response = self.client.post(_URL, data=data,
content_type='application/json')
assert_equal(201, response.status_code)
assert_equal(1, WeatherObservation.objects.all().count())
observation = WeatherObservation.objects.get()
keys = map(lambda x: str.replace(x, 'datetime', 'minute__datetime'),
OBSERVATION_A.keys())
serialized_data = WeatherObservation.objects\
.filter(id=observation.id).values(*keys)[0]
serialized_data['datetime'] = serialized_data['minute__datetime']
del serialized_data['minute__datetime']
weather_data = copy.copy(OBSERVATION_A)
weather_data['datetime'] = parse_datetime(weather_data['datetime'])
assert_equal(weather_data, serialized_data)
def test_that_http_post_can_create_single_weather_observation(self):
data = json.dumps([OBSERVATION_A])
response = self.client.post(_URL,
data=data,
content_type='application/json')
assert_equal(201, response.status_code)
assert_equal(1, WeatherObservation.objects.all().count())
observation = WeatherObservation.objects.get()
keys = map(lambda x: str.replace(x, 'datetime', 'minute__datetime'),
OBSERVATION_A.keys())
serialized_data = WeatherObservation.objects\
.filter(id=observation.id).values(*keys)[0]
serialized_data['datetime'] = serialized_data['minute__datetime']
del serialized_data['minute__datetime']
weather_data = copy.copy(OBSERVATION_A)
weather_data['datetime'] = parse_datetime(weather_data['datetime'])
assert_equal(weather_data, serialized_data)
def test_multiple_history(self):
schedule = self.create_schedule()
schedule.departure = parse_datetime('2016-03-26T15:00:00Z')
schedule.save()
self.assertEqual(2, len(schedule.history.all()))
schedule.delete()
def valid_to(self, value):
if isinstance(value, str):
value = parse_datetime(value)
self.minute_to, _ = Minute.objects.get_or_create(datetime=value)
def test_multiple_history(self):
schedule = self.create_schedule()
schedule.departure = parse_datetime('2016-03-26T15:00:00Z')
schedule.save()
self.assertEqual(2, len(schedule.history.all()))
schedule.delete()
def valid_to(self, value):
if isinstance(value, str):
value = parse_datetime(value)
self.minute_to, _ = Minute.objects.get_or_create(datetime=value)
def datetime(self, value):
if isinstance(value, str):
value = parse_datetime(value)
self.minute, _ = Minute.objects.get_or_create(datetime=value)
return self.minute
def arrival_datetime(self, value):
if isinstance(value, str):
value = parse_datetime(value)
self.arrival, _ = Minute.objects.get_or_create(datetime=value)
return self.arrival
def payload_minute_datetime(self, payload):
payload['minute'], _ = Minute.objects.get_or_create(
datetime=parse_datetime(payload['minute__datetime']))
del payload['minute__datetime']
return payload
def payload_minute_datetime(self, payload):
payload['minute'], _ = Minute.objects.get_or_create(
datetime=parse_datetime(payload['minute__datetime']))
del payload['minute__datetime']
return payload