def setUp(self): mock_config = MockConfig() self.config_mock = mock_config.config self.config_real = Config("TEST") self.mock_search_cursor = mock.MagicMock(arcpy.da.SearchCursor) self.mock_search_cursor.__iter__.return_value = iter([ (1, "02yr6h", "D"), (2, "05yr6h", "D") ]) self.mock_search_cursor_for_required_simulation_list = mock.MagicMock( arcpy.da.SearchCursor) self.mock_search_cursor_for_required_simulation_list.__iter__.return_value = iter( [("02yr6h", "D", "EX", 0), ("05yr6h", "D", "50", 1)]) self.mock_dev_scenario_search_cursor = mock.MagicMock( arcpy.da.SearchCursor) self.mock_dev_scenario_search_cursor.__iter__.return_value = iter([ (1, "EX"), (2, "50") ]) self.patch_list_of_domains = mock.patch("arcpy.da.ListDomains") self.mock_list_of_domains = self.patch_list_of_domains.start() self.patch_search_cursor = mock.patch("arcpy.da.SearchCursor") self.mock_search_cursor_instance = self.patch_search_cursor.start() self.mock_search_cursor_instance.return_value = self.mock_search_cursor self.key_field = "key_field" self.value_fields = ["field1", "field2"] self.db_table = "db_table_path"
def setUp(self): self.config = Config(test_flag) self.model_catalog_db_data_io = ModelCatalogDbDataIo(self.config) self.simulation_data_io = SimulationDataIo( self.config, self.model_catalog_db_data_io) self.simulation = Simulation(self.config) self.simulation.id = 999998 self.simulation.storm_id = 1 self.simulation.dev_scenario_id = 1 self.patch_simulation_path = mock.patch.object(self.simulation, "path") self.mock_simulation_path = self.patch_simulation_path.start() self.mock_simulation_path.return_value = r"\\besfile1\ccsp\03_WP2_Planning_Support_Tools\03_RRAD\CCSP_Data_Management_ToolBox\Test_Cases\Taggart\BaseR011018V4ic\sim\D25yr6h" self.model_catalog_dataio = ModelCatalogDbDataIo(self.config) self.model_dataio = ModelDataIo(self.config, self.model_catalog_dataio) self.model_catalog = ModelCatalog(self.config) self.model = Model.initialize_with_current_id( self.config, self.model_catalog_dataio) self.model.parent_model_id = 555 self.model.model_request_id = 777 self.model.project_phase_id = 1 self.model.engine_type_id = 1 self.model.create_date = None self.model.deploy_date = None # TODO NEEDS TO BE EXTRACTED FROM CONFIG FILE self.model.run_date = None # TODO NEEDS TO BE EXTRACTED FROM CONFIG FILE self.model.extract_date = None # TODO NEEDS TO BE EXTRACTED FROM CONFIG FILE self.model.created_by = getpass.getuser() self.model_name = "This is what I call my model" self.model.model_path = r"\\besfile1\CCSP\03_WP2_Planning_Support_Tools\03_RRAD\CCSP_Data_Management_ToolBox\Test_Cases\Taggart\Final" self.model.project_type_id = 1 self.model.model_purpose_id = self.config.model_purpose_id[ "Characterization"] self.model.model_calibration_file = "C:\Temp\Cal" self.model.model_status_id = self.config.model_status_id["Working"] self.model.model_alteration_file = "C:\Temp\BC" self.model.project_num = "E10TEST" self.model.create_date = datetime.datetime.today() self.model.create_model_alterations_bc([["Stage"]], self.model_catalog_dataio) self.model.create_model_alterations_hydrologic( [["Area Factor"]], self.model_catalog_dataio) self.model.create_model_alterations_hydraulic( [["Pipe Roughness"]], self.model_catalog_dataio) self.model.create_project_types(["Storm"], self.model_catalog_dataio) self.model.create_simulations(self.model_dataio) self.model_dataio.set_model_to_read_write(self.model)
def test_config_init_with_test_flag_as_false_sde_path_to_prod_server(self): with mock.patch("businessclasses.config.Config.retrieve_domain_as_dict" ) as mock_retrieve_domain_as_dict: test_bool = "PROD" mock_retrieve_domain_as_dict.return_value = {"dict1": 1} config = Config(test_bool) sde_connections = r"\\besfile1\CCSP\03_WP2_Planning_Support_Tools\03_RRAD\CCSP_Data_Management_ToolBox\connection_files" model_catalog_prod_sde = r"BESDBPROD1.MODELCATALOG.sde" EMGAATS_prod_sde = r"BESDBPROD1.EMGAATS.sde" ASM_WORK_prod_sde = r"BESDBPROD1.ASM_WORK.sde" model_catalog_prod_sde_path = os.path.join(sde_connections, model_catalog_prod_sde) EMGAATS_prod_sde_path = os.path.join(sde_connections, EMGAATS_prod_sde) ASM_WORK_prod_sde_path = os.path.join(sde_connections, ASM_WORK_prod_sde) self.assertEquals(config.model_catalog_sde_path, model_catalog_prod_sde_path) self.assertEquals(config.EMGAATS_sde_path, EMGAATS_prod_sde_path) self.assertEquals(config.ASM_WORK_sde_path, ASM_WORK_prod_sde_path)
def setUp(self): self.config = Config(test_flag) cip_numbers = self.config.unique_cip_numbers self.model_catalog_dataio = ModelCatalogDbDataIo(self.config) self.model_dataio = ModelDataIo(self.config, self.model_catalog_dataio) self.model_catalog = ModelCatalog(self.config) self.model = Model.initialize_with_current_id( self.config, self.model_catalog_dataio) self.model.parent_model_id = 555 self.model.model_request_id = 777 self.model.project_phase_id = 1 self.model.engine_type_id = 1 self.model.create_date = None self.model.created_by = getpass.getuser() self.model.model_path = r"\\besfile1\ccsp\Models\OAK\2Cali\Final" ## does this one have all the required storms? self.model.deploy_date = None # TODO NEEDS TO BE EXTRACTED FROM CONFIG FILE self.model.run_date = None # TODO NEEDS TO BE EXTRACTED FROM CONFIG FILE self.model.set_extract_date(self.model_dataio) self.model.project_type_id = 1 self.model.model_purpose_id = self.config.model_purpose_id[ "Calibration"] self.model.model_calibration_file = "C:\Temp\Cal" self.model.model_status_id = self.config.model_status_id["Working"] self.model.model_alteration_file = "C:\Temp\BC" self.model.project_num = "E10TEST" self.model.create_date = datetime.datetime.today() self.model.create_model_alterations_bc([["Stage"]], self.model_catalog_dataio) self.model.create_model_alterations_hydrologic( [["Area Factor"]], self.model_catalog_dataio) self.model.create_model_alterations_hydraulic( [["Pipe Roughness"]], self.model_catalog_dataio) self.model.create_project_types(["Storm"], self.model_catalog_dataio) self.model.create_simulations(self.model_dataio) self.model_dataio.set_model_to_read_write(self.model)
def create_citywide_hybrid(): start = time.time() #config = Config('TEST') config = Config('PROD') dme_master_hybrid = DmeMasterHybrid(config) dme_master_hybrid_db_data_io = DmeMasterHybridDbDataIo(config) start = time.time() test_dme_links = dme_master_hybrid.create_dme_links(dme_master_hybrid_db_data_io) print " Creating DME links - duration: " + str(time.time() - start) + " seconds" start = time.time() test_master_links = dme_master_hybrid.create_master_links(dme_master_hybrid_db_data_io) print " Creating master links - duration: " + str(time.time() - start) + " seconds" dme_master_links = [] start = time.time() test_dme_links.sort(key=lambda x: x.global_id, reverse=True) test_master_links.sort(key=lambda x: x.global_id, reverse=True) invalid_counter = 0 for dme_link in test_dme_links: dme_master_link = DmeMasterLink(config) dme_master_link.global_id = dme_link.global_id dme_master_link.us_node_name = dme_link.us_node_name dme_master_link.ds_node_name = dme_link.ds_node_name dme_master_link.compkey = dme_link.compkey dme_master_link.diameter = dme_link.diameter dme_master_link.geometry = dme_link.geometry for index, master_link in enumerate(test_master_links): if dme_link.global_id == master_link.global_id: diameter = 0 valid_us_depth = False valid_ds_depth = False valid_diameter = False valid_dme_diameter = False valid_master_diameter = False valid_ies = (master_link.us_ie != 0 and master_link.ds_ie != 0) if (dme_link.diameter > 0) and dme_link.diameter is not None: valid_dme_diameter = True if (master_link.diameter > 0) and master_link.diameter is not None: valid_master_diameter = True if valid_dme_diameter: diameter = dme_link.diameter valid_diameter = True elif valid_master_diameter: diameter = master_link.diameter valid_diameter = True else: #print " Invalid Diameter" invalid_counter += 1 diameter = 4 valid_diameter = False if valid_diameter and valid_ies: min_depth = (diameter / 12.0 + 1.0) if master_link.us_depth > min_depth: valid_us_depth = True if master_link.ds_depth > min_depth: valid_ds_depth = True if valid_us_depth and valid_ds_depth: dme_master_link.us_depth = master_link.us_depth dme_master_link.ds_depth = master_link.ds_depth dme_master_link.us_ie = master_link.us_ie dme_master_link.ds_ie = master_link.ds_ie dme_master_link.link_id = master_link.link_id dme_master_link.us_depth_source = "Master" dme_master_link.ds_depth_source = "Master" else: dme_master_link.us_depth = 10 dme_master_link.ds_depth = 10 if valid_us_depth: dme_master_link.us_depth = master_link.us_depth dme_master_link.us_depth_source = "Master" else: dme_master_link.us_depth = 10 dme_master_link.us_depth_source = "10_ft_fill_Master" if valid_ds_depth: dme_master_link.ds_depth = master_link.ds_depth dme_master_link.ds_depth_source = "Master" else: dme_master_link.ds_depth = 10 dme_master_link.ds_depth_source = "10_ft_fill_Master" dme_master_link.diameter = diameter dme_master_links.append(dme_master_link) test_master_links.pop(index) break else: dme_master_link.us_depth = 10 dme_master_link.ds_depth = 10 dme_master_link.us_ie = None dme_master_link.ds_ie = None dme_master_link.link_id = None dme_master_link.us_depth_source = "10ftFill" dme_master_link.ds_depth_source = "10ftFill" dme_master_link.diameter = 4 dme_master_links.append(dme_master_link) if invalid_counter > 0: print " Records with Invalid Diameter: " + str(invalid_counter) print " Data conditioning - duration: " + str(time.time() - start) + " seconds" start = time.time() dme_master_hybrid_db_data_io.append_dme_master_links_to_db(dme_master_links) #dme_master_hybrid_db_data_io.copy_dme_master_links_to_db(dme_master_links) print " Writing result - duration: " + str(time.time() - start) + " seconds" pass #FOR TESTING/ RUNNING INDEPENDENTLY #create_citywide_hybrid()
class TestConfig(TestCase): def setUp(self): mock_config = MockConfig() self.config_mock = mock_config.config self.config_real = Config("TEST") self.mock_search_cursor = mock.MagicMock(arcpy.da.SearchCursor) self.mock_search_cursor.__iter__.return_value = iter([ (1, "02yr6h", "D"), (2, "05yr6h", "D") ]) self.mock_search_cursor_for_required_simulation_list = mock.MagicMock( arcpy.da.SearchCursor) self.mock_search_cursor_for_required_simulation_list.__iter__.return_value = iter( [("02yr6h", "D", "EX", 0), ("05yr6h", "D", "50", 1)]) self.mock_dev_scenario_search_cursor = mock.MagicMock( arcpy.da.SearchCursor) self.mock_dev_scenario_search_cursor.__iter__.return_value = iter([ (1, "EX"), (2, "50") ]) self.patch_list_of_domains = mock.patch("arcpy.da.ListDomains") self.mock_list_of_domains = self.patch_list_of_domains.start() self.patch_search_cursor = mock.patch("arcpy.da.SearchCursor") self.mock_search_cursor_instance = self.patch_search_cursor.start() self.mock_search_cursor_instance.return_value = self.mock_search_cursor self.key_field = "key_field" self.value_fields = ["field1", "field2"] self.db_table = "db_table_path" def tearDown(self): self.mock_search_cursor_instance = self.patch_search_cursor.stop() self.mock_list_of_domains = self.patch_list_of_domains.stop() # TODO need to add a test for Dry does not follow logic of D for design + storm name like all of the other storms def test_standard_simulation_names(self): standard_simulation_names = [ 'D25yr6h', 'D25yr6h-50', 'D25yr6h-BO', 'D10yr6h', 'D10yr6h-50', 'D10yr6h-BO' ] output_simulation_names = self.config_mock.standard_simulation_names() self.assertEquals(output_simulation_names, standard_simulation_names) def test_reverse_dict_returns_reverse_dict(self): test_dictionary = {0: "one", 1: "two", 2: "three"} reverse_dictionary = {"one": 0, "two": 1, "three": 2} test_reverse = self.config_real.reverse_dict(test_dictionary) self.assertEquals(test_reverse, reverse_dictionary) def test_retrieve_domain_as_dict_calls_list_of_domains_with_correct_arguments( self): self.config_real.retrieve_domain_as_dict( "Engine_Type", self.config_real.model_catalog_sde_path) self.mock_list_of_domains.assert_called_with( self.config_real.model_catalog_sde_path) def test_retrieve_domain_as_dict_returns_correct_dict(self): mock_domain1 = mock.MagicMock(arcpy.da.Domain) mock_domain1.name = "Engine_Type" mock_domain1.codedValues = {1: "EMGAATS"} mock_domain2 = mock.MagicMock(arcpy.da.Domain) mock_domain2.name = "Storm_Type" self.mock_list_of_domains.return_value = [mock_domain1, mock_domain2] domain_dict_of_scenarios = self.config_real.retrieve_domain_as_dict( "Engine_Type", self.config_real.model_catalog_sde_path) self.assertEquals(domain_dict_of_scenarios, {1: "EMGAATS"}) def test_retrieve_engine_type_domain_as_dict_called_with_correct_domain_name( self): with mock.patch.object( self.config_real, "retrieve_domain_as_dict") as mock_retrieve_domain_as_dict: self.config_real.retrieve_engine_type_domain_as_dict() mock_retrieve_domain_as_dict.assert_called_with( "Engine_Type", self.config_real.model_catalog_sde_path) def test_retrieve_model_alt_bc_domain_as_dict_called_with_correct_domain_name( self): with mock.patch.object( self.config_real, "retrieve_domain_as_dict") as mock_retrieve_domain_as_dict: self.config_real.retrieve_model_alt_bc_domain_as_dict() mock_retrieve_domain_as_dict.assert_called_with( "Model_Alt_BC", self.config_real.model_catalog_sde_path) def test_retrieve_model_alt_hydraulic_domain_as_dict_called_with_correct_domain_name( self): with mock.patch.object( self.config_real, "retrieve_domain_as_dict") as mock_retrieve_domain_as_dict: self.config_real.retrieve_model_alt_hydraulic_domain_as_dict() mock_retrieve_domain_as_dict.assert_called_with( "Model_Alt_Hydraulic", self.config_real.model_catalog_sde_path) def test_retrieve_model_alt_hydrologic_domain_as_dict_called_with_correct_domain_name( self): with mock.patch.object( self.config_real, "retrieve_domain_as_dict") as mock_retrieve_domain_as_dict: self.config_real.retrieve_model_alt_hydrologic_domain_as_dict() mock_retrieve_domain_as_dict.assert_called_with( "Model_Alt_Hydrologic", self.config_real.model_catalog_sde_path) def test_retrieve_model_purpose_domain_as_dict_called_with_correct_domain_name( self): with mock.patch.object( self.config_real, "retrieve_domain_as_dict") as mock_retrieve_domain_as_dict: self.config_real.retrieve_model_purpose_domain_as_dict() mock_retrieve_domain_as_dict.assert_called_with( "Model_Purpose", self.config_real.model_catalog_sde_path) def test_retrieve_model_status_domain_as_dict_called_with_correct_domain_name( self): with mock.patch.object( self.config_real, "retrieve_domain_as_dict") as mock_retrieve_domain_as_dict: self.config_real.retrieve_model_status_domain_as_dict() mock_retrieve_domain_as_dict.assert_called_with( "Model_Status", self.config_real.model_catalog_sde_path) def test_retrieve_proj_phase_domain_as_dict_called_with_correct_domain_name( self): with mock.patch.object( self.config_real, "retrieve_domain_as_dict") as mock_retrieve_domain_as_dict: self.config_real.retrieve_proj_phase_domain_as_dict() mock_retrieve_domain_as_dict.assert_called_with( "Proj_Phase", self.config_real.model_catalog_sde_path) def test_retrieve_proj_type_domain_as_dict_called_with_correct_domain_name( self): with mock.patch.object( self.config_real, "retrieve_domain_as_dict") as mock_retrieve_domain_as_dict: self.config_real.retrieve_proj_type_domain_as_dict() mock_retrieve_domain_as_dict.assert_called_with( "Proj_Type", self.config_real.model_catalog_sde_path) def test_retrieve_dict_from_db_calls_search_cursor_with_correct_arguments( self): self.config_real.retrieve_dict_from_db(self.key_field, self.value_fields, self.db_table) self.mock_search_cursor_instance.assert_called_with( "db_table_path", ["key_field", "field1", "field2"]) def test_retrieve_dict_from_db_has_multiple_fields_returns_correct_dictionary( self): return_dict = {1: ("02yr6h", "D"), 2: ("05yr6h", "D")} storm_dict = self.config_real.retrieve_dict_from_db( self.key_field, self.value_fields, self.db_table) self.assertEqual(storm_dict, return_dict) def test_retrieve_dict_from_db_has_one_field_returns_correct_dictionary( self): return_dict = {1: "EX", 2: "50"} self.value_fields = ["field1"] self.mock_search_cursor_instance.return_value = self.mock_dev_scenario_search_cursor storm_dict = self.config_real.retrieve_dict_from_db( self.key_field, self.value_fields, self.db_table) self.assertEqual(storm_dict, return_dict) def test_retrieve_storm_dict_calls_retrieve_dict_from_db_with_correct_arguments( self): with mock.patch.object( self.config_real, "retrieve_dict_from_db") as mock_retrieve_dict_from_db: self.config_real.retrieve_storm_dict() mock_retrieve_dict_from_db.assert_called_with( "storm_id", ["storm_name", "storm_type"], self.config_real.storms_sde_path) def test_retrieve_storm_dict_returns_correct_value(self): with mock.patch.object( self.config_real, "retrieve_dict_from_db") as mock_retrieve_dict_from_db: mock_retrieve_dict_from_db.return_value = "return value" return_value = self.config_real.retrieve_storm_dict() self.assertEqual(return_value, "return value") def test_retrieve_dev_scenario_dict_calls_retrieve_dict_from_db_with_correct_arguments( self): with mock.patch.object( self.config_real, "retrieve_dict_from_db") as mock_retrieve_dict_from_db: self.config_real.retrieve_dev_scenario_dict() mock_retrieve_dict_from_db.assert_called_with( "dev_scenario_id", ["dev_scenario"], self.config_real.dev_scenarios_sde_path) def test_retrieve_dev_scenario_dict_returns_correct_value(self): with mock.patch.object( self.config_real, "retrieve_dict_from_db") as mock_retrieve_dict_from_db: mock_retrieve_dict_from_db.return_value = "return value" return_value = self.config_real.retrieve_dev_scenario_dict() self.assertEqual(return_value, "return value") def test_retrieve_cip_analysis_request_dict_is_called_with_correct_arguments( self): with mock.patch.object( self.config_real, "retrieve_dict_from_db") as mock_retrieve_dict_from_db: self.config_real.retrieve_cip_analysis_request_dict() mock_retrieve_dict_from_db.assert_called_with( "AR_ID", ["ProjectNumber"], self.config_real.analysis_requests_sde_path) def test_retrieve_cip_analysis_request_dict_returns_correct_value(self): with mock.patch.object( self.config_real, "retrieve_dict_from_db") as mock_retrieve_dict_from_db: mock_retrieve_dict_from_db.return_value = { "key1": "value", "key2": None } return_value = self.config_real.retrieve_cip_analysis_request_dict( ) self.assertEqual(return_value, {"key1": "value"}) def test_get_unique_values_returns_unique_values(self): input_dict = {"key1": "value", "key2": "value", "key3": "value1"} unique_values = self.config_real.get_unique_values(input_dict) self.assertItemsEqual(unique_values, ["value", "value1"]) def test_get_unique_values_case_insensitive_returns_unique_values_regardless_of_case( self): input_dict = {"key1": "value", "key2": "Value", "key3": "value1"} unique_values = self.config_real.get_unique_values_case_insensitive( input_dict) self.assertItemsEqual(unique_values, ["VALUE", "VALUE1"]) def test_get_keys_based_on_value_returns_correct_keys(self): test_dict = {"Key1": "value", "Key2": "value", "Key3": "bad_value"} test_value = "value" check_keys = self.config_real.get_keys_based_on_value( test_dict, test_value) self.assertItemsEqual(check_keys, ["Key1", "Key2"]) def test_get_keys_based_on_value_case_insensitive_returns_correct_keys_regardless_of_value_case( self): test_dict = {"Key1": "value", "Key2": "VALUE", "Key3": "bad_value"} test_value = "value" return_keys = self.config_real.get_keys_based_on_value_case_insensitive( test_dict, test_value) self.assertItemsEqual(return_keys, ["Key1", "Key2"]) def test_get_cip_analysis_requests_returns_correct_cip_requests(self): self.config_real.cip_analysis_requests = { "Key1": "e1000", "Key2": "E1000", "Key3": "bad_value" } cip_number = "E1000" cip_analysis_requests = self.config_real.get_cip_analysis_requests( cip_number) self.assertItemsEqual(cip_analysis_requests, ["Key1", "Key2"]) def test_get_unique_cip_numbers_returns_cip_numbers_without_empty_unicode_string( self): input_dict = { "key1": "value1", "key2": "Value", "key3": "value", "key4": u'' } self.config_real.cip_analysis_requests = input_dict unique_values = self.config_real.get_unique_cip_numbers() self.assertItemsEqual(unique_values, ["VALUE", "VALUE1"]) self.assertEqual(unique_values[0], "VALUE1") self.assertEqual(unique_values[1], "VALUE") def test_retrieve_required_storm_and_dev_scenario_ids_with_purpose_characterization_calls_search_cursor_with_correct_arguments( self): model_purpose = "Characterization" model_project_phase = "Planning" self.mock_search_cursor_instance.return_value = self.mock_search_cursor_for_required_simulation_list self.config_real.retrieve_required_storm_and_dev_scenario_ids( model_purpose, model_project_phase) self.mock_search_cursor_instance.assert_called_with( self.config_real.required_simulations_sde_path, [ "storm_name", "storm_type", "dev_scenario", "ccsp_characterization" ]) def test_retrieve_required_storm_and_dev_scenario_ids_with_purpose_characterization_returns_correct_list_of_required_simulations( self): model_purpose = "Characterization" model_project_phase = "Planning" self.mock_search_cursor_instance.return_value = self.mock_search_cursor_for_required_simulation_list required_simulations = self.config_real.retrieve_required_storm_and_dev_scenario_ids( model_purpose, model_project_phase) self.assertEqual(required_simulations, [(2, 2)]) def test_retrieve_required_storm_and_dev_scenario_ids_throws_exception_when_storm_name_not_in_storm_id_dict( self): model_purpose = "Characterization" model_project_phase = "Planning" self.mock_search_cursor_for_required_simulation_list.__iter__.return_value = iter( [("02yr6h", "D", "EX", 0), ("incorrect_storm_name", "D", "50", 1)]) self.mock_search_cursor_instance.return_value = self.mock_search_cursor_for_required_simulation_list with self.assertRaises( InvalidStormNameOrStormTypeInRequiredSimulationsTable): self.config_real.retrieve_required_storm_and_dev_scenario_ids( model_purpose, model_project_phase) def test_retrieve_required_storm_and_dev_scenario_ids_throws_exception_when_dev_scenario_not_in_dev_scenario_dict( self): model_purpose = "Characterization" model_project_phase = "Planning" self.mock_search_cursor_for_required_simulation_list.__iter__.return_value = iter( [("02yr6h", "D", "EX", 0), ("05yr6h", "D", "incorrect_dev_scenario", 1)]) self.mock_search_cursor_instance.return_value = self.mock_search_cursor_for_required_simulation_list with self.assertRaises(InvalidDevScenarioInRequiredSimulationsTable): self.config_real.retrieve_required_storm_and_dev_scenario_ids( model_purpose, model_project_phase) def test_retrieve_required_storm_and_dev_scenario_ids_throws_exception_with_invalid_project_phase( self): model_purpose = "Characterization" model_project_phase = "invalid_project_phase" self.mock_search_cursor_for_required_simulation_list.__iter__.return_value = iter( [("02yr6h", "D", "EX", 0), ("05yr6h", "D", "incorrect_dev_scenario", 1)]) self.mock_search_cursor_instance.return_value = self.mock_search_cursor_for_required_simulation_list with self.assertRaises(InvalidProjectPhase): self.config_real.retrieve_required_storm_and_dev_scenario_ids( model_purpose, model_project_phase) def test_retrieve_required_storm_and_dev_scenario_ids_throws_exception_with_invalid_model_purpose( self): model_purpose = "Invalid_model_purpose" model_project_phase = "Planning" self.mock_search_cursor_for_required_simulation_list.__iter__.return_value = iter( [("02yr6h", "D", "EX", 0), ("05yr6h", "D", "incorrect_dev_scenario", 1)]) self.mock_search_cursor_instance.return_value = self.mock_search_cursor_for_required_simulation_list with self.assertRaises(InvalidModelPurposeException): self.config_real.retrieve_required_storm_and_dev_scenario_ids( model_purpose, model_project_phase) def test_config_init_with_test_flag_as_true_sde_path_to_test_server(self): with mock.patch("businessclasses.config.Config.retrieve_domain_as_dict" ) as mock_retrieve_domain_as_dict: test_bool = "TEST" mock_retrieve_domain_as_dict.return_value = {"dict1": 1} config = Config(test_bool) sde_connections = r"\\besfile1\CCSP\03_WP2_Planning_Support_Tools\03_RRAD\CCSP_Data_Management_ToolBox\connection_files" model_catalog_test_sde = r"BESDBTEST1.MODELCATALOG.sde" EMGAATS_test_sde = r"BESDBTEST1.EMGAATS.sde" ASM_WORK_test_sde = r"BESDBTEST1.ASM_WORK.sde" model_catalog_test_sde_path = os.path.join(sde_connections, model_catalog_test_sde) EMGAATS_test_sde_path = os.path.join(sde_connections, EMGAATS_test_sde) ASM_WORK_test_sde_path = os.path.join(sde_connections, ASM_WORK_test_sde) self.assertEquals(config.model_catalog_sde_path, model_catalog_test_sde_path) self.assertEquals(config.EMGAATS_sde_path, EMGAATS_test_sde_path) self.assertEquals(config.ASM_WORK_sde_path, ASM_WORK_test_sde_path) def test_config_init_with_test_flag_as_false_sde_path_to_prod_server(self): with mock.patch("businessclasses.config.Config.retrieve_domain_as_dict" ) as mock_retrieve_domain_as_dict: test_bool = "PROD" mock_retrieve_domain_as_dict.return_value = {"dict1": 1} config = Config(test_bool) sde_connections = r"\\besfile1\CCSP\03_WP2_Planning_Support_Tools\03_RRAD\CCSP_Data_Management_ToolBox\connection_files" model_catalog_prod_sde = r"BESDBPROD1.MODELCATALOG.sde" EMGAATS_prod_sde = r"BESDBPROD1.EMGAATS.sde" ASM_WORK_prod_sde = r"BESDBPROD1.ASM_WORK.sde" model_catalog_prod_sde_path = os.path.join(sde_connections, model_catalog_prod_sde) EMGAATS_prod_sde_path = os.path.join(sde_connections, EMGAATS_prod_sde) ASM_WORK_prod_sde_path = os.path.join(sde_connections, ASM_WORK_prod_sde) self.assertEquals(config.model_catalog_sde_path, model_catalog_prod_sde_path) self.assertEquals(config.EMGAATS_sde_path, EMGAATS_prod_sde_path) self.assertEquals(config.ASM_WORK_sde_path, ASM_WORK_prod_sde_path)
from businessclasses.config import Config from businessclasses.dme_master_hybrid import DmeMasterHybrid from businessclasses.dme_master_link import DmeMasterLink from dataio.dme_master_hybrid_db_data_io import DmeMasterHybridDbDataIo import time start = time.time() config = Config('TEST') dme_master_hybrid = DmeMasterHybrid(config) dme_master_hybrid_db_data_io = DmeMasterHybridDbDataIo(config) ## will write out result for a subset of mlinks specified in CCSP.MASTER_LINK_NAMES (specified in view) ## 1. create in memory version of DME links ## 2. create in memory version of EMGAATS links which have already been subset to project area ## 3. overwrite information from EMGAATS links to DME links where global_ids match ## 4. append result to CCSP.DME_MASTER_HYBRID start = time.time() test_dme_pipes = dme_master_hybrid.create_dme_links( dme_master_hybrid_db_data_io) print time.time() - start start = time.time() test_ccsp_master_links = dme_master_hybrid.create_ccsp_master_links( dme_master_hybrid_db_data_io) print time.time() - start dme_master_links = [] start = time.time()
from businessclasses.config import Config from dataio.utility import Utility config = Config("TEST") utility = Utility(config) print("Cleaning model catalog test data") utility.model_catalog_test_data_cleanup() utility.set_current_ids_to_zero(config.model_catalog_current_id_table_sde_path)