def test_observation_latest(self):
base_url = self.live_server_url + self.endpoint
# A user has observation data
payload = [
encode_datetime(self.payload_observation(datetime=delta(hours=-4)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(base_url, payload)
payload_2 = [
encode_datetime(self.payload_observation(OBSERVATION_B,
datetime=delta(hours=-6)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(base_url, payload_2)
# The user queries the latest endpoint
latest_url = "{0}/latest".format(base_url)
data = self.assertRecordJSONExists(latest_url)
# A single record is returned
self.assertEqual(1, len(data))
# The user data matches the original payload
self.assertPayloadMatchesData(data[0], payload[0])
def test_prediction_latest(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)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(base_url, payload)
# A user has forecast data
payload_2 = [
encode_datetime(
self.payload_prediction(True,
valid_from=delta(hours=4),
valid_to=delta(hours=6)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(base_url, payload_2)
# The user queries the latest endpoint
latest_url = "{0}{1}/latest".format(self.live_server_url, base_url)
data = self.assertRecordJSONExists(latest_url)
# A single record is returned
self.assertEqual(1, len(data))
# The user data matches the original payload
self.assertPayloadMatchesData(data[0], payload[0])
def test_forecast_date_order(self):
base_url = self.endpoint
# A user has forecast data
payload = [encode_datetime(self.payload_prediction(
valid_from=delta(hours=4),
valid_to=delta(hours=6)
))]
# The user submits the data to the endpoint
self.assertSubmitPayload(base_url, payload)
# A user has previous forecast data
payload_2 = [encode_datetime(self.payload_prediction(
True,
valid_from=delta(hours=2),
valid_to=delta(hours=4)
))]
# The user submits the data to the endpoint
self.assertSubmitPayload(base_url, payload_2)
# The user queries for the latest record
base_url = self.live_server_url + self.endpoint
now_url = "{0}/now".format(base_url)
data = self.assertRecordJSONExists(now_url)
# record-0 matches the second payload
self.assertPayloadMatchesData(data[0], payload_2[0])
# record-1 matches the first payload
self.assertPayloadMatchesData(data[1], payload[0])
def test_prediction_latest(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)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(base_url, payload)
# A user has forecast data
payload_2 = [
encode_datetime(self.payload_prediction(True,
valid_from=delta(hours=4),
valid_to=delta(hours=6)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(base_url, payload_2)
# The user queries the latest endpoint
latest_url = "{0}{1}/latest".format(self.live_server_url, base_url)
data = self.assertRecordJSONExists(latest_url)
# A single record is returned
self.assertEqual(1, len(data))
# The user data matches the original payload
self.assertPayloadMatchesData(data[0], payload[0])
def test_observation_date_order(self):
url = self.live_server_url + self.endpoint
# A user has observation data
payload = [
encode_datetime(self.payload_observation(datetime=delta(hours=-4)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(url, payload)
payload_2 = [
encode_datetime(self.payload_observation(OBSERVATION_B,
datetime=delta(hours=-2)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(url, payload_2)
# 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 first data matches the second payload
self.assertPayloadMatchesData(data[0], payload_2[0])
# The second data matches the first payload
self.assertPayloadMatchesData(data[1], payload[0])
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 test_observation_date_order(self):
url = self.endpoint
# A user has observation data
payload = [
encode_datetime(self.payload_observation(datetime=delta(hours=-4)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(url, payload)
payload_2 = [
encode_datetime(
self.payload_observation(OBSERVATION_B,
datetime=delta(hours=-2)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(url, payload_2)
# 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 first data matches the second payload
self.assertPayloadMatchesData(data[0], payload_2[0])
# The second data matches the first payload
self.assertPayloadMatchesData(data[1], payload[0])
def test_forecast_date_order(self):
base_url = self.endpoint
# A user has forecast data
payload = [
encode_datetime(
self.payload_prediction(valid_from=delta(hours=4),
valid_to=delta(hours=6)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(base_url, payload)
# A user has previous forecast data
payload_2 = [
encode_datetime(
self.payload_prediction(True,
valid_from=delta(hours=2),
valid_to=delta(hours=4)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(base_url, payload_2)
# The user queries for the latest record
base_url = self.live_server_url + self.endpoint
now_url = "{0}/now".format(base_url)
data = self.assertRecordJSONExists(now_url)
# record-0 matches the second payload
self.assertPayloadMatchesData(data[0], payload_2[0])
# record-1 matches the first payload
self.assertPayloadMatchesData(data[1], payload[0])
def test_observation_latest(self):
base_url = self.endpoint
# A user has observation data
payload = [
encode_datetime(self.payload_observation(datetime=delta(hours=-4)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(base_url, payload)
payload_2 = [
encode_datetime(
self.payload_observation(OBSERVATION_B,
datetime=delta(hours=-6)))
]
# The user submits the data to the endpoint
self.assertSubmitPayload(base_url, payload_2)
# The user queries the latest endpoint
latest_url = "{0}/latest".format(self.live_server_url + base_url)
data = self.assertRecordJSONExists(latest_url)
# A single record is returned
self.assertEqual(1, len(data))
# The user data matches the original payload
self.assertPayloadMatchesData(data[0], payload[0])
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 payload_prediction_now(self, alternative=False, **kwargs):
data = {
'valid_from': delta(),
'valid_to': delta(hours=2)
}
data.update(**kwargs)
return self.payload_prediction(alternative, **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.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_existing_objects_order_by_datetime(self):
observation1 = self.create_observation(datetime=delta(hours=-4))
observation2 = self.create_observation(datetime=delta(hours=-2))
observations = WeatherObservation.objects.now_minus_24(self.liverpool)
self.assertEqual(observation2, observations[0])
self.assertEqual(observation1, observations[1])
observation2.delete()
observation1.delete()
def test_that_existing_objects_order_by_datetime(self):
observation1 = self.create_observation(datetime=delta(hours=-4))
observation2 = self.create_observation(datetime=delta(hours=-2))
observations = WeatherObservation.objects.now_minus_24(self.liverpool)
self.assertEqual(observation2, observations[0])
self.assertEqual(observation1, observations[1])
observation2.delete()
observation1.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_prediction_admin(self):
predictions = [
self.create_prediction(valid_from=delta(hours=-4),
valid_to=delta(hours=-2)),
self.create_prediction_now()
]
super(PredictionAdmin, self)._test_admin(predictions, 'predictions',
self.assert_valid_dates)
for prediction in predictions:
prediction.delete()
def test_prediction_admin(self):
predictions = [
self.create_prediction(valid_from=delta(hours=-4),
valid_to=delta(hours=-2)),
self.create_prediction_now()
]
super(PredictionAdmin, self)._test_admin(predictions, 'predictions',
self.assert_valid_dates)
for prediction in predictions:
prediction.delete()
def test_that_existing_objects_order_by_datetime(self):
prediction1 = self.create_prediction(valid_from=delta(hours=4),
valid_to=delta(hours=6))
prediction2 = self.create_prediction(valid_from=delta(hours=2),
valid_to=delta(hours=4))
predictions = WeatherPrediction.objects.now_plus_24(self.liverpool)
self.assertEqual(prediction2, predictions[0])
self.assertEqual(prediction1, predictions[1])
prediction2.delete()
prediction1.delete()
def load_recent_test_cases():
# now - VALID
o = [(delta(), True)]
# now(-1m) - VALID
o.append((delta(minutes=-1), True))
# now(+1m) - NOT VALID
o.append((delta(minutes=1), False))
# now(-1h) - VALID
o.append((delta(hours=-1), True))
# now(-2h) - VALID
o.append((delta(hours=-2), True))
# now(-24h) - VALID
o.append((delta(hours=-24), True))
# now(-24h +1m) - VALID
o.append((delta(hours=-24, minutes=1), True))
# now (-24h -1m) - NOT VALID
o.append((delta(hours=-24, minutes=-1), False))
return o
def load_recent_test_cases():
# now - VALID
o = [(delta(), True)]
# now(-1m) - VALID
o.append((delta(minutes=-1), True))
# now(+1m) - NOT VALID
o.append((delta(minutes=1), False))
# now(-1h) - VALID
o.append((delta(hours=-1), True))
# now(-2h) - VALID
o.append((delta(hours=-2), True))
# now(-24h) - VALID
o.append((delta(hours=-24), True))
# now(-24h +1m) - VALID
o.append((delta(hours=-24, minutes=1), True))
# now (-24h -1m) - NOT VALID
o.append((delta(hours=-24, minutes=-1), False))
return o
def test_that_default_weather_type_is_unavailable(self):
WeatherPrediction.objects.create(precipitation=20,
location=self.location,
pressure=21,
wind_gust=22,
wind_direction='N',
wind_degrees=24,
wind_speed=25,
temperature=26,
supplier='met_office',
valid_from=delta(hours=2),
valid_to=delta(hours=4))
prediction = WeatherPrediction.objects.get()
self.assertEquals('not_available', prediction.weather_type)
def test_that_http_get_no_end_returns_bad_request(self):
prediction = self.create_prediction_now()
data = {'start': delta()}
response = self.client.get(_URL, data)
assert_equal(400, response.status_code)
prediction.delete()
def test_that_http_get_returns_multiple_relevant_now_predictions(self):
prediction1 = self.create_prediction_now()
prediction2 = self.create_prediction(valid_from=delta(hours=-4),
valid_to=delta(hours=-2))
prediction3 = self.create_prediction(valid_from=delta(hours=4),
valid_to=delta(hours=6))
response = self.client.get(_URL_NOW)
assert_equal(200, response.status_code)
data = json.loads(response.content.decode('utf-8'))
assert_equal(2, len(data))
prediction1.delete()
prediction2.delete()
prediction3.delete()
def test_that_http_get_no_start_returns_bad_request(self):
observation = self.create_observation_now()
data = {'end': delta(hours=1)}
response = self.client.get(_URL, data)
assert_equal(400, response.status_code)
observation.delete()
def test_that_http_get_no_start_returns_bad_request(self):
observation = self.create_observation_now()
data = {'end': delta(hours=1)}
response = self.client.get(_URL, data)
assert_equal(400, response.status_code)
observation.delete()
def test_that_duplicate_to_raises(self):
prediction = self.create_prediction()
with self.assertRaises(ValidationError) as validationError:
self.create_prediction(valid_from=delta())
error_base = 'Weather prediction with this Location and Minute {0}'\
' already exists.'
error1 = error_base.format('to')
errors = validationError.exception.message_dict['__all__']
self.assertEquals(error1, errors[0])
prediction.delete()
def test_observation_admin(self):
observations = [
self.create_observation(datetime=delta(hours=-2)),
self.create_observation_now()
]
super(ObservationAdmin, self)._test_admin(observations, 'observations',
self.assert_datetime)
for observation in observations:
observation.delete()
def create_over_twenty_four_hours_of_tide(cls, location):
cls.base_time = delta(hours=1)
day = 86400
minutes = [-10, -9, -8, 0, 1, 2, 3, 4, day + 1, day + 2, day + 3]
for minute in minutes:
create_tide_prediction(
location, cls.base_time + datetime.timedelta(minutes=minute),
5)
def test_observation_admin(self):
observations = [
self.create_observation(datetime=delta(hours=-2)),
self.create_observation_now()
]
super(ObservationAdmin, self)._test_admin(observations, 'observations',
self.assert_datetime)
for observation in observations:
observation.delete()
def test_that_http_get_returns_multiple_weather_observations(self):
observation1 = self.create_observation_now()
observation2 = self.create_observation(datetime=delta(minutes=-1))
response = self.client.get(_URL_RECENT)
assert_equal(200, response.status_code)
data = json.loads(response.content.decode('utf-8'))
assert_equal(2, len(data))
observation1.delete()
observation2.delete()
def test_that_http_get_returns_multiple_weather_observations(self):
observation1 = self.create_observation_now()
observation2 = self.create_observation(datetime=delta(minutes=-1))
response = self.client.get(_URL_RECENT)
assert_equal(200, response.status_code)
data = json.loads(response.content.decode('utf-8'))
assert_equal(2, len(data))
observation1.delete()
observation2.delete()
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_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_returns_multiple_weather_prediction(self):
prediction1 = self.create_prediction_now()
prediction2 = \
self.create_prediction_now(precipitation=20,
pressure=21,
wind_gust=22,
wind_direction='N',
wind_degrees=24,
wind_speed=25,
temperature=26,
supplier='met_office',
weather_type='thunder',
valid_from=delta(hours=2),
valid_to=delta(hours=4))
response = self.client.get(_URL_NOW)
assert_equal(200, response.status_code)
data = json.loads(response.content.decode('utf-8'))
assert_equal(2, len(data))
prediction1.delete()
prediction2.delete()
def load_recent_range_test_cases():
# now - VALID
o = [(delta(), delta(), True)]
# now(-1h) -> now(-1m) - NOT VALID
o.append((delta(hours=-1), delta(minutes=-1), False))
# now(-1h) -> now() - VALID
o.append((delta(hours=-1), delta(), True))
# now(-1m) -> now() - VALID
o.append((delta(minutes=-1), delta(), True))
return o
def load_recent_range_test_cases():
# now - VALID
o = [(delta(), delta(), True)]
# now(-1h) -> now(-1m) - NOT VALID
o.append((delta(hours=-1), delta(minutes=-1), False))
# now(-1h) -> now() - VALID
o.append((delta(hours=-1), delta(), True))
# now(-1m) -> now() - VALID
o.append((delta(minutes=-1), delta(), True))
return o
def create_over_twenty_four_hours_of_tide(cls, location):
cls.base_time = delta(hours=1)
day = 86400
minutes = [-10, -9, -8,
0, 1, 2, 3, 4,
day + 1, day + 2, day + 3]
for minute in minutes:
create_tide_prediction(
location,
cls.base_time + datetime.timedelta(minutes=minute),
5
)
def test_that_schedule_alerts_can_be_disabled(self):
now = now_rounded()
with freeze_time(now):
disable_alert_until(self.origin, AlertType.schedule,
delta(hours=1))
self.assert_status(True, 'OK (alert disabled)', self.origin)
def test_that_weather_observations_alerts_can_be_disabled(self):
now = now_rounded()
with freeze_time(now):
disable_alert_until(self.location, AlertType.weather_predictions,
delta(hours=1))
self.assert_status(True, 'OK (alert disabled)', self.location)
def payload_observation_now(self, observation=OBSERVATION_A, **kwargs):
return self.payload_observation(observation, datetime=delta())
def test_that_schedule_alerts_can_be_disabled(self):
now = now_rounded()
with freeze_time(now):
disable_alert_until(self.origin, AlertType.schedule,
delta(hours=1))
self.assert_status(True, 'OK (alert disabled)', self.origin)
def payload_prediction_now(self, alternative=False, **kwargs):
data = {'valid_from': delta(), 'valid_to': delta(hours=2)}
data.update(**kwargs)
return self.payload_prediction(alternative, **data)
def payload_observation_now(self, observation=OBSERVATION_A, **kwargs):
return self.payload_observation(observation, datetime=delta())
def test_that_old_prediction_has_missing_status(self):
prediction = self.create_prediction(valid_from=delta(days=-2),
valid_to=delta(days=-1))
self.assert_status(False, "Missing data for the next 24 hours",
self.location)
prediction.delete()
def create_schedule_now(self, payload=None, **kwargs):
kwargs['departure'] = format_datetime(now_rounded())
kwargs['arrival'] = format_datetime(delta(hours=2))
return self.create_schedule(payload, **kwargs)
def load_now_test_cases():
# now -> +2h - VALID
o = [(delta(), delta(hours=2), True)]
# ? -> now + 1m - VALID
o.append((delta(hours=-2, minutes=1), delta(minutes=1), True))
# ? -> now - 1m
o.append((delta(hours=-2, minutes=-1), delta(minutes=-1), False))
# now -1m -> ? - VALID
o.append((delta(minutes=-1), delta(hours=2, minutes=-1), True))
# now +1m -> ? - VALID
o.append((delta(minutes=1), delta(hours=2, minutes=1), True))
# now +0.5 -> ? - VALID
o.append((delta(hours=1), delta(hours=3), True))
# ? -> +24h - 1m - VALID
o.append((delta(hours=22, minutes=-1), delta(hours=24, minutes=-1), True))
# ? -> +24h - VALID
o.append((delta(hours=22), delta(hours=24), True))
# ? -> +24h + 1m - VALID
o.append((delta(hours=22, minutes=1), delta(hours=24, minutes=1), True))
# +24 - 1m -> ? - VALID
o.append((delta(hours=24, minutes=-1), delta(hours=26, minutes=-1), True))
# +24h -> ? - VALID
o.append((delta(hours=24), delta(hours=26), True))
# +24h + 1m -> ? - NOT VALID
# o.append((delta(hours=24, minutes=1), delta(hours=26, minutes=1), False))
return o
def create_schedule_now(self, payload=None, **kwargs):
kwargs['departure__datetime'] = format_datetime(now_rounded())
kwargs['arrival__datetime'] = format_datetime(delta(hours=2))
return self.create_schedule(payload, **kwargs)
def test_that_old_observation_has_missing_status(self):
observation = self.create_observation(datetime=delta(days=-2))
self.assert_status(False, "Missing data for the previous 24 hours",
self.location)
observation.delete()
