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()