def new_user(
username: str, email: str, roles: List[str], timezone: str = "Europe/Amsterdam"
):
"""
The `users create` task from Flask Security Too is too simple for us.
Use this to add email, timezone and roles.
"""
try:
pytz.timezone(timezone)
except pytz.UnknownTimeZoneError:
print("Timezone %s is unkown!" % timezone)
return
pwd1 = getpass.getpass(prompt="Please enter the password:"******"Please repeat the password:"******"Passwords do not match!")
return
create_user(
username=username,
email=email,
password=hash_password(pwd1),
timezone=timezone,
user_roles=roles,
check_deliverability=False,
)
app.db.session.commit()
def setup_ui_test_data(
db,
setup_accounts,
setup_roles_users,
setup_markets,
setup_sources,
setup_asset_types,
):
"""
Create another prosumer, without data, and an admin
Also, a weather sensor (and sensor type).
TODO: review if any of these are really needed (might be covered now by main conftest)
"""
print("Setting up data for UI tests on %s" % db.engine)
create_user(
username="******",
email="*****@*****.**",
password="******",
account_name=setup_accounts["Prosumer"].name,
user_roles=dict(name="admin", description="A site admin."),
)
test_user_ui = create_user(
username="******",
email="*****@*****.**",
password="******",
account_name=setup_accounts["Prosumer"].name,
)
asset = Asset(
name="solar pane 1",
display_name="Solar Pane 1",
asset_type_name="solar",
unit="MW",
capacity_in_mw=10,
latitude=10,
longitude=100,
min_soc_in_mwh=0,
max_soc_in_mwh=0,
soc_in_mwh=0,
)
db.session.add(asset)
asset.owner = test_user_ui
# Create 1 weather sensor
test_sensor_type = WeatherSensorType(name="irradiance")
db.session.add(test_sensor_type)
sensor = WeatherSensor(
name="irradiance_sensor",
weather_sensor_type_name="irradiance",
latitude=33.4843866,
longitude=126,
unit="kW/m²",
)
db.session.add(sensor)
print("Done setting up data for UI tests")
def create_roles_users(db, test_accounts) -> Dict[str, User]:
"""Create a minimal set of roles and users"""
new_users: List[User] = []
# Two Prosumer users
new_users.append(
create_user(
username="******",
email="*****@*****.**",
account_name=test_accounts["Prosumer"].name,
password="******",
# TODO: test some normal user roles later in our auth progress
# user_roles=dict(name="", description=""),
)
)
new_users.append(
create_user(
username="******",
email="*****@*****.**",
account_name=test_accounts["Prosumer"].name,
password="******",
user_roles=dict(name="account-admin", description="Admin for this account"),
)
)
# A user on an account without any special rights
new_users.append(
create_user(
username="******",
email="*****@*****.**",
account_name=test_accounts["Dummy"].name,
password="******",
)
)
# A supplier user
new_users.append(
create_user(
username="******",
email="*****@*****.**",
account_name=test_accounts["Supplier"].name,
password="******",
)
)
# One platform admin
new_users.append(
create_user(
username="******",
email="*****@*****.**",
account_name=test_accounts[
"Dummy"
].name, # the account does not give rights
password="******",
user_roles=dict(
name=ADMIN_ROLE, description="A user who can do everything."
),
)
)
return {user.username: user for user in new_users}
def setup_roles_users(db):
"""Create a minimal set of roles and users"""
create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
user_roles=dict(name="Prosumer", description="A Prosumer with a few assets."),
)
create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
user_roles=dict(name="Supplier", description="A Supplier trading on markets."),
)
def setup_ui_test_data(db):
"""
Create another prosumer, without data, and an admin
Also, a weather sensor (and sensor type).
"""
print("Setting up data for UI tests on %s" % db.engine)
create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
user_roles=dict(name="admin", description="A site admin."),
)
test_prosumer2 = create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
user_roles=dict(name="Prosumer",
description="A Prosumer with one asset but no data."),
)
asset = Asset(
name="solar pane 1",
display_name="Solar Pane 1",
asset_type_name="solar",
unit="MW",
capacity_in_mw=10,
latitude=10,
longitude=100,
min_soc_in_mwh=0,
max_soc_in_mwh=0,
soc_in_mwh=0,
)
db.session.add(asset)
asset.owner = test_prosumer2
# Create 1 weather sensor
test_sensor_type = WeatherSensorType(name="radiation")
db.session.add(test_sensor_type)
sensor = WeatherSensor(
name="radiation_sensor",
weather_sensor_type_name="radiation",
latitude=33.4843866,
longitude=126,
unit="kW/m²",
)
db.session.add(sensor)
print("Done setting up data for UI tests")
def set_owner(
asset_form: NewAssetForm,
create_if_not_exists: bool = False
) -> Tuple[Optional[User], Optional[str]]:
"""Set a user as owner for the to-be-created asset.
Return the user (if available and an error message)"""
owner = None
owner_error = None
if asset_form.owner.data == -1 and create_if_not_exists:
new_owner_email = request.form.get("new_owner_email", "")
if new_owner_email.startswith("--Type"):
owner_error = "Either pick an existing user as owner or enter an email address for the new owner."
else:
try:
owner = create_user(email=new_owner_email,
user_roles=["Prosumer"])
except InvalidFlexMeasuresUser as ibe:
owner_error = str(ibe)
except IntegrityError as ie:
owner_error = "New owner cannot be created: %s" % str(ie)
if owner:
asset_form.owner.choices.append((owner.id, owner.username))
else:
owner = User.query.filter_by(
id=int(asset_form.owner.data)).one_or_none()
if owner:
asset_form.owner.data = owner.id
else:
current_app.logger.error(owner_error)
return owner, owner_error
def test_create_invalid_user(fresh_db, setup_accounts_fresh_db,
setup_roles_users_fresh_db, app):
"""A few invalid attempts to create a user"""
with pytest.raises(InvalidFlexMeasuresUser) as exc_info:
create_user(password="******")
assert "No email" in str(exc_info.value)
with pytest.raises(InvalidFlexMeasuresUser) as exc_info:
create_user(
email="test_user_AT_seita.nl",
password="******",
account_name=setup_accounts_fresh_db["Prosumer"].name,
)
assert "not a valid" in str(exc_info.value)
""" # This check is disabled during testing, as testing should work without internet and be fast
with pytest.raises(InvalidFlexMeasuresUser) as exc_info:
create_user(
email="*****@*****.**",
password="******",
account_name=setup_account_fresh_db.name,
)
assert "not seem to be deliverable" in str(exc_info.value)
"""
with pytest.raises(InvalidFlexMeasuresUser) as exc_info:
create_user(
email="*****@*****.**",
password="******",
account_name=setup_accounts_fresh_db["Prosumer"].name,
)
assert "already exists" in str(exc_info.value)
with pytest.raises(InvalidFlexMeasuresUser) as exc_info:
create_user(
email="*****@*****.**",
username="******",
password="******",
account_name=setup_accounts_fresh_db["Prosumer"].name,
)
assert "already exists" in str(exc_info.value)
with pytest.raises(InvalidFlexMeasuresUser) as exc_info:
create_user(
email="*****@*****.**",
username="******",
password="******",
)
assert "without knowing the name of the account" in str(exc_info.value)
def test_create_user(app):
"""Create a user"""
num_users = User.query.count()
user = create_user(
email="*****@*****.**",
password=hash_password("testtest"),
user_roles=["Prosumer"],
)
assert User.query.count() == num_users + 1
assert user.email == "*****@*****.**"
assert user.username == "new_prosumer"
assert user.roles == [Role.query.filter_by(name="Prosumer").one_or_none()]
assert DataSource.query.filter_by(user_id=user.id).one_or_none()
assert DataSource.query.filter_by(name=user.username).one_or_none()
def test_create_user(fresh_db, setup_accounts_fresh_db,
setup_roles_users_fresh_db, app):
"""Create a user"""
num_users = User.query.count()
user = create_user(
email="*****@*****.**",
password="******",
account_name=setup_accounts_fresh_db["Prosumer"].name,
user_roles=["SomeRole"],
)
assert User.query.count() == num_users + 1
assert user.email == "*****@*****.**"
assert user.username == "new_user"
assert user.account.name == "Test Prosumer Account"
assert user.roles == [Role.query.filter_by(name="SomeRole").one_or_none()]
assert DataSource.query.filter_by(user_id=user.id).one_or_none()
assert DataSource.query.filter_by(name=user.username).one_or_none()
def test_create_invalid_user(app):
"""A few invalid attempts to create a user"""
with pytest.raises(InvalidFlexMeasuresUser) as exc_info:
create_user(password=hash_password("testtest"), user_roles=["Prosumer"])
assert "No email" in str(exc_info.value)
with pytest.raises(InvalidFlexMeasuresUser) as exc_info:
create_user(
email="test_prosumer_AT_seita.nl",
password=hash_password("testtest"),
user_roles=["Prosumer"],
)
assert "not a valid" in str(exc_info.value)
""" # This check is disabled during testing, as testing should work without internet and be fast
with pytest.raises(InvalidFlexMeasuresUser) as exc_info:
create_user(
email="*****@*****.**",
password=hash_password("testtest"),
user_roles=["Prosumer"],
)
assert "not seem to be deliverable" in str(exc_info.value)
"""
with pytest.raises(InvalidFlexMeasuresUser) as exc_info:
create_user(
email="*****@*****.**",
password=hash_password("testtest"),
user_roles=["Prosumer"],
)
assert "already exists" in str(exc_info.value)
with pytest.raises(InvalidFlexMeasuresUser) as exc_info:
create_user(
email="*****@*****.**",
username="******",
password=hash_password("testtest"),
user_roles=["Prosumer"],
)
assert "already exists" in str(exc_info.value)
def setup_api_test_data(db):
"""
Set up data for API v1 tests.
"""
print("Setting up data for API v1 tests on %s" % db.engine)
from flexmeasures.data.models.user import User, Role
from flexmeasures.data.models.assets import Asset, AssetType, Power
from flexmeasures.data.models.data_sources import DataSource
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
# Create an anonymous user
create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
user_roles=[
"Prosumer",
dict(name="anonymous", description="Anonymous test user"),
],
)
# Create 1 test asset for the anonymous user
test_prosumer = user_datastore.find_user(email="*****@*****.**")
test_asset_type = AssetType(name="test-type")
db.session.add(test_asset_type)
asset_names = ["CS 0"]
assets: List[Asset] = []
for asset_name in asset_names:
asset = Asset(
name=asset_name,
asset_type_name="test-type",
event_resolution=timedelta(minutes=15),
capacity_in_mw=1,
latitude=100,
longitude=100,
unit="MW",
)
asset.owner = test_prosumer
assets.append(asset)
db.session.add(asset)
# Create a test user without a USEF role
create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
)
# Create 5 test assets for the test_prosumer user
test_prosumer = user_datastore.find_user(email="*****@*****.**")
asset_names = ["CS 1", "CS 2", "CS 3", "CS 4", "CS 5"]
assets: List[Asset] = []
for asset_name in asset_names:
asset = Asset(
name=asset_name,
asset_type_name="test-type",
event_resolution=timedelta(minutes=15),
capacity_in_mw=1,
latitude=100,
longitude=100,
unit="MW",
)
asset.owner = test_prosumer
if asset_name == "CS 4":
asset.event_resolution = timedelta(hours=1)
assets.append(asset)
db.session.add(asset)
# Add power forecasts to one of the assets, for two sources
cs_5 = Asset.query.filter(Asset.name == "CS 5").one_or_none()
test_supplier = user_datastore.find_user(email="*****@*****.**")
prosumer_data_source = DataSource.query.filter(
DataSource.user == test_prosumer).one_or_none()
supplier_data_source = DataSource.query.filter(
DataSource.user == test_supplier).one_or_none()
meter_data = []
for i in range(6):
p_1 = Power(
datetime=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
horizon=timedelta(0),
value=(100.0 + i) * -1,
asset_id=cs_5.id,
data_source_id=prosumer_data_source.id,
)
p_2 = Power(
datetime=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
horizon=timedelta(hours=0),
value=(1000.0 - 10 * i) * -1,
asset_id=cs_5.id,
data_source_id=supplier_data_source.id,
)
meter_data.append(p_1)
meter_data.append(p_2)
db.session.bulk_save_objects(meter_data)
print("Done setting up data for API v1 tests")
def setup_api_test_data(db):
"""
Set up data for API v1.1 tests.
"""
print("Setting up data for API v1.1 tests on %s" % db.engine)
from flexmeasures.data.models.user import User, Role
from flexmeasures.data.models.assets import Asset, AssetType
from flexmeasures.data.models.weather import WeatherSensor, WeatherSensorType
user_datastore = SQLAlchemySessionUserDatastore(db.session, User, Role)
# Create a user without proper registration as a data source
user = user_datastore.create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
)
role = user_datastore.find_role("Prosumer")
user_datastore.add_role_to_user(user, role)
# Create a test user without a USEF role
create_user(
username="******",
email="*****@*****.**",
password=hash_password("testtest"),
)
# Create 3 test assets for the test_prosumer user
test_prosumer = user_datastore.find_user(email="*****@*****.**")
test_asset_type = AssetType(name="test-type")
db.session.add(test_asset_type)
asset_names = ["CS 1", "CS 2", "CS 3"]
assets: List[Asset] = []
for asset_name in asset_names:
asset = Asset(
name=asset_name,
asset_type_name="test-type",
event_resolution=timedelta(minutes=15),
capacity_in_mw=1,
latitude=100,
longitude=100,
unit="MW",
)
asset.owner = test_prosumer
assets.append(asset)
db.session.add(asset)
# Add power forecasts to the assets
cs_1 = Asset.query.filter(Asset.name == "CS 1").one_or_none()
cs_2 = Asset.query.filter(Asset.name == "CS 2").one_or_none()
cs_3 = Asset.query.filter(Asset.name == "CS 3").one_or_none()
data_source = DataSource.query.filter(
DataSource.user == test_prosumer).one_or_none()
power_forecasts = []
for i in range(6):
p_1 = Power(
datetime=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
horizon=timedelta(hours=6),
value=(300 + i) * -1,
asset_id=cs_1.id,
data_source_id=data_source.id,
)
p_2 = Power(
datetime=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
horizon=timedelta(hours=6),
value=(300 - i) * -1,
asset_id=cs_2.id,
data_source_id=data_source.id,
)
p_3 = Power(
datetime=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
horizon=timedelta(hours=6),
value=(0 + i) * -1,
asset_id=cs_3.id,
data_source_id=data_source.id,
)
power_forecasts.append(p_1)
power_forecasts.append(p_2)
power_forecasts.append(p_3)
db.session.bulk_save_objects(power_forecasts)
# Create 2 weather sensors
test_sensor_type = WeatherSensorType(name="wind_speed")
db.session.add(test_sensor_type)
sensor = WeatherSensor(
name="wind_speed_sensor",
weather_sensor_type_name="wind_speed",
event_resolution=timedelta(minutes=5),
latitude=33.4843866,
longitude=126,
unit="m/s",
)
db.session.add(sensor)
test_sensor_type = WeatherSensorType(name="temperature")
db.session.add(test_sensor_type)
sensor = WeatherSensor(
name="temperature_sensor",
weather_sensor_type_name="temperature",
event_resolution=timedelta(minutes=5),
latitude=33.4843866,
longitude=126,
unit="°C",
)
db.session.add(sensor)
print("Done setting up data for API v1.1 tests")
def setup_api_test_data(db, setup_accounts, setup_roles_users,
add_market_prices):
"""
Set up data for API v1 tests.
"""
print("Setting up data for API v1 tests on %s" % db.engine)
from flexmeasures.data.models.assets import Asset, AssetType
from flexmeasures.data.models.data_sources import DataSource
# Create an anonymous user TODO: used for demo purposes, maybe "demo-user" would be a better name
test_anonymous_user = create_user(
username="******",
email="*****@*****.**",
password="******",
account_name=setup_accounts["Dummy"].name,
user_roles=[
dict(name="anonymous", description="Anonymous test user"),
],
)
# Create 1 test asset for the anonymous user
test_asset_type = AssetType(name="test-type")
db.session.add(test_asset_type)
asset_names = ["CS 0"]
assets: List[Asset] = []
for asset_name in asset_names:
asset = Asset(
name=asset_name,
owner_id=test_anonymous_user.id,
asset_type_name="test-type",
event_resolution=timedelta(minutes=15),
capacity_in_mw=1,
latitude=100,
longitude=100,
unit="MW",
)
assets.append(asset)
db.session.add(asset)
# Create 5 test assets for the test user
test_user = setup_roles_users["Test Prosumer User"]
asset_names = ["CS 1", "CS 2", "CS 3", "CS 4", "CS 5"]
assets: List[Asset] = []
for asset_name in asset_names:
asset = Asset(
name=asset_name,
owner_id=test_user.id,
asset_type_name="test-type",
event_resolution=timedelta(minutes=15)
if not asset_name == "CS 4" else timedelta(hours=1),
capacity_in_mw=1,
latitude=100,
longitude=100,
unit="MW",
)
assets.append(asset)
db.session.add(asset)
# Add power forecasts to one of the assets, for two sources
cs_5 = Asset.query.filter(Asset.name == "CS 5").one_or_none()
user1_data_source = DataSource.query.filter(
DataSource.user == test_user).one_or_none()
test_user_2 = setup_roles_users["Test Prosumer User 2"]
user2_data_source = DataSource.query.filter(
DataSource.user == test_user_2).one_or_none()
user1_beliefs = [
TimedBelief(
event_start=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
belief_horizon=timedelta(0),
event_value=(100.0 + i) * -1,
sensor=cs_5.corresponding_sensor,
source=user1_data_source,
) for i in range(6)
]
user2_beliefs = [
TimedBelief(
event_start=isodate.parse_datetime("2015-01-01T00:00:00Z") +
timedelta(minutes=15 * i),
belief_horizon=timedelta(hours=0),
event_value=(1000.0 - 10 * i) * -1,
sensor=cs_5.corresponding_sensor,
source=user2_data_source,
) for i in range(6)
]
db.session.add_all(user1_beliefs + user2_beliefs)
print("Done setting up data for API v1 tests")
