def setUpClass(cls):
print("\nINFO: Setting up copy layer With different Geometries to DB validation...")
cls.app = AppInterface()
import_qgis_model_baker()
# restore schemas
print("INFO: Restoring databases to be used")
restore_schema(SCHEMA_DISTINCT_GEOMS)
restore_schema(SCHEMA_LADM_COL_EMPTY)
cls.gpkg_path = get_test_copy_path(GPKG_PATH_DISTINCT_GEOMS)
cls.db_distinct_geoms = get_pg_conn(SCHEMA_DISTINCT_GEOMS)
cls.db_pg = get_pg_conn(SCHEMA_LADM_COL_EMPTY)
def test_export_data_in_pg(self):
print("\nINFO: Validate Export Data in PG...")
restore_schema('test_export_data')
db_pg = get_pg_conn('test_export_data')
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path(MODELS_PATH)
base_config.custom_model_directories_enabled = True
configuration = ExportConfiguration()
configuration.base_configuration = base_config
configuration.dbhost = 'postgres'
configuration.dbusr = '******'
configuration.dbpwd = 'clave_ladm_col'
configuration.database = 'ladm_col'
configuration.dbschema = 'test_export_data'
configuration.delete_data = True
configuration.ilimodels = ';'.join([self.ladmcol_models.model(LADMNames.LADM_COL_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SURVEY_MODEL_KEY).full_name()])
exporter = iliexporter.Exporter()
exporter.tool = DbIliMode.ili2pg
exporter.configuration = configuration
exporter.configuration.xtffile = os.path.join(tempfile.mkdtemp(), 'test_export_data.xtf')
self.assertEqual(exporter.run(), iliexporter.Exporter.SUCCESS)
self.check_export_xtf(exporter.configuration.xtffile)
db_pg.conn.close()
def setUpClass(cls):
import_processing()
import_asistente_ladm_col() # Import plugin
print("INFO: Restoring databases to be used")
restore_schema('test_ladm_col_queries')
cls.db_pg = get_pg_conn('test_ladm_col_queries')
# We can't use the restored database connection because the expression functions use the one in the plugin;
# that's why we have to get the database connection and assign it to the plugin
cls.plugin = utils.plugins[
"asistente_ladm_col"] # Dict of active plugins
cls.conn_manager = cls.plugin.conn_manager
cls.conn_manager.set_db_connector_for_source(cls.db_pg)
res, code, msg = cls.db_pg.test_connection()
cls.assertTrue(res, msg)
cls.assertIsNotNone(cls.db_pg.names.T_ID_F, 'Names is None')
cls.ladm_queries = PGLADMQuery()
# Maybe custom expression functions are not register in processing module
QgsExpression.registerFunction(get_domain_code_from_value)
QgsExpression.registerFunction(get_domain_value_from_code)
# Plots to be consulted are defined
layers = {cls.db_pg.names.LC_PLOT_T: None}
cls.plugin.app.core.get_layers(cls.db_pg, layers, load=True)
cls.test_plot_t_ids = get_field_values_by_key_values(
layers[cls.db_pg.names.LC_PLOT_T], cls.db_pg.names.T_ILI_TID_F,
['fc68c492-fad5-4a7b-98a3-6104e84a4ec4'], cls.db_pg.names.T_ID_F)
def setUpClass(cls):
cls.app = AppInterface()
restore_schema('test_ladm_cadastral_manager_data')
cls.db = get_pg_conn('test_ladm_cadastral_manager_data')
res, code, msg = cls.db.test_connection()
cls.assertTrue(res, msg)
def test_pg_test_connection_interlis_ladm_col_models(self):
print("\nINFO: Validate test_connection() for PostgreSQL (Interlis, no LADM-COL models)...")
restore_schema('test_ladm_all_models')
db_pg = get_pg_conn('test_ladm_all_models')
res, code, msg = db_pg.test_connection()
self.assertTrue(res, msg)
self.assertEqual(code, EnumTestConnectionMsg.SCHEMA_WITH_VALID_LADM_COL_STRUCTURE)
db_pg.conn.close()
def test_pg_test_connection_no_interlis_no_ladm_col_models(self):
print("\nINFO: Validate test_connection() for PostgreSQL (no Interlis, no LADM-COL models)...")
restore_schema('empty_no_interlis_no_ladm')
db_pg = get_pg_conn('empty_no_interlis_no_ladm')
res, code, msg = db_pg.test_connection()
self.assertFalse(res, msg)
self.assertEqual(code, EnumTestConnectionMsg.INTERLIS_META_ATTRIBUTES_NOT_FOUND)
db_pg.conn.close()
def test_pg_test_connection_interlis_with_ili2pg3_ladm_col_221_models(self):
print("\nINFO: Validate test_connection() for PostgreSQL (Interlis with ili2pg 3, LADM-COL 2.2.1 models)...")
restore_schema('interlis_ili2db3_ladm')
db_pg = get_pg_conn('interlis_ili2db3_ladm')
res, code, msg = db_pg.test_connection()
self.assertFalse(res, msg)
self.assertEqual(EnumTestConnectionMsg.INVALID_ILI2DB_VERSION, code)
db_pg.conn.close()
def test_pg_test_connection_interlis_ladm_col_models_higher_version(self):
print("\nINFO: Validate test_connection() for PostgreSQL (Interlis, LADM-COL with higher models version)...")
restore_schema('ladm_col_210')
db_pg = get_pg_conn('ladm_col_210')
res, code, msg = db_pg.test_connection()
self.assertFalse(res, msg)
self.assertEqual(code, EnumTestConnectionMsg.NO_LADM_MODELS_FOUND_IN_SUPPORTED_VERSION)
db_pg.conn.close()
def setUpClass(cls):
print("INFO: Restoring databases to be used")
restore_schema('test_change_detections')
cls.db_pg = get_pg_conn('test_change_detections')
res, code, msg = cls.db_pg.test_connection()
cls.assertTrue(res, msg)
cls.app = AppInterface()
cls.ladm_data = LADMData()
def test_import_data_in_pg(self):
print("\nINFO: Validate Import Data in PG...")
restore_schema('test_import_data')
db_pg = get_pg_conn('test_import_data')
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path('models/LADM_COL')
base_config.custom_model_directories_enabled = True
configuration = ImportDataConfiguration()
configuration.base_configuration = base_config
configuration.dbhost = 'postgres'
configuration.dbusr = '******'
configuration.dbpwd = 'clave_ladm_col'
configuration.database = 'ladm_col'
configuration.epsg = DEFAULT_EPSG
configuration.inheritance = LADMNames.DEFAULT_INHERITANCE
configuration.create_basket_col = LADMNames.CREATE_BASKET_COL
configuration.create_import_tid = LADMNames.CREATE_IMPORT_TID
configuration.stroke_arcs = LADMNames.STROKE_ARCS
configuration.dbschema = 'test_import_data'
configuration.delete_data = True
configuration.ilimodels = ';'.join([
LADMNames.SUPPORTED_LADM_MODEL, LADMNames.SUPPORTED_SNR_DATA_MODEL,
LADMNames.SUPPORTED_SUPPLIES_MODEL,
LADMNames.SUPPORTED_SUPPLIES_INTEGRATION_MODEL,
LADMNames.SUPPORTED_OPERATION_MODEL, LADMNames.SUPPORTED_ANT_MODEL,
LADMNames.SUPPORTED_CADASTRAL_FORM_MODEL,
LADMNames.SUPPORTED_VALUATION_MODEL
])
importer = iliimporter.Importer(dataImport=True)
importer.tool = DbIliMode.ili2pg
importer.configuration = configuration
importer.configuration.xtffile = testdata_path(
'xtf/test_ladm_col_queries_v2.9.6.xtf')
self.assertEqual(importer.run(), iliimporter.Importer.SUCCESS)
generator = Generator(
DbIliMode.ili2pg, 'dbname={} user={} password={} host={}'.format(
configuration.database, configuration.dbusr,
configuration.dbpwd, configuration.dbhost),
configuration.inheritance, importer.configuration.dbschema)
available_layers = generator.layers()
self.assertEqual(len(available_layers), 189)
res, code, msg = db_pg.test_connection()
self.assertTrue(res, msg)
test_layer = self.qgis_utils.get_layer(db_pg,
db_pg.names.OP_BOUNDARY_POINT_T,
load=True)
self.assertEqual(test_layer.featureCount(), 390)
db_pg.conn.close()
def setUp(self):
restore_schema(SCHEMA_LADM_COL_EMPTY, True)
self.db_pg = get_pg_conn(SCHEMA_LADM_COL_EMPTY)
self.names = self.db_pg.names
self.ladm_data = LADMData()
self.geometry = GeometryUtils()
res, code, msg = self.db_pg.test_connection()
self.assertTrue(res, msg)
self.assertIsNotNone(self.names.LC_BOUNDARY_POINT_T, 'Names is None')
def setUpClass(cls):
cls.app = AppInterface()
cls.db_gpkg = get_copy_gpkg_conn('test_ladm_survey_model_gpkg')
print("INFO: Restoring databases to be used")
restore_schema('test_ladm_col')
cls.db_pg = get_pg_conn('test_ladm_col')
schema = 'test_ladm_col'
reset_db_mssql(schema)
restore_schema_mssql(schema)
cls.db_mssql = get_mssql_conn(schema)
def test_import_data_in_pg(self):
print("\nINFO: Validate Import Data in PG...")
restore_schema('test_import_data')
db_pg = get_pg_conn('test_import_data')
base_config = BaseConfiguration()
base_config.custom_model_directories = testdata_path(MODELS_PATH)
base_config.custom_model_directories_enabled = True
configuration = ImportDataConfiguration()
configuration.base_configuration = base_config
configuration.dbhost = 'postgres'
configuration.dbusr = '******'
configuration.dbpwd = 'clave_ladm_col'
configuration.database = 'ladm_col'
configuration.srs_auth = DEFAULT_SRS_AUTH
configuration.srs_code = DEFAULT_SRS_CODE
configuration.inheritance = ILI2DBNames.DEFAULT_INHERITANCE
configuration.create_basket_col = ILI2DBNames.CREATE_BASKET_COL
configuration.create_import_tid = ILI2DBNames.CREATE_IMPORT_TID
configuration.stroke_arcs = ILI2DBNames.STROKE_ARCS
configuration.dbschema = 'test_import_data'
configuration.delete_data = True
configuration.ilimodels = ';'.join([self.ladmcol_models.model(LADMNames.LADM_COL_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(LADMNames.SURVEY_MODEL_KEY).full_name()])
importer = iliimporter.Importer(dataImport=True)
importer.tool = DbIliMode.ili2pg
importer.configuration = configuration
importer.configuration.xtffile = testdata_path('xtf/test_ladm_col_queries_v1_0.xtf')
self.assertEqual(importer.run(), iliimporter.Importer.SUCCESS)
generator = Generator(
DbIliMode.ili2pg,
'dbname={} user={} password={} host={}'.format(configuration.database, configuration.dbusr,
configuration.dbpwd, configuration.dbhost),
configuration.inheritance,
importer.configuration.dbschema)
available_layers = generator.layers()
self.assertEqual(len(available_layers), 156)
res, code, msg = db_pg.test_connection()
self.assertTrue(res, msg)
test_layer = self.app.core.get_layer(db_pg, db_pg.names.LC_BOUNDARY_POINT_T, load=True)
self.assertEqual(test_layer.featureCount(), 390)
db_pg.conn.close()
def test_pg_test_connection_bad_interlis_ladm_col_models(self):
print(
"\nINFO: Validate test_connection() for PostgreSQL (Bad Interlis, LADM-COL models)..."
)
print(
"\nINFO: All records for t_ili2db_attrname table where removed...")
restore_schema('bad_interlis_ladm')
db_pg = get_pg_conn('bad_interlis_ladm')
res, code, msg = db_pg.test_connection()
self.assertFalse(res, msg)
self.assertEqual(code, EnumTestConnectionMsg.DB_NAMES_INCOMPLETE)
db_pg.conn.close()
def setUpClass(cls):
print("INFO: Restoring databases to be used")
restore_schema('test_ladm_col_queries')
cls.db_pg = get_pg_conn('test_ladm_col_queries')
cls.ladm_queries = PGLADMQuery()
# Standardize query results: id's are removed because it depends on the database test data
standardize_query_results(expected_result_ladm_basic_query.copy())
standardize_query_results(expected_result_ladm_economic_query.copy())
standardize_query_results(expected_result_ladm_legal_query.copy())
standardize_query_results(expected_result_ladm_physical_query.copy())
standardize_query_results(expected_result_ladm_property_record_card_query.copy())
def setUpClass(cls):
print("\nINFO: Setting up copy CSV points to DB validation...")
print("INFO: Restoring databases to be used")
import_qgis_model_baker()
cls.qgis_utils = QGISUtils()
restore_schema(SCHEMA_LADM_COL_EMPTY)
cls.db_pg = get_pg_conn(SCHEMA_LADM_COL_EMPTY)
cls.names = cls.db_pg.names
import_asistente_ladm_col()
cls.ladm_data = LADM_DATA(cls.qgis_utils)
cls.geometry = GeometryUtils()
result = cls.db_pg.test_connection()
cls.assertTrue(result[0],
'The test connection is not working for empty db')
cls.assertIsNotNone(cls.names.OP_BOUNDARY_POINT_T, 'Names is None')
def test_pg_get_models(self):
print("\nINFO: Validate get models method() in postgres...")
expected_dict = {
'test_ladm_all_models': [
LADMNames.SUPPORTED_ANT_MODEL,
LADMNames.SUPPORTED_VALUATION_MODEL,
LADMNames.SUPPORTED_REFERENCE_CARTOGRAPHY,
LADMNames.SUPPORTED_SUPPLIES_MODEL,
LADMNames.SUPPORTED_SUPPLIES_INTEGRATION_MODEL,
LADMNames.SUPPORTED_SNR_DATA_MODEL,
LADMNames.SUPPORTED_CADASTRAL_FORM_MODEL,
LADMNames.SUPPORTED_OPERATION_MODEL,
LADMNames.SUPPORTED_ISO_CARTESIAN_COORDINATES,
LADMNames.SUPPORTED_LADM_MODEL
],
'test_ladm_integration': [
LADMNames.SUPPORTED_SNR_DATA_MODEL,
LADMNames.SUPPORTED_SUPPLIES_INTEGRATION_MODEL,
LADMNames.SUPPORTED_SUPPLIES_MODEL,
LADMNames.SUPPORTED_ISO_CARTESIAN_COORDINATES,
LADMNames.SUPPORTED_LADM_MODEL
],
'test_ladm_operation_model': [
LADMNames.SUPPORTED_OPERATION_MODEL,
LADMNames.SUPPORTED_SNR_DATA_MODEL,
LADMNames.SUPPORTED_SUPPLIES_INTEGRATION_MODEL,
LADMNames.SUPPORTED_SUPPLIES_MODEL,
LADMNames.SUPPORTED_ISO_CARTESIAN_COORDINATES,
LADMNames.SUPPORTED_LADM_MODEL
],
'test_ladm_cadastral_manager_data': [
LADMNames.SUPPORTED_SUPPLIES_MODEL,
LADMNames.SUPPORTED_ISO_CARTESIAN_COORDINATES
]
}
for schema_name in expected_dict:
restore_schema(schema_name)
self.db_pg = get_pg_conn(schema_name)
model_names = self.db_pg.get_models()
self.assertEqual(set(expected_dict[schema_name]), set(model_names))
self.db_pg.conn.close()
def test_pg_get_models(self):
print("\nINFO: Validate get models method() in postgres...")
expected_dict = {
'test_ladm_all_models': [
self.ladmcol_models.model(
LADMNames.VALUATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.CADASTRAL_CARTOGRAPHY_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SURVEY_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.ISO19107_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.LADM_COL_MODEL_KEY).full_name()
],
'test_ladm_integration': [
self.ladmcol_models.model(
LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.ISO19107_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.LADM_COL_MODEL_KEY).full_name()
],
'test_ladm_survey_model': [
self.ladmcol_models.model(
LADMNames.SURVEY_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SNR_DATA_SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_INTEGRATION_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.ISO19107_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.LADM_COL_MODEL_KEY).full_name()
],
'test_ladm_cadastral_manager_data': [
self.ladmcol_models.model(
LADMNames.SUPPLIES_MODEL_KEY).full_name(),
self.ladmcol_models.model(
LADMNames.ISO19107_MODEL_KEY).full_name()
]
}
for schema_name in expected_dict:
restore_schema(schema_name)
self.db_pg = get_pg_conn(schema_name)
res, code, msg = self.db_pg.test_connection()
self.assertTrue(res, msg)
model_names = self.db_pg.get_models()
print(model_names, expected_dict[schema_name])
self.assertEqual(set(expected_dict[schema_name]), set(model_names))
self.db_pg.conn.close()
def setUpClass(cls):
print("INFO: Restoring databases to be used")
restore_schema('test_ladm_cadastral_manager_data')
cls.db_pg = get_pg_conn('test_ladm_cadastral_manager_data')
cls.db_gpkg = get_gpkg_conn('test_ladm_cadastral_manager_data_gpkg')
def setUpClass(cls):
print("INFO: Restoring databases to be used")
restore_schema('test_ladm_reference_cartography')
cls.db_pg = get_pg_conn('test_ladm_reference_cartography')
cls.db_gpkg = get_gpkg_conn('test_ladm_reference_cartography_gpkg')
def setUpClass(cls):
print("INFO: Restoring databases to be used")
restore_schema('test_ladm_ant')
cls.db_pg = get_pg_conn('test_ladm_ant')
cls.db_gpkg = get_gpkg_conn('test_ladm_ant_gpkg')
def get_connector(cls) -> DBConnector:
return get_pg_conn(cls.schema)
def setUpClass(cls):
print("INFO: Restoring databases to be used")
restore_schema('test_ladm_col_queries')
cls.db_pg = get_pg_conn('test_ladm_col_queries')
