def test_multiple_day_range_forecasts(self):
base_url = self.endpoint
# A user has forecast data
payload = [
encode_datetime(
self.payload_prediction(valid_from=delta(hours=2),
valid_to=delta(hours=4))),
encode_datetime(
self.payload_prediction(True,
valid_from=delta(days=1, hours=2),
valid_to=delta(days=1, hours=4)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(base_url, payload)
# The user queries for a range record
base_url = self.live_server_url + self.endpoint
range_url = "{0}?start={1}&end={2}" \
.format(base_url, format_datetime(delta()),
format_datetime(delta(days=2)))
data = self.assertRecordJSONExists(range_url)
self.assertEqual(2, len(data))
def test_can_save_observation(self):
# A user has observation data
payload = [encode_datetime(self.payload_observation_now())]
# The user submits the data to the endpoint
self.assertSubmitPayload(self.endpoint, payload)
# The user queries for the recent record
base_url = self.live_server_url + self.endpoint
recent_url = "{0}/recent".format(base_url)
data = self.assertRecordJSONExists(recent_url)
# The user data matches the original payload
self.assertPayloadMatchesData(data[0], payload[0])
# The user queries for a range record
range_url = '{0}?start={1}&end={2}' \
.format(base_url, format_datetime(delta(hours=-1)),
format_datetime(delta()))
data = self.assertRecordJSONExists(range_url)
# The user data matches the original payload
self.assertPayloadMatchesData(data[0], payload[0])
# The user can has individual endpoints to query
endpoints = [
key for key in payload[0].keys()
if key not in ['datetime', 'supplier']
]
# The user queries each endpoint
for endpoint in endpoints:
url = "{0}/{1}/recent".format(base_url, endpoint.replace('_', '-'))
# The user receives a JSON response from the endpoint
data = self.assertRecordJSONExists(url)
# The JSON response contains the observation data
self.assertIn(endpoint, data[0])
self.assertEqual(payload[0][endpoint], data[0][endpoint])
url = "{0}/{1}/latest".format(base_url, endpoint.replace('_', '-'))
# The user receives a JSON response from the endpoint latest
data = self.assertRecordJSONExists(url)
# The JSON response contains the datetime
# The JSON response contains the observation data
self.assertIn(endpoint, data[0])
self.assertEqual(payload[0][endpoint], data[0][endpoint])
self.assertIn('datetime', data[0])
self.assertEquals(payload[0]['datetime'], data[0]['datetime'])
self.assertEqual(payload[0]['datetime'], data[0]['datetime'])
# The user queries the latest endpoint
latest_url = "{0}/latest".format(base_url)
data = self.assertRecordJSONExists(latest_url)
# The user data matches the original payload
self.assertPayloadMatchesData(data[0], payload[0])
def point_status(location, point, start, end, has_observations):
# expected = int((end - start).seconds / 60) + 1
args = [location, start.datetime, end.datetime, point['fields']]
has_predictions = point['predictions_max_day'] and\
point['predictions_max_day'] >= end
has_observations = point['observations_max_day'] and\
point['observations_max_day'] >= end if has_observations else False
records = list(
zip(point['predictions'].objects.has_fields(point['fields']),
point['observations'].objects.has_fields(point['fields']),
point['predictions'].objects.range_records_diff(*args),
point['observations'].objects.range_records_diff(*args)))
url_args = (location.slug, )
url_predictions = reverse(
'{0}prediction-list'.format(point['url_name']), args=url_args)\
+ '?start={0}&end={1}'.format(format_datetime(start.datetime),
format_datetime(end.datetime))
url_observations = reverse(
'{0}observation-list'.format(point['url_name']), args=url_args)\
+ '?start={0}&end={1}'.format(format_datetime(start.datetime),
format_datetime(end.datetime))
ret = [
Status(has_predictions, has_observations,
not pre if has_predictions and _has_pre else True,
not obs if has_observations and _has_obs else True,
url_predictions, url_observations)
for _has_pre, _has_obs, pre, obs in records
]
return ret
def test_multiple_day_range_forecasts(self):
base_url = self.endpoint
# A user has forecast data
payload = [
encode_datetime(self.payload_prediction(
valid_from=delta(hours=2),
valid_to=delta(hours=4)
)),
encode_datetime(self.payload_prediction(
True,
valid_from=delta(days=1, hours=2),
valid_to=delta(days=1, hours=4)
))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(base_url, payload)
# The user queries for a range record
base_url = self.live_server_url + self.endpoint
range_url = "{0}?start={1}&end={2}" \
.format(base_url, format_datetime(delta()),
format_datetime(delta(days=2)))
data = self.assertRecordJSONExists(range_url)
self.assertEqual(2, len(data))
def test_that_http_get_range_prediction(self):
prediction = self.create_prediction_now()
data = {'start': format_datetime(delta()),
'end': format_datetime(delta(hours=1))}
response = self.client.get(_URL, data)
assert_equal(200, response.status_code)
prediction.delete()
def test_can_save_observation(self):
# A user has observation data
payload = [encode_datetime(self.payload_observation_now())]
# The user submits the data to the endpoint
self.assertSubmitPayload(self.live_server_url + self.endpoint, payload)
# The user queries for the recent record
base_url = self.live_server_url + self.endpoint
recent_url = "{0}/recent".format(base_url)
data = self.assertRecordJSONExists(recent_url)
# The user data matches the original payload
self.assertPayloadMatchesData(data[0], payload[0])
# The user queries for a range record
range_url = '{0}?start={1}&end={2}' \
.format(base_url, format_datetime(delta(hours=-1)),
format_datetime(delta()))
data = self.assertRecordJSONExists(range_url)
# The user data matches the original payload
self.assertPayloadMatchesData(data[0], payload[0])
# The user can has individual endpoints to query
endpoints = [key for key in payload[0].keys()
if key not in ['datetime', 'supplier']]
# The user queries each endpoint
for endpoint in endpoints:
url = "{0}/{1}/recent".format(base_url, endpoint.replace('_', '-'))
# The user receives a JSON response from the endpoint
data = self.assertRecordJSONExists(url)
# The JSON response contains the observation data
self.assertIn(endpoint, data[0])
self.assertEqual(payload[0][endpoint], data[0][endpoint])
url = "{0}/{1}/latest".format(base_url, endpoint.replace('_', '-'))
# The user receives a JSON response from the endpoint latest
data = self.assertRecordJSONExists(url)
# The JSON response contains the datetime
# The JSON response contains the observation data
self.assertIn(endpoint, data[0])
self.assertEqual(payload[0][endpoint], data[0][endpoint])
self.assertIn('datetime', data[0])
self.assertEquals(payload[0]['datetime'], data[0]['datetime'])
self.assertEqual(payload[0]['datetime'], data[0]['datetime'])
# The user queries the latest endpoint
latest_url = "{0}/latest".format(base_url)
data = self.assertRecordJSONExists(latest_url)
# The user data matches the original payload
self.assertPayloadMatchesData(data[0], payload[0])
def test_that_http_get_range_future_invalid(self):
observation = self.create_observation_now()
payload = {'start': format_datetime(delta()),
'end': format_datetime(delta(minutes=1))}
response = self.client.get(_URL, payload)
observation.delete()
assert_equal(400, response.status_code)
assert_equal(_('End range cannot be in the future'),
json.loads(response.content.decode('utf-8'))['detail'])
def test_that_http_get_departures_small_timeframe(self, timepoint, exists):
payload = self.payload_schedule(
departure=format_datetime(timepoint),
arrival=format_datetime(timepoint + timedelta(hours=2)))
schedule = self.create_schedule(payload=payload)
url = self.schedule_departures_datetime_endpoint.format(
location_slug='liverpool',
start=self.SCHEDULE_DATETIME_09,
end=self.SCHEDULE_DATETIME_17)
expected = [payload] if exists else []
self.assertGetSchedules(200, items=expected, url=url)
schedule.delete()
def test_that_http_get_range_future_invalid(self):
observation = self.create_observation_now()
payload = {
'start': format_datetime(delta()),
'end': format_datetime(delta(minutes=1))
}
response = self.client.get(_URL, payload)
observation.delete()
assert_equal(400, response.status_code)
assert_equal(_('End range cannot be in the future'),
json.loads(response.content.decode('utf-8'))['detail'])
def test_that_http_get_departures_today(self, timepoint, exists):
payload = self.payload_schedule(
departure=format_datetime(timepoint),
arrival=format_datetime(timepoint + timedelta(hours=2)),
)
schedule = self.create_schedule(payload=payload)
url = self.schedule_departures_today_endpoint.format(
location_slug='liverpool')
expected = [payload] if exists else []
with freeze_time(arrow.get(self.SCHEDULE_DATETIME_12).datetime):
self.assertGetSchedules(200, items=expected, url=url)
schedule.delete()
def get_queryset(self, *args, **kwargs):
new_query_params = self.request.query_params.copy() # make it mutable
now = now_rounded()
now_plus_24 = now + datetime.timedelta(hours=24)
new_query_params.update({
'start': format_datetime(now),
'end': format_datetime(now_plus_24),
})
return super(TideLevelsNow, self).get_queryset(
query_params=new_query_params, *args, **kwargs)
def get_history_date(self, obj):
if not hasattr(obj, 'history'):
return None
if not obj.history.exists():
return None
return format_datetime(obj.history.latest().history_date)
def get_arrival_actual(self, obj):
return format_datetime(self._object_actual(obj, 'arrival'))
def get_departure_actual(self, obj):
return format_datetime(self._object_actual(obj, 'departure'))
def get_arrival_actual(self, obj):
return format_datetime(self._object_actual(obj, 'arrival'))
def get_departure_actual(self, obj):
return format_datetime(self._object_actual(obj, 'departure'))
def encode_datetime(payload):
return {k: format_datetime(v) if type(v) is datetime.datetime else v
for k, v in payload.items()}
def encode_datetime(payload):
return {
k: format_datetime(v) if type(v) is datetime.datetime else v
for k, v in payload.items()
}
