def test_post_an_asset_as_admin(client, setup_api_fresh_test_data, admin_kind):
"""
Post one extra asset, as an admin user.
"""
with AccountContext("Test Prosumer Account") as prosumer:
post_data = get_asset_post_data(
account_id=prosumer.id,
asset_type_id=prosumer.generic_assets[0].generic_asset_type.id,
)
if admin_kind == "site-admin":
auth_token = get_auth_token(client, "*****@*****.**",
"testtest")
else:
auth_token = get_auth_token(client, "*****@*****.**",
"testtest")
post_data["name"] = "Test battery 3"
post_assets_response = client.post(
url_for("AssetAPI:post"),
json=post_data,
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
print("Server responded with:\n%s" % post_assets_response.json)
assert post_assets_response.status_code == 201
assert post_assets_response.json["latitude"] == 30.1
asset: GenericAsset = GenericAsset.query.filter(
GenericAsset.name == post_data["name"]).one_or_none()
assert asset is not None
assert asset.latitude == 30.1
def test_invalid_or_no_unit(client, method, message):
if method == "GET":
get_meter_data_response = client.get(
url_for("flexmeasures_api_v1.get_meter_data"),
query_string=message,
headers={
"Authorization": get_auth_token(
client, "*****@*****.**", "testtest"
)
},
)
elif method == "POST":
get_meter_data_response = client.post(
url_for("flexmeasures_api_v1.get_meter_data"),
json=message,
headers={
"Authorization": get_auth_token(
client, "*****@*****.**", "testtest"
)
},
)
else:
get_meter_data_response = []
assert get_meter_data_response.status_code == 400
assert get_meter_data_response.json["type"] == "GetMeterDataResponse"
assert (
get_meter_data_response.json["status"]
== invalid_unit("power", ["MW"])[0]["status"]
)
def test_post_sensor_data(
client,
setup_api_fresh_test_data,
num_values,
expected_num_values,
unit,
expected_value,
):
post_data = make_sensor_data_request_for_gas_sensor(
num_values=num_values, unit=unit
)
sensor = Sensor.query.filter(Sensor.name == "some gas sensor").one_or_none()
beliefs_before = TimedBelief.query.filter(TimedBelief.sensor_id == sensor.id).all()
print(f"BELIEFS BEFORE: {beliefs_before}")
assert len(beliefs_before) == 0
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
response = client.post(
url_for("SensorAPI:post_data"),
json=post_data,
headers={"Authorization": auth_token},
)
print(response.json)
assert response.status_code == 200
beliefs = TimedBelief.query.filter(TimedBelief.sensor_id == sensor.id).all()
print(f"BELIEFS AFTER: {beliefs}")
assert len(beliefs) == expected_num_values
# check that values are scaled to the sensor unit correctly
assert pytest.approx(beliefs[0].event_value - expected_value) == 0
def test_get_assets(
client, setup_api_test_data, setup_accounts, account_name, num_assets
):
"""
Get assets per account.
Our user here is admin, so is allowed to see all assets.
"""
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
query = {"account_id": setup_accounts[account_name].id}
get_assets_response = client.get(
url_for("AssetAPI:index"),
query_string=query,
headers={"content-type": "application/json", "Authorization": auth_token},
)
print("Server responded with:\n%s" % get_assets_response.json)
assert get_assets_response.status_code == 200
assert len(get_assets_response.json) == num_assets
if account_name == "Supplier": # one deep dive
turbine = {}
for asset in get_assets_response.json:
if asset["name"] == "Test wind turbine":
turbine = asset
assert turbine
assert turbine["account_id"] == setup_accounts["Supplier"].id
def test_post_price_data(db, app, post_message):
"""
Try to post price data as a logged-in test user with the Supplier role, which should succeed.
"""
# call with client whose context ends, so that we can test for,
# after-effects in the database after teardown committed.
with app.test_client() as client:
# post price data
auth_token = get_auth_token(client, "*****@*****.**",
"testtest")
post_price_data_response = client.post(
url_for("flexmeasures_api_v1_1.post_price_data"),
json=post_message,
headers={"Authorization": auth_token},
)
print("Server responded with:\n%s" % post_price_data_response.json)
assert post_price_data_response.status_code == 200
assert post_price_data_response.json["type"] == "PostPriceDataResponse"
verify_prices_in_db(post_message, post_message["values"], db)
# look for Forecasting jobs in queue
assert (len(app.queues["forecasting"]) == 2
) # only one market is affected, but two horizons
horizons = [timedelta(hours=24), timedelta(hours=48)]
jobs = sorted(app.queues["forecasting"].jobs,
key=lambda x: x.kwargs["horizon"])
market = get_market(post_message)
for job, horizon in zip(jobs, horizons):
assert job.kwargs["horizon"] == horizon
assert job.kwargs["start"] == parse_date(
post_message["start"]) + horizon
assert job.kwargs["timed_value_type"] == "Price"
assert job.kwargs["asset_id"] == market.id
def test_get_assets(client, add_charging_station_assets, use_owner_id,
num_assets):
"""
Get assets, either for all users (our user here is admin, so is allowed to see all 7 assets) or for
a unique one (prosumer user 2 has one asset ― "Test battery").
"""
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
test_prosumer2_id = find_user_by_email("*****@*****.**").id
query = {}
if use_owner_id:
query["owner_id"] = test_prosumer2_id
get_assets_response = client.get(
url_for("flexmeasures_api_v2_0.get_assets"),
query_string=query,
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
print("Server responded with:\n%s" % get_assets_response.json)
assert get_assets_response.status_code == 200
assert len(get_assets_response.json) == num_assets
battery = {}
for asset in get_assets_response.json:
if asset["name"] == "Test battery":
battery = asset
assert battery
assert pd.Timestamp(
battery["soc_datetime"]) == pd.Timestamp("2015-01-01T00:00:00+00:00")
assert battery["owner_id"] == test_prosumer2_id
assert battery["capacity_in_mw"] == 2
def test_get_asset_nonaccount_access(client, setup_api_test_data):
"""Without being on the same account, test correct responses when accessing one asset."""
with UserContext("*****@*****.**") as prosumer1:
prosumer1_assets = prosumer1.account.generic_assets
with UserContext("*****@*****.**") as supplieruser4:
supplieruser4_assets = supplieruser4.account.generic_assets
headers = {
"content-type": "application/json",
"Authorization": get_auth_token(
client, "*****@*****.**", "testtest"
),
}
# okay to look at assets in own account
asset_response = client.get(
url_for("AssetAPI:fetch_one", id=supplieruser4_assets[0].id),
headers=headers,
follow_redirects=True,
)
assert asset_response.status_code == 200
# not okay to see assets owned by other accounts
asset_response = client.get(
url_for("AssetAPI:fetch_one", id=prosumer1_assets[0].id),
headers=headers,
follow_redirects=True,
)
assert asset_response.status_code == 403
# proper 404 for non-existing asset
asset_response = client.get(
url_for("AssetAPI:fetch_one", id=8171766575),
headers=headers,
follow_redirects=True,
)
assert asset_response.status_code == 404
assert "not found" in asset_response.json["message"]
def test_post_an_asset(client):
"""
Post one extra asset, as an admin user.
TODO: Soon we'll allow creating assets on an account-basis, i.e. for users
who have the user role "account-admin" or sthg similar. Then we'll
test that here.
"""
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
post_data = get_asset_post_data()
post_assets_response = client.post(
url_for("flexmeasures_api_v2_0.post_assets"),
json=post_data,
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
print("Server responded with:\n%s" % post_assets_response.json)
assert post_assets_response.status_code == 201
assert post_assets_response.json["latitude"] == 30.1
asset: Asset = Asset.query.filter(
Asset.name == "Test battery 2").one_or_none()
assert asset is not None
assert asset.capacity_in_mw == 3
def test_get_asset_nonadmin_access(client):
"""Without being an admin, test correct responses when accessing one asset."""
with UserContext("*****@*****.**") as prosumer1:
prosumer1_assets = prosumer1.assets
with UserContext("*****@*****.**") as prosumer2:
prosumer2_assets = prosumer2.assets
headers = {
"content-type":
"application/json",
"Authorization":
get_auth_token(client, "*****@*****.**", "testtest"),
}
# okay to look at own asset
asset_response = client.get(
url_for("flexmeasures_api_v2_0.get_asset", id=prosumer2_assets[0].id),
headers=headers,
follow_redirects=True,
)
assert asset_response.status_code == 200
# not okay to see assets owned by others
asset_response = client.get(
url_for("flexmeasures_api_v2_0.get_asset", id=prosumer1_assets[0].id),
headers=headers,
follow_redirects=True,
)
assert asset_response.status_code == 403
# proper 404 for non-existing asset
asset_response = client.get(
url_for("flexmeasures_api_v2_0.get_asset", id=8171766575),
headers=headers,
follow_redirects=True,
)
assert asset_response.status_code == 404
assert "not found" in asset_response.json["message"]
def test_post_sensor_data_twice(client, setup_api_test_data):
auth_token = get_auth_token(client, "*****@*****.**",
"testtest")
post_data = make_sensor_data_request_for_gas_sensor()
# Check that 1st time posting the data succeeds
response = client.post(
url_for("SensorAPI:post_data"),
json=post_data,
headers={"Authorization": auth_token},
)
print(response.json)
assert response.status_code == 200
# Check that 2nd time posting the same data succeeds informatively
response = client.post(
url_for("SensorAPI:post_data"),
json=post_data,
headers={"Authorization": auth_token},
)
print(response.json)
assert response.status_code == 200
assert "data has already been received" in response.json["message"]
# Check that replacing data fails informatively
post_data["values"][0] = 100
response = client.post(
url_for("SensorAPI:post_data"),
json=post_data,
headers={"Authorization": auth_token},
)
print(response.json)
assert response.status_code == 403
assert "data represents a replacement" in response.json["message"]
def test_get_prognosis(client, message):
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
get_prognosis_response = client.get(
url_for("flexmeasures_api_v1_1.get_prognosis"),
query_string=message_replace_name_with_ea(message),
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
print("Server responded with:\n%s" % get_prognosis_response.json)
assert get_prognosis_response.status_code == 200
if "groups" in get_prognosis_response.json:
assert get_prognosis_response.json["groups"][0]["values"] == [
300,
301,
302,
303,
304,
305,
]
else:
assert get_prognosis_response.json["values"] == [
300, 301, 302, 303, 304, 305
]
def test_post_weather_data(
setup_fresh_api_v1_1_test_data,
add_weather_sensors_fresh_db,
app,
client,
post_message,
):
"""
Try to post wind speed data as a logged-in test user, which should lead to forecasting jobs.
"""
auth_token = get_auth_token(client, "*****@*****.**",
"testtest")
post_weather_data_response = client.post(
url_for("flexmeasures_api_v1_1.post_weather_data"),
json=post_message,
headers={"Authorization": auth_token},
)
print("Server responded with:\n%s" % post_weather_data_response.json)
assert post_weather_data_response.status_code == 200
assert post_weather_data_response.json["type"] == "PostWeatherDataResponse"
forecast_horizons = forecast_horizons_for(timedelta(minutes=5))
jobs = get_forecasting_jobs(last_n=len(forecast_horizons))
for job, horizon in zip(sorted(jobs, key=lambda x: x.kwargs["horizon"]),
forecast_horizons):
# check if jobs have expected horizons
assert job.kwargs["horizon"] == horizon
# check if jobs' start time (the time to be forecasted)
# is the weather observation plus the horizon
assert job.kwargs["start"] == parse_date(
post_message["start"]) + horizon
def test_get_meter_data(db, app, client, message):
"""Checks Charging Station 5, which has multi-sourced data for the same time interval:
6 values from a Prosumer, and 6 values from a Supplier.
All data should be in the database, and currently only the Prosumer data is returned.
"""
message["connection"] = "CS 5"
# set up frame with expected values, and filter by source if needed
expected_values = pd.concat(
[
pd.DataFrame.from_dict(
dict(
value=[(100.0 + i) for i in range(6)],
datetime=[
isodate.parse_datetime("2015-01-01T00:00:00Z")
+ timedelta(minutes=15 * i)
for i in range(6)
],
data_source_id=1,
)
),
pd.DataFrame.from_dict(
dict(
value=[(1000.0 - 10 * i) for i in range(6)],
datetime=[
isodate.parse_datetime("2015-01-01T00:00:00Z")
+ timedelta(minutes=15 * i)
for i in range(6)
],
data_source_id=2,
)
),
]
)
if "source" in message:
source_ids = validate_user_sources(message["source"])
expected_values = expected_values[
expected_values["data_source_id"].isin(source_ids)
]
expected_values = expected_values.set_index(
["datetime", "data_source_id"]
).sort_index()
# check whether conftest.py did its job setting up the database with expected values
cs_5 = Asset.query.filter(Asset.name == "CS 5").one_or_none()
verify_power_in_db(message, cs_5, expected_values, db, swapped_sign=True)
# check whether the API returns the expected values (currently only the Prosumer data is returned)
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
get_meter_data_response = client.get(
url_for("flexmeasures_api_v1.get_meter_data"),
query_string=message_replace_name_with_ea(message),
headers={"content-type": "application/json", "Authorization": auth_token},
)
print("Server responded with:\n%s" % get_meter_data_response.json)
assert get_meter_data_response.status_code == 200
assert get_meter_data_response.json["values"] == [(100.0 + i) for i in range(6)]
def test_post_udi_event(app, message):
auth_token = None
with app.test_client() as client:
sensor = Sensor.query.filter(
Sensor.name == "Test battery").one_or_none()
message["event"] = message["event"] % sensor.id
auth_token = get_auth_token(client, "*****@*****.**",
"testtest")
post_udi_event_response = client.post(
url_for("flexmeasures_api_v1_2.post_udi_event"),
json=message,
headers={"Authorization": auth_token},
)
print("Server responded with:\n%s" % post_udi_event_response.json)
assert post_udi_event_response.status_code == 200
assert post_udi_event_response.json["type"] == "PostUdiEventResponse"
msg_dt = message["datetime"]
# test database state
sensor = Sensor.query.filter(Sensor.name == "Test battery").one_or_none()
assert sensor.generic_asset.get_attribute("soc_datetime") == msg_dt
assert sensor.generic_asset.get_attribute(
"soc_in_mwh") == message["value"] / 1000
assert sensor.generic_asset.get_attribute("soc_udi_event_id") == 204
# sending again results in an error, unless we increase the event ID
with app.test_client() as client:
next_msg_dt = parse_datetime(msg_dt) + timedelta(minutes=5)
message["datetime"] = next_msg_dt.strftime("%Y-%m-%dT%H:%M:%S.%f%z")
post_udi_event_response = client.post(
url_for("flexmeasures_api_v1_2.post_udi_event"),
json=message,
headers={"Authorization": auth_token},
)
print("Server responded with:\n%s" % post_udi_event_response.json)
assert post_udi_event_response.status_code == 400
assert post_udi_event_response.json["type"] == "PostUdiEventResponse"
assert post_udi_event_response.json["status"] == "OUTDATED_UDI_EVENT"
message["event"] = message["event"].replace("204", "205")
post_udi_event_response = client.post(
url_for("flexmeasures_api_v1_2.post_udi_event"),
json=message,
headers={"Authorization": auth_token},
)
print("Server responded with:\n%s" % post_udi_event_response.json)
assert post_udi_event_response.status_code == 200
assert post_udi_event_response.json["type"] == "PostUdiEventResponse"
# test database state
sensor = Sensor.query.filter(Sensor.name == "Test battery").one_or_none()
assert parse_datetime(
sensor.generic_asset.get_attribute("soc_datetime")) == parse_datetime(
message["datetime"])
assert sensor.generic_asset.get_attribute(
"soc_in_mwh") == message["value"] / 1000
assert sensor.generic_asset.get_attribute("soc_udi_event_id") == 205
def test_invalid_resolution_str(client):
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
query_string = message_for_get_meter_data()
query_string["resolution"] = "15M" # invalid
get_meter_data_response = client.get(
url_for("flexmeasures_api_v1.get_meter_data"),
query_string=query_string,
headers={"Authorization": auth_token},
)
print("Server responded with:\n%s" % get_meter_data_response.json)
assert get_meter_data_response.status_code == 400
assert get_meter_data_response.json["type"] == "GetMeterDataResponse"
assert get_meter_data_response.json["status"] == "INVALID_RESOLUTION"
def test_invalid_connection_in_get_request(client):
get_meter_data_response = client.get(
url_for("flexmeasures_api_v1.get_meter_data"),
query_string=message_for_get_meter_data(invalid_connection=True),
headers={
"Authorization": get_auth_token(
client, "*****@*****.**", "testtest"
)
},
)
print("Server responded with:\n%s" % get_meter_data_response.json)
assert get_meter_data_response.status_code == 400
assert get_meter_data_response.json["type"] == "GetMeterDataResponse"
assert get_meter_data_response.json["status"] == invalid_domain()[0]["status"]
def test_post_invalid_sensor_data(client, setup_api_test_data, request_field,
new_value, error_field, error_text):
post_data = make_sensor_data_request_for_gas_sensor()
post_data[request_field] = new_value
# this guy is allowed to post sensorData
auth_token = get_auth_token(client, "*****@*****.**",
"testtest")
response = client.post(
url_for("SensorAPI:post_data"),
json=post_data,
headers={"Authorization": auth_token},
)
print(response.json)
assert response.status_code == 422
assert error_text in response.json["message"]["json"][error_field][0]
def test_get_one_user(client, requesting_user, status_code):
test_user2_id = find_user_by_email("*****@*****.**").id
headers = {"content-type": "application/json"}
if requesting_user:
headers["Authorization"] = get_auth_token(client, requesting_user,
"testtest")
get_user_response = client.get(
url_for("UserAPI:get", id=test_user2_id),
headers=headers,
)
print("Server responded with:\n%s" % get_user_response.data)
assert get_user_response.status_code == status_code
if status_code == 200:
assert get_user_response.json["username"] == "Test Prosumer User 2"
def test_no_data(client):
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
get_prognosis_response = client.get(
url_for("flexmeasures_api_v1_1.get_prognosis"),
query_string=message_replace_name_with_ea(
message_for_get_prognosis(no_data=True)),
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
print("Server responded with:\n%s" % get_prognosis_response.json)
assert get_prognosis_response.status_code == 200
assert get_prognosis_response.json["type"] == "GetPrognosisResponse"
assert get_prognosis_response.json["values"] == []
def test_invalid_horizon(client, message):
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
get_prognosis_response = client.get(
url_for("flexmeasures_api_v1_1.get_prognosis"),
query_string=message,
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
print("Server responded with:\n%s" % get_prognosis_response.json)
assert get_prognosis_response.status_code == 400
assert get_prognosis_response.json["type"] == "GetPrognosisResponse"
assert get_prognosis_response.json["status"] == invalid_horizon(
)[0]["status"]
def test_post_weather_data(client, post_message):
"""
Try to post wind speed data as a logged-in test user with the Supplier role, which should succeed.
"""
# post weather data
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
post_weather_data_response = client.post(
url_for("flexmeasures_api_v1_1.post_weather_data"),
json=post_message,
headers={"Authorization": auth_token},
)
print("Server responded with:\n%s" % post_weather_data_response.json)
assert post_weather_data_response.status_code == 200
assert post_weather_data_response.json["type"] == "PostWeatherDataResponse"
def test_delete_an_asset(client, db):
with UserContext("*****@*****.**") as prosumer:
existing_asset_id = prosumer.assets[0].id
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
delete_asset_response = client.delete(
url_for("flexmeasures_api_v2_0.delete_asset", id=existing_asset_id),
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
assert delete_asset_response.status_code == 204
deleted_asset = Asset.query.filter_by(id=existing_asset_id).one_or_none()
assert deleted_asset is None
def test_get_one_user(client):
test_supplier_id = find_user_by_email("*****@*****.**").id
headers = {
"content-type":
"application/json",
"Authorization":
get_auth_token(client, "*****@*****.**", "testtest"),
}
get_user_response = client.get(
url_for("flexmeasures_api_v2_0.get_user", id=test_supplier_id),
headers=headers,
)
print("Server responded with:\n%s" % get_user_response.data)
assert get_user_response.status_code == 200
assert get_user_response.json["username"] == "Test Supplier"
def test_get_device_message_wrong_event_id(client, message):
asset = Asset.query.filter(Asset.name == "Test battery").one_or_none()
message["event"] = message["event"] % (asset.owner_id, asset.id)
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
get_device_message_response = client.get(
url_for("flexmeasures_api_v1_3.get_device_message"),
query_string=message,
headers={"content-type": "application/json", "Authorization": auth_token},
)
print("Server responded with:\n%s" % get_device_message_response.json)
assert get_device_message_response.status_code == 400
assert get_device_message_response.json["type"] == "GetDeviceMessageResponse"
assert (
get_device_message_response.json["status"]
== unrecognized_event(9999, "soc")[0]["status"]
)
def test_delete_an_asset(client, setup_api_fresh_test_data):
with AccountContext("Test Prosumer Account") as prosumer:
existing_asset_id = prosumer.generic_assets[0].id
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
delete_asset_response = client.delete(
url_for("AssetAPI:delete", id=existing_asset_id),
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
assert delete_asset_response.status_code == 204
deleted_asset = GenericAsset.query.filter_by(
id=existing_asset_id).one_or_none()
assert deleted_asset is None
def test_api_task_run_post_unauthorized_wrong_role(client):
url = url_for("flexmeasures_api_ops.post_task_run")
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
post_req_params = dict(query_string={"name": "my-task"},
headers={"Authorization": auth_token})
task_run = client.post(url, **post_req_params)
assert task_run.status_code == FORBIDDEN_STATUS_CODE
assert bytes(FORBIDDEN_ERROR_CLASS, encoding="utf") in task_run.data
# While we are on it, test if the unauth handler correctly returns json if we set the content-type
post_req_params.update(headers={
"Authorization": auth_token,
"Content-Type": "application/json"
})
task_run = client.post(url, **post_req_params)
assert task_run.status_code == FORBIDDEN_STATUS_CODE
assert task_run.json["status"] == FORBIDDEN_ERROR_STATUS
def test_get_device_message(client, message):
sensor = Sensor.query.filter(Sensor.name == "Test battery").one_or_none()
message["event"] = message["event"] % sensor.id
auth_token = get_auth_token(client, "*****@*****.**",
"testtest")
get_device_message_response = client.get(
url_for("flexmeasures_api_v1_2.get_device_message"),
query_string=message,
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
print("Server responded with:\n%s" % get_device_message_response.json)
assert get_device_message_response.status_code == 200
assert get_device_message_response.json[
"type"] == "GetDeviceMessageResponse"
assert len(get_device_message_response.json["values"]) == 192
# Test that a shorter planning horizon yields a shorter result
# Note that the scheduler might give a different result, because it doesn't look as far ahead
message["duration"] = "PT6H"
get_device_message_response_short = client.get(
url_for("flexmeasures_api_v1_2.get_device_message"),
query_string=message,
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
print("Server responded with:\n%s" %
get_device_message_response_short.json)
assert get_device_message_response_short.status_code == 200
assert len(get_device_message_response_short.json["values"]) == 24
# Test that a much longer planning horizon yields the same result (when there are only 2 days of prices)
message["duration"] = "PT1000H"
get_device_message_response_long = client.get(
url_for("flexmeasures_api_v1_2.get_device_message"),
query_string=message,
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
assert (get_device_message_response_long.json["values"][0:192] ==
get_device_message_response.json["values"])
def test_get_device_message(client, message):
asset = Asset.query.filter(Asset.name == "Test battery").one_or_none()
message["event"] = message["event"] % (asset.owner_id, asset.id)
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
get_device_message_response = client.get(
url_for("flexmeasures_api_v1_2.get_device_message"),
query_string=message,
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
print("Server responded with:\n%s" % get_device_message_response.json)
assert get_device_message_response.status_code == 200
assert get_device_message_response.json[
"type"] == "GetDeviceMessageResponse"
assert len(get_device_message_response.json["values"]) == 192
# Test that a shorter planning horizon yields the same result
message["duration"] = "PT6H"
get_device_message_response_short = client.get(
url_for("flexmeasures_api_v1_2.get_device_message"),
query_string=message,
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
print("Server responded with:\n%s" %
get_device_message_response_short.json)
assert get_device_message_response_short.status_code == 200
assert (get_device_message_response_short.json["values"] ==
get_device_message_response.json["values"][0:24])
# Test that a much longer planning horizon yields the same result (when there are only 2 days of prices)
message["duration"] = "PT1000H"
get_device_message_response_long = client.get(
url_for("flexmeasures_api_v1_2.get_device_message"),
query_string=message,
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
assert (get_device_message_response_long.json["values"][0:192] ==
get_device_message_response.json["values"])
def test_post_price_data_2_0(
fresh_db,
setup_roles_users_fresh_db,
setup_markets_fresh_db,
clean_redis,
app,
post_message,
):
"""
Try to post price data as a logged-in test user, which should succeed.
"""
db = fresh_db
# call with client whose context ends, so that we can test for,
# after-effects in the database after teardown committed.
with app.test_client() as client:
# post price data
auth_token = get_auth_token(client, "*****@*****.**",
"testtest")
post_price_data_response = client.post(
url_for("flexmeasures_api_v2_0.post_price_data"),
json=post_message,
headers={"Authorization": auth_token},
)
print("Server responded with:\n%s" % post_price_data_response.json)
assert post_price_data_response.status_code == 200
assert post_price_data_response.json["type"] == "PostPriceDataResponse"
verify_sensor_data_in_db(post_message,
post_message["values"],
db,
entity_type="market",
fm_scheme="fm1")
# look for Forecasting jobs in queue
assert (len(app.queues["forecasting"]) == 2
) # only one market is affected, but two horizons
horizons = [timedelta(hours=24), timedelta(hours=48)]
jobs = sorted(app.queues["forecasting"].jobs,
key=lambda x: x.kwargs["horizon"])
market = SensorField("market",
fm_scheme="fm1").deserialize(post_message["market"])
for job, horizon in zip(jobs, horizons):
assert job.kwargs["horizon"] == horizon
assert job.kwargs["start"] == parse_date(
post_message["start"]) + horizon
assert job.kwargs["sensor_id"] == market.id
def test_get_device_message_mistyped_duration(client):
auth_token = get_auth_token(client, "*****@*****.**", "testtest")
message = message_for_get_device_message()
asset = Asset.query.filter(Asset.name == "Test battery").one_or_none()
message["event"] = message["event"] % (asset.owner_id, asset.id)
message["duration"] = "PTT6H"
get_device_message_response = client.get(
url_for("flexmeasures_api_v1_2.get_device_message"),
query_string=message,
headers={
"content-type": "application/json",
"Authorization": auth_token
},
)
print("Server responded with:\n%s" % get_device_message_response.json)
assert get_device_message_response.status_code == 422
assert (
"Cannot parse PTT6H as ISO8601 duration"
in get_device_message_response.json["args_and_json"]["duration"][0])
