def test_GIVEN_model_run_has_parameters_WHEN_get_model_run_by_id_THEN_model_run_has_parameter_values_loaded(self):
# Add a user and give them a model
user = self.login()
model_run = self.create_run_model(0, "MR1", user)
with session_scope(Session) as session:
# Add parameter value
parameter_value = ParameterValue()
parameter_value.parameter_id = 1
parameter_value.set_value_from_python(123)
parameter = Parameter()
parameter.name = "Param"
parameter.parameter_values = [parameter_value]
# Give them a model
model_run = session.query(ModelRun).filter(ModelRun.id == model_run.id).one()
model_run.parameter_values = [parameter_value]
session.add(model_run)
with session_scope(Session) as session:
model_run_id = session.query(ModelRun).filter(ModelRun.name == model_run.name).one().id
# Get the users model runs
model_run_returned = self.model_run_service.get_model_by_id(user, model_run_id)
pv = model_run_returned.parameter_values[0]
assert_that(pv.value, is_('123'))
assert_that(pv.parameter.name, is_("Param"))
def test_GIVEN_full_model_WHEN_delete_THEN_model_is_deleted(self):
user = self.login('')
self.create_model_run_ready_for_submit()
with session_scope(Session) as session:
dataset_count = session.query(Dataset).count()
model = self.model_run_service.get_models_for_user(user)[0]
dataset = Dataset()
dataset.model_run_id = model.id
session.add(dataset)
region_count = session.query(LandCoverAction).count()
session.add(LandCoverAction(model_run_id=model.id))
model_not_to_delete = self.create_run_model(0, "test", user, constants.MODEL_RUN_STATUS_PUBLISHED)
self.job_runner_client.delete = Mock()
self.model_run_service.delete_run_model(model.id, user)
with session_scope(Session) as session:
count = session.query(ModelRun).filter(ModelRun.id == model.id).count()
assert_that(count, is_(0), 'Count(Model)')
with session_scope(Session) as session:
count = session.query(ModelRun).filter(ModelRun.id == model_not_to_delete.id).count()
assert_that(count, is_(1), 'Count(Model)')
with session_scope(Session) as session:
count = session.query(Dataset).count()
assert_that(count, is_(dataset_count), 'Count(Datasets)is same as before creating model')
with session_scope(Session) as session:
count = session.query(LandCoverAction).count()
assert_that(count, is_(region_count), 'Count(LandCoverAction)is same as before creating model')
def test_GIVEN_land_cover_actions_WHEN_post_THEN_land_cover_action_saved_in_database(self):
with session_scope() as session:
model_run = self.model_run_service._get_model_run_being_created(session, self.user)
dds = model_run.driving_dataset
categories = LandCoverService().get_land_cover_categories(dds.id)
# Need to know the region IDs
self.app.post(
url(controller='model_run', action='land_cover'),
params={
'submit': u'Next',
'action_1_region': str(categories[0].regions[0].id),
'action_1_value': u'8',
'action_1_order': u'1',
'action_2_region': str(categories[0].regions[0].id),
'action_2_value': u'7',
'action_2_order': u'2'
})
with session_scope() as session:
model_run = self.model_run_service._get_model_run_being_created(session, self.user)
actions = model_run.land_cover_actions
assert_that(len(actions), is_(2))
for action in actions:
if action.value_id == 8:
assert_that(action.order, is_(1))
elif action.value_id == 7:
assert_that(action.order, is_(2))
else:
assert False
def test_GIVEN_model_with_land_cover_actions_WHEN_duplicate_THEN_model_is_duplicated(self):
# Add a user who doesn't have any model runs
user = self.login()
model = self.create_run_model(10, "test", user)
model = self.model_run_service.get_model_by_id(user, model.id)
with session_scope() as session:
region1 = LandCoverRegion()
region2 = LandCoverRegion()
session.add(region1)
session.add(region2)
session.add(LandCoverAction(model_run_id=model.id, order=1, value_id=1, region=region1))
session.add(LandCoverAction(model_run_id=model.id, order=2, value_id=2, region=region2))
self.job_runner_client.duplicate = Mock()
self.model_run_service.duplicate_run_model(model.id, user)
assert_that(self.job_runner_client.duplicate.called, is_(False), "Job runner not called")
model_run = self.model_run_service.get_model_being_created_with_non_default_parameter_values(user)
with session_scope() as session:
regions = session.query(LandCoverAction).filter(LandCoverAction.model_run_id == model_run.id).all()
assert_that(len(regions), is_(2), "regions")
assert_that(regions[0].value_id, is_(1), "value id")
assert_that(regions[0].order, is_(1), "order id")
assert_that(regions[0].region_id, is_(region1.id), "region id")
assert_that(regions[1].value_id, is_(2), "value id")
assert_that(regions[1].order, is_(2), "order id")
assert_that(regions[1].region_id, is_(region2.id), "region id")
def test_GIVEN_one_pending_job_in_the_database_which_has_completed_WHEN_update_dap_client_not_available_THEN_model_run_status_is_not_updated(self):
self.dap_client_factory.get_dap_client = Mock(side_effect=DapClientException("trouble"))
self.create_model_run_ready_for_submit()
model_run_service = ModelRunService()
model_run = model_run_service.get_model_run_being_created_or_default(self.user)
with session_scope(Session) as session:
model_run.change_status(session, constants.MODEL_RUN_STATUS_RUNNING)
self.running_job_client.get_run_model_statuses = Mock(
return_value=[{'id': model_run.id,
'status': constants.MODEL_RUN_STATUS_COMPLETED,
'error_message': ''
}])
self.job_status_updater.update()
model_run = model_run_service.get_model_by_id(self.user, model_run.id)
assert_that(model_run.status.name, is_(constants.MODEL_RUN_STATUS_RUNNING), "model status")
with session_scope() as session:
datasets = session.query(Dataset)\
.filter(Dataset.model_run_id == model_run.id)\
.filter(Dataset.is_input == False)\
.all()
assert_that(len(datasets), is_(0), "Number of output datasets")
datasets = session.query(Dataset)\
.filter(Dataset.model_run_id == model_run.id)\
.filter(Dataset.is_input == True)\
.all()
assert_that(len(datasets), is_(0), "Number of input datasets")
def test_GIVEN_no_values_WHEN_add_to_new_dataset_THEN_nothing_changes(self):
with session_scope() as session:
driving_dataset = self.create_driving_dataset(session)
#WHEN
self.land_cover_service.update_regions_and_categories_in_session(session, driving_dataset, [])
with session_scope() as session:
regions = LandCoverService().get_land_cover_regions(driving_dataset.id)
assert_that(len(regions), is_(0), "number of regions")
def test_GIVEN_valid_parameters_WHEN_submitted_THEN_request_in_database(self):
with session_scope(Session) as session:
session.query(AccountRequest).delete()
response = self.app.post(
url=url(controller='request_account', action='request'),
params=self.account_request
)
with session_scope(Session) as session:
account_requests = session.query(AccountRequest).all()
assert_that(len(account_requests), is_(1))
assert_that(account_requests[0].first_name, is_('name'))
def test_GIVEN_one_value_WHEN_add_to_existing_empty_dataset_THEN_value_is_added(self):
expected_names = ["name"]
expected_categories = ["category"]
expected_paths = ["expected_paths"]
expected_ids = [""]
values = self.create_values(expected_categories, expected_names, expected_paths, expected_ids)
with session_scope() as session:
driving_dataset = self.create_driving_dataset(session)
with session_scope() as session:
driving_dataset = session.query(DrivingDataset).get(driving_dataset.id)
self.land_cover_service.update_regions_and_categories_in_session(session, driving_dataset, values)
self.assert_regions_are_correct(driving_dataset, expected_categories, expected_names, expected_paths, values)
def test_WHEN_get_user_model_runs_THEN_list_ordered_by_date_created_newest_first(self):
with session_scope(Session) as session:
# First add user
user1 = User()
user1.name = 'user1'
session.add(user1)
session.commit()
# Create three published models not in datetime order
model_run1 = ModelRun()
model_run1.user_id = user1.id
model_run1.name = "MR1"
model_run1.date_created = datetime(2013, 12, 7, 17, 15, 30)
session.add(model_run1)
session.commit()
model_run2 = ModelRun()
model_run2.user_id = user1.id
model_run2.name = "MR2"
model_run2.date_created = datetime(2014, 6, 9, 12, 30, 24)
session.add(model_run2)
session.commit()
model_run3 = ModelRun()
model_run3.user_id = user1.id
model_run3.name = "MR3"
model_run3.date_created = datetime(2014, 6, 9, 11, 39, 30)
session.add_all([model_run1, model_run2, model_run3])
model_runs = self.model_run_service.get_models_for_user(user1)
assert_that(model_runs[0].name, is_("MR2"))
assert_that(model_runs[1].name, is_("MR3"))
assert_that(model_runs[2].name, is_("MR1"))
def test_WHEN_get_published_model_runs_THEN_list_ordered_by_date_created_newest_first(self):
with session_scope(Session) as session:
# Create three published models not in datetime order
model_run1 = ModelRun()
model_run1.name = "MR1"
model_run1.date_created = datetime(2013, 12, 7, 17, 15, 30)
model_run1.status = self._status(constants.MODEL_RUN_STATUS_PUBLISHED)
session.add(model_run1)
session.commit()
model_run2 = ModelRun()
model_run2.name = "MR2"
model_run2.date_created = datetime(2014, 6, 9, 12, 30, 24)
model_run2.status = self._status(constants.MODEL_RUN_STATUS_PUBLIC)
session.add(model_run2)
session.commit()
model_run3 = ModelRun()
model_run3.name = "MR3"
model_run3.status = self._status(constants.MODEL_RUN_STATUS_PUBLISHED)
model_run3.date_created = datetime(2014, 6, 9, 11, 39, 30)
session.add(model_run3)
session.commit()
model_runs = self.model_run_service.get_published_models()
assert_that(model_runs[0].name, is_("MR2"))
assert_that(model_runs[1].name, is_("MR3"))
assert_that(model_runs[2].name, is_("MR1"))
def test_GIVEN_model_with_parameters_WHEN_get_parameter_value_THEN_parameter_value_returned(self):
with session_scope(Session) as session:
user = User()
user.name = 'user1'
session.add(user)
session.commit()
param = session.query(Parameter).first()
param_id = param.id
param_name = param.name
param_namelist = param.namelist.name
model_run = ModelRun()
model_run.name = "MR1"
model_run.user_id = user.id
model_run.status = self._status(constants.MODEL_RUN_STATUS_CREATED)
session.add(model_run)
session.commit()
parameter1 = ParameterValue()
parameter1.parameter_id = param_id
parameter1.set_value_from_python("param1 value")
parameter1.model_run_id = model_run.id
session.add(parameter1)
model_run_returned = self.model_run_service.get_model_being_created_with_non_default_parameter_values(user)
param_value_returned = model_run_returned.get_python_parameter_value([param_namelist, param_name])
assert_that(param_value_returned, is_("param1 value"))
def test_GIVEN_multiple_land_cover_actions_saved_out_of_order_WHEN_get_THEN_order_rendered_correctly(self):
with session_scope() as session:
model_run = self.model_run_service._get_model_run_being_created(session, self.user)
dds = model_run.driving_dataset
session.add_all(self.generate_categories_with_regions(dds))
action = LandCoverAction()
action.model_run = model_run
action.region_id = 1 # Thames
action.value_id = 5 # Shrub
action.order = 5
session.add(action)
session.commit()
action2 = LandCoverAction()
action2.model_run = model_run
action2.region_id = 2 # Itchen
action2.value_id = 1 # Broad-leaved Tree
action2.order = 1
session.add(action2)
session.commit()
action3 = LandCoverAction()
action3.model_run = model_run
action3.region_id = 3 # Hampshire
action3.value_id = 6 # Urban
action3.order = 2
session.add(action3)
session.commit()
response = self.app.get(url(controller='model_run', action='land_cover'))
order1 = response.normal_body.index("Change <b>Itchen (Rivers)</b> to <b>Broad-leaved Tree</b>")
order2 = response.normal_body.index("Change <b>Hampshire (Counties)</b> to <b>Urban</b>")
order5 = response.normal_body.index("Change <b>Thames (Rivers)</b> to <b>Shrub</b>")
assert (order1 < order2 < order5)
def test_GIVEN_valid_data_with_masks_WHEN_create_new_THEN_masks_are_created(self):
self.login(access_level=constants.USER_ACCESS_LEVEL_ADMIN)
valid_params = self.create_valid_post_values()
valid_params["mask_count"] = 1
valid_params["region-0.id"] = ""
valid_params["region-0.name"] = "name0"
valid_params["region-0.category"] = "category0"
valid_params["region-0.path"] = "path0"
response = self.app.post(
url=url(controller='driving_data', action='edit'),
params=valid_params,
expect_errors=True
)
assert_that(response.status_code, is_(302), "no redirect after successful post got %s" % response.normal_body)
with session_scope() as session:
driving_dataset_id = session\
.query(DrivingDataset)\
.filter(DrivingDataset.name == self.new_driving_dataset.name)\
.one().id
regions = LandCoverService().get_land_cover_regions(driving_dataset_id)
assert_that(len(regions), is_(1), "number of regions")
assert_that(regions[0].name, is_(valid_params["region-0.name"]), "name of region")
assert_that(regions[0].category.name, is_(valid_params["region-0.category"]), "category of region")
assert_that(regions[0].mask_file, is_(valid_params["region-0.path"]), "path of region")
def setUp(self):
super(TestDrivingDataEditOrAdd, self).setUp()
self.clean_database()
self.extra_parameter = "an extra parameter value"
self.driving_dataset_jules_params = DrivingDatasetJulesParams(
dataperiod=1800,
drive_file="jules_param_drive_file",
drive_var=['drive var 1', 'drive var 2'],
var_names=['name1', 'name2'],
var_templates=['template1', 'template2'],
var_interps=['interp1', 'interp2'],
nx='jules_param_nx',
ny='jules_param_ny',
x_dim_name='jules_param_x_dim_name',
y_dim_name='jules_param_y_dim_name',
time_dim_name='jules_param_time_dim_name',
latlon_file='latlon_file',
latlon_lat_name='latlon_lat_name',
latlon_lon_name='latlon_lon_name',
land_frac_file='land_frac_file',
land_frac_frac_name='land_frac_frac_name',
frac_file='frac_file_file_name',
frac_frac_dim_name='frac_frac_dim_name',
frac_type_dim_name='frac_type_dim_name',
soil_props_file='soil_props_file',
extra_parameters={1: self.extra_parameter})
with session_scope() as session:
self.driving_dataset = self.create_driving_dataset(
session,
self.driving_dataset_jules_params)
def setUp(self):
super(TestModelRunOutput, self).setUp()
self.clean_database()
self.user = self.login()
self.valid_params = {
'submit': u'Next',
'ov_select_1': 1,
'ov_yearly_1': 1,
'ov_monthly_1': 1,
'ov_select_2': 1,
'ov_hourly_2': 1,
'ov_daily_2': 1,
'ov_select_3': 1,
'ov_monthly_3': 1
}
self.model_run_service = ModelRunService()
param_run_start = self.model_run_service.get_parameter_by_constant(JULES_PARAM_RUN_START)
param_run_end = self.model_run_service.get_parameter_by_constant(JULES_PARAM_RUN_END)
with session_scope(Session) as session:
self.model_run = self.model_run_service._create_new_model_run(session, self.user)
self.model_run.name = "MR1"
pv_run_start = ParameterValue()
pv_run_start.parameter_id = param_run_start.id
pv_run_start.value = "'1901-01-01 00:00:00'"
pv_run_end = ParameterValue()
pv_run_end.parameter_id = param_run_end.id
pv_run_end.value = "'1902-01-01 00:00:00'"
self.model_run.parameter_values = [pv_run_start, pv_run_end]
session.add(self.model_run)
def test_GIVEN_valid_data_with_extra_parameters_WHEN_create_new_THEN_extra_parameters_are_created(self):
self.login(access_level=constants.USER_ACCESS_LEVEL_ADMIN)
valid_params = self.create_valid_post_values()
valid_params["params_count"] = 1
parameter_id = 23
valid_params["param-0.id"] = str(parameter_id)
valid_params["param-0.value"] = "value"
response = self.app.post(
url=url(controller='driving_data', action='edit'),
params=valid_params,
expect_errors=True
)
assert_that(response.status_code, is_(302), "no redirect after successful post got %s" % response.normal_body)
with session_scope(Session) as session:
driving_dataset_id = session\
.query(DrivingDataset)\
.filter(DrivingDataset.name == self.new_driving_dataset.name)\
.one().id
driving_dataset = DatasetService().get_driving_dataset_by_id(driving_dataset_id)
value = [parameter_value for parameter_value in driving_dataset.parameter_values if parameter_value.parameter_id == parameter_id]
assert_that(len(value), is_(1), "number of parameter values")
assert_that(value[0].value, is_(valid_params["param-0.value"]), "parameter value")
def test_GIVEN_categories_have_land_cover_regions_WHEN_get_categories_THEN_category_has_regions_loaded(self):
model_run = self.model_run_service.get_model_being_created_with_non_default_parameter_values(self.user)
with session_scope() as session:
cat1 = LandCoverRegionCategory()
cat1.name = "Countries"
cat1.driving_dataset_id = model_run.driving_dataset_id
region1 = LandCoverRegion()
region1.mask_file = "filepath"
region1.name = "Wales"
region1.category = cat1
cat2 = LandCoverRegionCategory()
cat2.name = "Rivers"
cat2.driving_dataset_id = model_run.driving_dataset_id
region2 = LandCoverRegion()
region2.mask_file = "filepath2"
region2.name = "Thames"
region2.category = cat2
session.add_all([region1, region2])
categories = self.land_cover_service.get_land_cover_categories(model_run.driving_dataset_id)
assert_that(len(categories[0].regions), is_(1))
assert_that(categories[0].regions[0].name, is_("Wales"))
def test_GIVEN_quota_is_not_exceeded_and_email_not_sent_recently_WHEN_update_THEN_email_not_sent_and_marked_in_table(
self
):
model_run = self.create_run_model(
status=constants.MODEL_RUN_STATUS_PENDING, name="test", user=self.user, storage_in_mb=0
)
expected_storage = 10
self.running_job_client.get_run_model_statuses = Mock(
return_value=[
{
"id": model_run.id,
"status": constants.MODEL_RUN_STATUS_RUNNING,
"error_message": "",
"start_time": "2014-07-16 16:33:30",
"end_time": "2014-07-17 12:07:46",
"storage_in_mb": expected_storage,
}
]
)
self.job_status_updater.update()
with session_scope(Session) as session:
email = (
session.query(SystemAlertEmail)
.filter(SystemAlertEmail.code == SystemAlertEmail.GROUP_SPACE_FULL_ALERT)
.one()
)
assert_that(email.last_sent, is_(None), "date email sent")
assert_that(self.email_service.send_email.called, is_(False), "An email has been sent")
def test_GIVEN_land_cover_action_saved_WHEN_view_submit_page_THEN_land_cover_action_shown(self):
self.create_model_run_ready_for_submit()
model_run = self.model_run_service.get_model_being_created_with_non_default_parameter_values(self.user)
with session_scope() as session:
land_cover_cat = LandCoverRegionCategory()
land_cover_cat.driving_dataset_id = model_run.driving_dataset_id
land_cover_cat.name = "Rivers"
land_cover_region = LandCoverRegion()
land_cover_region.name = "Thames"
land_cover_region.category = land_cover_cat
land_cover_action = LandCoverAction()
land_cover_action.model_run = model_run
land_cover_action.value_id = 9
land_cover_action.region = land_cover_region
land_cover_action.order = 1
session.add(land_cover_action)
response = self.app.get(
url(controller='model_run', action='submit'))
assert_that(response.normal_body, contains_string("Change Thames (Rivers) to Ice"))
def create_two_driving_datasets(self):
"""
Creates two driving datasets with datasets, parameter values etc set up
:return: nothing
"""
with session_scope(Session) as session:
self.create_driving_dataset(session)
model_run_service = ModelRunService()
driving2 = DrivingDataset()
driving2.name = "driving2"
driving2.description = "driving 2 description"
driving2.geographic_region = 'Global'
driving2.spatial_resolution = 'Half degree'
driving2.temporal_resolution = '3 Hours'
driving2.boundary_lat_north = 85
driving2.boundary_lat_south = -90
driving2.boundary_lon_west = -180
driving2.boundary_lon_east = 180
driving2.time_start = datetime.datetime(1901, 1, 1, 0, 0, 0)
driving2.time_end = datetime.datetime(2001, 1, 1, 0, 0, 0)
driving2.view_order_index = 200
driving2.usage_order_index = 2
driving2.is_restricted_to_admins = False
location3 = DrivingDatasetLocation()
location3.base_url = "base_url3"
location3.driving_dataset = driving2
val = f90_helper.python_to_f90_str(8 * ["i"])
pv1 = DrivingDatasetParameterValue(model_run_service, driving2,
constants.JULES_PARAM_DRIVE_INTERP, val)
val = f90_helper.python_to_f90_str(3600)
pv2 = DrivingDatasetParameterValue(model_run_service, driving2,
constants.JULES_PARAM_DRIVE_DATA_PERIOD, val)
val = f90_helper.python_to_f90_str("data/driving2/frac.nc")
pv3 = DrivingDatasetParameterValue(model_run_service, driving2,
constants.JULES_PARAM_FRAC_FILE, val)
val = f90_helper.python_to_f90_str("frac2")
pv4 = DrivingDatasetParameterValue(model_run_service, driving2,
constants.JULES_PARAM_FRAC_NAME, val)
val = f90_helper.python_to_f90_str(['b', 'sathh', 'satcon', 'sm_sat', 'sm_crit',
'sm_wilt', 'hcap', 'hcon', 'albsoil'])
pv5 = DrivingDatasetParameterValue(model_run_service, driving2,
constants.JULES_PARAM_SOIL_PROPS_VAR, val)
val = f90_helper.python_to_f90_str(['bexp', 'sathh', 'satcon', 'vsat', 'vcrit',
'vwilt', 'hcap', 'hcon', 'albsoil'])
pv6 = DrivingDatasetParameterValue(model_run_service, driving2,
constants.JULES_PARAM_SOIL_PROPS_VAR_NAME, val)
val = f90_helper.python_to_f90_str(9)
pv7 = DrivingDatasetParameterValue(model_run_service, driving2,
constants.JULES_PARAM_SOIL_PROPS_NVARS, val)
val = f90_helper.python_to_f90_str("data/WATCH_2D/ancils/soil_igbp_bc_watch_0p5deg_capUM6.6_2D.nc")
pv7 = DrivingDatasetParameterValue(model_run_service, driving2,
constants.JULES_PARAM_SOIL_PROPS_FILE, val)
session.add(driving2)
session.commit()
def _status(self, status_name):
"""
Return from the database the ModelRunStatus for a requested status name
:param status_name: The name of the status to find
:return: The matching status object
"""
with session_scope(Session) as session:
return session.query(ModelRunStatus).filter(ModelRunStatus.name == status_name).one()
def test_GIVEN_nonexistent_model_id_WHEN_make_public_model_THEN_ServiceException_raised(self):
# Add a user
with session_scope(Session) as session:
user = User()
user.name = 'user1'
session.add(user)
with self.assertRaises(ServiceException, msg="Should have raised a ServiceException"):
self.model_run_service.make_public_model(user, -100)
def test_GIVEN_full_model_WHEN_delete_THEN_parameter_values_are_deleted(self):
user = self.login('')
with session_scope(Session) as session:
pv_count = session.query(ParameterValue).count()
self.create_model_run_ready_for_submit()
with session_scope(Session) as session:
model = self.model_run_service.get_models_for_user(user)[0]
assert_that(session.query(ParameterValue).count(), greater_than(pv_count), "Creating model run adds parameters")
self.job_runner_client.delete = Mock()
self.model_run_service.delete_run_model(model.id, user)
with session_scope(Session) as session:
assert_that(session.query(ParameterValue).count(), is_(pv_count), "Parameter values is same as before model was created")
def clean_database(self):
"""
Cleans the User, ModelRun, Dataset, DrivingDataset and ParameterValue tables in the database
"""
with session_scope(Session) as session:
published_status = session \
.query(ModelRunStatus) \
.filter(ModelRunStatus.name == constants.MODEL_RUN_STATUS_PUBLISHED) \
.one()
parameter_to_keep = session \
.query(ParameterValue.id) \
.join(ModelRun) \
.join(User) \
.filter(User.username == constants.CORE_USERNAME) \
.filter(ModelRun.status_id != published_status.id)\
.all()
session.query(LandCoverAction).delete()
session.query(LandCoverRegion).delete()
session.query(LandCoverRegionCategory).delete()
session \
.query(ParameterValue) \
.filter(ParameterValue.id.notin_([x[0] for x in parameter_to_keep])) \
.delete(synchronize_session='fetch')
core_user_id = session.query(User.id).filter(User.username == constants.CORE_USERNAME).one()[0]
session.query(Dataset).delete()
# delete all runs except the scientific configurations
session \
.query(ModelRun) \
.filter(or_(
ModelRun.user_id != core_user_id,
ModelRun.user_id.is_(None),
ModelRun.status_id == published_status.id)) \
.delete(synchronize_session='fetch')
session.query(DrivingDatasetLocation).delete()
session.query(DrivingDatasetParameterValue).delete()
session.query(DrivingDataset) \
.filter(DrivingDataset.name != constants.USER_UPLOAD_DRIVING_DATASET_NAME) \
.delete()
session \
.query(User) \
.filter(or_(User.username != constants.CORE_USERNAME, User.username.is_(None))) \
.delete()
session.query(AccountRequest).delete()
emails = session \
.query(SystemAlertEmail).all()
for email in emails:
email.last_sent = None
def create_account_request(self, email_addess="*****@*****.**"):
"""
Create an account request
:return: id of account request
"""
with session_scope() as session:
self.account_request = AccountRequest()
self.account_request.email = email_addess
self.account_request.institution = "institution"
self.account_request.first_name = "a very unique name for the user " + str(datetime.datetime.now())
self.account_request.last_name = "last name"
self.account_request.usage = "usage"
session.add(self.account_request)
with session_scope() as session:
ac = session.query(AccountRequest).filter(
AccountRequest.first_name == self.account_request.first_name).one()
return ac.id
def test_GIVEN_no_model_runs_WHEN_get_model_runs_for_user_THEN_empty_list(self):
# Add a user who doesn't have any model runs
with session_scope(Session) as session:
user = User()
user.name = 'Has No Model Runs'
session.add(user)
# Get the users model runs
model_runs = self.model_run_service.get_models_for_user(user)
assert_that(model_runs, is_([]))
def test_GIVEN_driving_dataset_THEN_when_view_by_non_admin_THEN_not_shown(self):
user = self.login()
self.clean_database()
with session_scope() as session:
self.create_driving_dataset(session, is_restricted_to_admins=True)
driving_datasets = self.dataset_service.get_driving_datasets(user)
assert_that(len(driving_datasets), is_(1), "Driving dataset count (just the single cell one)")
def test_GIVEN_user_has_completed_model_WHEN_publish_model_THEN_model_published(self):
# Add a user and give them a model
with session_scope(Session) as session:
user = User()
user.name = 'user1'
session.add(user)
session.commit()
# Give them a model
model_run = ModelRun()
model_run.name = "MR1"
model_run.user_id = user.id
model_run.status = self._status(constants.MODEL_RUN_STATUS_COMPLETED)
session.add(model_run)
# Get the users model runs
self.model_run_service.publish_model(user, model_run.id)
with session_scope(Session) as session:
updated_model_run = session.query(ModelRun).join(ModelRunStatus).filter(ModelRun.id == model_run.id).one()
assert_that(updated_model_run.status.name, is_(constants.MODEL_RUN_STATUS_PUBLISHED))
def test_GIVEN_account_request_WHEN_reject_THEN_request_deleted_email_sent(self):
request_id = self.create_account_request()
self.account_request_service.reject_account_request(request_id, "a fairly long reason")
with session_scope() as session:
assert_that(session.query(AccountRequest).filter(AccountRequest.id == request_id).count(), is_(0), "Request has been deleted")
assert_that(session.query(User).count(), is_(1), "Only one user core in the users table")
assert_that(self.email_service.send_email.called, is_(True), "Rejection email sent")
def assert_regions_are_correct(self, driving_dataset, expected_categories, expected_names, expected_paths, values):
with session_scope() as session:
regions = LandCoverService().get_land_cover_regions(driving_dataset.id)
assert_that(len(regions), is_(len(values)), "number of regions")
for name, category, path, region in zip(expected_names, expected_categories, expected_paths, regions):
assert_that(region.name, is_(name), "name")
assert_that(region.category.name, is_(category), "category")
assert_that(region.mask_file, is_(path), "path")
return regions
