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