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_watch_regions(watch_driving_dataset, regions_csv_file): categories = [] f = open(regions_csv_file, "r") for line in f: stripped_line = line.strip() if not stripped_line.startswith('#') and len(stripped_line) > 0: values = line.split(',') if len(values) != 3: log.error("Regions csv file has incorrect number of elements on line reading %s" % stripped_line) exit(-1) category_name = values[0].strip() cat = None for category in categories: if category.name == category_name: cat = category if cat is None: log.info(" adding category {}".format(category_name)) cat = LandCoverRegionCategory(name=category_name) cat.driving_dataset = watch_driving_dataset categories.append(cat) region = LandCoverRegion() region.name = values[1].strip() region.mask_file = "data/WATCH_2D/masks/{}".format(values[2].strip()) region.category = cat log.info(" adding region {} to {} with file {}".format(region.name, category_name, region.mask_file)) f.close()
def add_land_cover_region(self, model_run): with session_scope() as session: land_cover_cat = LandCoverRegionCategory() land_cover_cat.name = "Countries" land_cover_cat.driving_dataset_id = model_run.driving_dataset_id land_cover_region = LandCoverRegion() land_cover_region.mask_file = "filepath" land_cover_region.name = "Wales" land_cover_region.category = land_cover_cat session.add(land_cover_region) return land_cover_region
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 _mock_lcs_get_land_cover_region_wrong_dataset(id): dds = DrivingDataset() dds.id = 7 land_cover_type = LandCoverRegionCategory() land_cover_type.id = 1 land_cover_type.driving_dataset_id = 7 land_cover_type.driving_dataset = dds land_cover_region = LandCoverRegion() land_cover_region.id = id land_cover_region.name = "Sand" land_cover_region.category = land_cover_type return land_cover_region
def _update_or_create_region(self, category, region, session): """ Update or create a land cover region :param category: category for the region :param region: a dictionry of region parameters :param session: the session :return: nothing """ existing_region_id = region.get("id") if existing_region_id is not None and existing_region_id is not "": region_in_db = self._get_land_cover_region_by_id_in_session(existing_region_id, session) else: region_in_db = LandCoverRegion() region_in_db.category = category region_in_db.name = region["name"] region_in_db.mask_file = region["path"]
def _mock_lcs_get_actions_for_model_run_wrong_dataset(model_run): cat = LandCoverRegionCategory() cat.id = 1 cat.name = "Countries" cat.driving_dataset_id = 2 region = LandCoverRegion() region.id = 1 region.name = "Wales" region.category = cat action = LandCoverAction() action.id = 1 action.region = region action.value_id = 1 return [action]
def test_GIVEN_data_set_with_a_region_WHEN_list_THEN_returns_mask(self): with session_scope() as session: category = LandCoverRegionCategory() category.driving_dataset = self.driving_dataset category.name = "mycategory" region = LandCoverRegion() region.name = "myregion" region.category = category region.mask_file = "data/file_path" session.add(category) self.login(access_level=constants.USER_ACCESS_LEVEL_ADMIN) response = self.app.get( url=url(controller='driving_data', action='edit', id=self.driving_dataset.id), expect_errors=True ) assert_that(response.normal_body, contains_string(category.name)) assert_that(response.normal_body, contains_string(region.name)) assert_that(response.normal_body, contains_string(region.mask_file))
def test_GIVEN_invalid_land_cover_actions_WHEN_post_THEN_error_shown_and_stay_on_page(self): # Add some regions to another driving dataset dds = DatasetService().get_driving_datasets(self.user)[1] with session_scope() as session: land_cat = LandCoverRegionCategory() land_cat.driving_dataset = dds land_cat.name = "Category2" land_region = LandCoverRegion() land_region.name = "Region1" land_region.category = land_cat session.add(land_region) response = self.app.post( url(controller='model_run', action='land_cover'), params={ 'submit': u'Next', 'action_1_region': str(land_region.id), 'action_1_value': u'8', 'action_1_order': u'1' }) assert_that(response.normal_body, contains_string("Land Cover")) # Check still on page assert_that(response.normal_body, contains_string("Land Cover Region not valid for the chosen driving data"))
def test_GIVEN_model_with_land_cover_actions_WHEN_convert_to_dictionary_THEN_land_cover_actions_present(self): job_runner_client = JobRunnerClient(config) def _alter_yearly_monthly_output_profiles(params): return params def _alter_driving_data_start(params): return params job_runner_client.alter_yearly_monthly_output_profiles = _alter_yearly_monthly_output_profiles job_runner_client.alter_driving_data_start = _alter_driving_data_start parameter = Parameter(name='file') expected_parameter_value = "'base_frac_file.nc'" parameter.parameter_values = [ParameterValue(value=expected_parameter_value)] parameter2 = Parameter(name='frac_name') expected_parameter_value2 = "'frac'" parameter2.parameter_values = [ParameterValue(value=expected_parameter_value2)] parameter3 = Parameter(name='latlon_region') expected_parameter_value3 = ".true." parameter3.parameter_values = [ParameterValue(value=expected_parameter_value3)] namelist = Namelist(name='JULES_FRAC') namelist_file = NamelistFile(filename='filename') expected_index = 3 namelist.parameters = [parameter, parameter2] namelist.namelist_file = namelist_file namelist.index_in_file = expected_index namelist2 = Namelist(name='JULES_MODEL_GRID') namelist_file = NamelistFile(filename='filename') expected_index = 3 namelist2.parameters = [parameter3] namelist2.namelist_file = namelist_file namelist2.index_in_file = expected_index model_run = ModelRun() model_run.id = 101 code_version = CodeVersion(name='Jules v3.4.1') model_run.code_version = code_version code_version.parameters = [parameter, parameter2, parameter3] user = User() user.id = 1 user.email = "email" user.username = "******" model_run.user = user lcr1 = LandCoverRegion() lcr1.mask_file = "region1.nc" lca1 = LandCoverAction() lca1.value_id = 9 lca1.order = 1 lca1.region = lcr1 lcr2 = LandCoverRegion() lcr2.mask_file = "region2.nc" lca2 = LandCoverAction() lca2.value_id = 5 lca2.order = 2 lca2.region = lcr2 land_cover_actions = [lca1, lca2] result = job_runner_client.convert_model_to_dictionary(model_run, code_version.parameters, land_cover_actions) result_lc = result[constants.JSON_LAND_COVER] assert_that(result_lc[constants.JSON_LAND_COVER_BASE_FILE], is_("base_frac_file.nc")) assert_that(result_lc[constants.JSON_LAND_COVER_BASE_KEY], is_("frac")) assert_that(result_lc[constants.JSON_LAND_COVER_ICE_INDEX], is_(9)) result_lc_actions = result_lc[constants.JSON_LAND_COVER_ACTIONS] assert_that(len(result_lc_actions), is_(2)) action1 = result_lc_actions[0] assert_that(action1[constants.JSON_LAND_COVER_MASK_FILE], is_("region1.nc")) assert_that(action1[constants.JSON_LAND_COVER_ORDER], is_(1)) assert_that(action1[constants.JSON_LAND_COVER_VALUE], is_(9)) action2 = result_lc_actions[1] assert_that(action2[constants.JSON_LAND_COVER_MASK_FILE], is_("region2.nc")) assert_that(action2[constants.JSON_LAND_COVER_ORDER], is_(2)) assert_that(action2[constants.JSON_LAND_COVER_VALUE], is_(5)) namelist_file_result = result[constants.JSON_MODEL_NAMELIST_FILES][0] parameters_result = namelist_file_result[constants.JSON_MODEL_NAMELISTS][0][constants.JSON_MODEL_PARAMETERS] assert_that(parameters_result['file'], is_("'" + constants.USER_EDITED_FRACTIONAL_FILENAME + "'")) assert_that(parameters_result['frac_name'], is_("'frac'"))
def _mock_get_land_cover_categories(driving_data_id): cat1 = LandCoverRegionCategory() cat1.driving_dataset_id = driving_data_id cat1.name = "Rivers" cat1.id = 1 region1 = LandCoverRegion() region1.id = 1 region1.name = "Thames" region1.category_id = 1 region1.category = cat1 region2 = LandCoverRegion() region2.id = 2 region2.name = "Itchen" region2.category_id = 1 region2.category = cat1 cat1.regions = [region1, region2] cat2 = LandCoverRegionCategory() cat2.driving_dataset_id = driving_data_id cat2.name = "Counties" cat2.id = 2 region3 = LandCoverRegion() region3.id = 3 region3.name = "Hampshire" region3.category_id = 2 region3.category = cat2 region4 = LandCoverRegion() region4.id = 4 region4.name = "Oxfordshire" region4.category_id = 2 region4.category = cat2 cat2.regions = [region3, region4] return [cat1, cat2]
def generate_categories_with_regions(self, driving_dataset): # Add categories cat1 = LandCoverRegionCategory() cat1.driving_dataset_id = driving_dataset.id cat1.name = "Rivers" cat1.id = 1 region1 = LandCoverRegion() region1.id = 1 region1.name = "Thames" region1.category_id = 1 region1.category = cat1 region2 = LandCoverRegion() region2.id = 2 region2.name = "Itchen" region2.category_id = 1 region2.category = cat1 cat1.regions = [region1, region2] cat2 = LandCoverRegionCategory() cat2.driving_dataset_id = driving_dataset.id cat2.name = "Counties" cat2.id = 2 region3 = LandCoverRegion() region3.id = 3 region3.name = "Hampshire" region3.category_id = 2 region3.category = cat2 region4 = LandCoverRegion() region4.id = 4 region4.name = "Oxfordshire" region4.category_id = 2 region4.category = cat2 cat2.regions = [region3, region4] return [cat1, cat2]