def test_insertion(self): # type: () -> None """ Test the insert functions of class Well :return: Nothing :raises AssertionError: Raises AssertionError if a test fails """ wells = Well.load_all_from_db(self.session) marker_1 = WellMarker(301.43, StratigraphicObject.init_stratigraphy(self.session, "ku"), self.session, "Comment 1") marker_2 = WellMarker(351.65, StratigraphicObject.init_stratigraphy(self.session, "mo"), self.session) marker_3 = WellMarker(934.23, StratigraphicObject.init_stratigraphy(self.session, "mm"), self.session, "Comment 3") wells[0].insert_marker(marker_1) self.assertEqual(len(wells[0].marker), 6) self.assertEqual(wells[0].marker[5], marker_1) self.assertRaises(ValueError, wells[1].insert_marker, marker_3) wells[2].insert_multiple_marker([marker_1, marker_2]) self.assertEqual(len(wells[2].marker), 6) self.assertEqual(wells[2].marker[2], marker_1) self.assertEqual(wells[2].marker[4], marker_2) del wells wells = Well.load_all_from_db(self.session) self.assertEqual(wells[2].marker[2], marker_1) self.assertEqual(wells[2].marker[4], marker_2) del wells wells = Well.load_all_from_db(self.session) self.assertRaises(ValueError, wells[1].insert_multiple_marker, [marker_1, marker_2, marker_3])
def test_log_handling(self): # type: () -> None """ Tests the log handling functionality :return: Nothing :raises AssertionError: Raises AssertionError if a test fails """ log_values = ( ( (10, 4, "", ""), (15, "45.4", "name 1", "Comment 1"), (16, 34.3, "", ""), (17, 234, "", "Comment 2"), (5, "34.4", "", "Comment 3") ), ( (34.3, 4, "", ""), (13, 234, "", "Comment 2"), (34, "34.4", "", "Comment 3") ) ) well = Well.load_by_wellname_from_db("Well_2", self.session) for i in range(len(log_values)): log = WellLog("log {}".format(i), "unit name", self.session, "", "") log.save_to_db() well.add_log(log) for value in log_values[i]: log.insert_log_value(WellLogValue(value[0], value[1], self.session, value[2], value[3])) del log del well well = Well.load_by_wellname_from_db("Well_2", self.session) self.assertEqual(2, len(well.logs)) self.assertEqual(5, len(well.logs[0].log_values)) self.assertEqual("log 0", well.logs[0].property_name) self.assertEqual(3, len(well.logs[1].log_values)) self.assertEqual("log 1", well.logs[1].property_name) well.delete_log(well.logs[1]) del well well = Well.load_by_wellname_from_db("Well_2", self.session) self.assertEqual(1, len(well.logs)) self.assertEqual(5, len(well.logs[0].log_values)) self.assertEqual("log 0", well.logs[0].property_name) logs = WellLog.load_all_from_db(self.session) self.assertEqual(1, len(logs))
def test_loading(self): # type: () -> None """ Test the different types of loading of lines from the db. Part 1: load all wells from the database Part 2: load well by name Part 3: load wells in given extent Part 4: load wells with minimal depth :return: Nothing :raises AssertionError: Raises AssertionError if a test fails """ # Part 1: load all wells from the database wells = Well.load_all_from_db(self.session) self.assertEqual(len(wells), 3) self.assertEqual(wells[0].well_name, "Well_1") self.assertEqual(wells[1].well_name, "Well_2") self.assertEqual(wells[2].well_name, "Well_3") self.assertEqual(len(wells[1].marker), 4) self.assertTrue(wells[1].marker[0].horizon == wells[1].marker[3].horizon) del wells # Part 2: load well by name well = Well.load_by_wellname_from_db("Well_2", self.session) self.assertEqual(well.well_name, "Well_2") self.assertEqual(well.short_name, "W2") self.assertEqual(well.depth, 341) self.assertEqual(len(well.marker), 4) self.assertEqual(well.marker[1].horizon.statigraphic_name, "mm") self.assertEqual(well.marker[1].depth, 120) del well # Part 3: load wells in given extent # extent x: 500 - 1,300 # extent y: 0 - 2,400 # result: "Well_1" and "Well_2" wells = Well.load_in_extent_from_db(self.session, 500, 1300, 0, 2400) self.assertEqual(len(wells), 2) self.assertEqual(wells[0].well_name, "Well_1") self.assertEqual(wells[1].well_name, "Well_2") self.assertEqual(len(wells[0].marker), 5) self.assertEqual(len(wells[1].marker), 4) del wells # Part 4: load wells with minimal depth wells = Well.load_deeper_than_value_from_db(self.session, 395.23) self.assertEqual(len(wells), 2) self.assertEqual(wells[0].well_name, "Well_1") self.assertEqual(wells[1].well_name, "Well_3") self.assertTrue(wells[0].depth >= 395.23) self.assertTrue(wells[1].depth >= 395.23) del wells
def test_get_marker_by_depth(self): # type: () -> None """ Test the Well.get_marker_by_depth function :return: Nothing :raises AssertionError: Raises AssertionError if a test fails """ well = Well.load_by_wellname_from_db("Well_1", self.session) self.assertEqual(well.get_marker_by_depth(16).horizon.statigraphic_name, "sm") self.assertRaises(ValueError, well.get_marker_by_depth, 100)
def test_delete_marker(self): # type: () -> None """ Test the Well.get_marker_by_depth function :return: Nothing :raises AssertionError: Raises AssertionError if a test fails """ well = Well.load_by_wellname_from_db("Well_1", self.session) marker = well.get_marker_by_depth(16) self.assertEqual(marker.horizon.statigraphic_name, "sm") self.assertRaises(ValueError, well.get_marker_by_depth, 100) well.delete_marker(marker) well.save_to_db() self.assertEqual(len(well.marker), 4) del well well = Well.load_by_wellname_from_db("Well_1", self.session) self.assertEqual(len(well.marker), 4) new_marker = WellMarker(23423, StratigraphicObject.init_stratigraphy(self.session, "so"), self.session, "Nothing") self.assertRaises(ValueError, well.delete_marker, new_marker) self.assertRaises(TypeError, well.delete_marker, "test")
def setUp(self): # type: () -> None """ Initialise a temporary database connection for all test cases and fill the database with test data :return: None """ # initialise a in-memory sqlite database self.handler = DBHandler(connection="sqlite://", echo=False) self.session = self.handler.get_session() # add test data to the database self.well = { "well_name": "Well_1", "short_name": "W1", "reference": "none", "east": 1234.56, "north": 123.45, "altitude": 10.5, "depth": 555, "log_values": ((10, 4, "", ""), (15, "45.4", "name 1", "Comment 1"), (16, 34.3, "", ""), (17, 234, "", "Comment 2"), (5, "34.4", "", "Comment 3")) } well = Well(self.well["well_name"], self.well["short_name"], self.well["depth"], self.well["reference"], self.well["east"], self.well["north"], self.well["altitude"], self.session, "", "") well.save_to_db() logging = WellLog("logging", "unit name", self.session, "", "") logging.save_to_db() well.add_log(logging) for value in self.well["log_values"]: logging.insert_log_value(WellLogValue(value[0], value[1], self.session, value[2], value[3]))
def run(self): """ Save well logs to the database :return: Nothing, emits Qt Signals """ self._mutex.lock() service = DatabaseService.get_instance() service.close_session() service.connect() session = service.get_session() failed_imports = 0 try: onekey = self._data[next(iter(self._data.keys()))]["values"] # import json # self._logger.info(json.dumps(onekey, indent=2)) count = len(onekey) well_name_col = self._selection["well_name"] depth_col = self._selection["depth"] reference = ImportService.get_instance().get_crs() if reference is None: reference = "" else: reference = reference.toWkt() self._logger.debug("Saving with reference system\n{}".format(reference)) for i in range(count): self.update_progress.emit(100 * i / count) try: well_name = self._data[well_name_col]["values"][i] except ValueError: self._logger.warn("No well_name specified for current data set at line {}".format(i)) failed_imports += 1 continue if (well_name is None) or (well_name == ""): self._logger.warn("Unknown well name found: [{}]".format(well_name)) failed_imports += 1 continue try: well: Well = Well.load_by_wellname_from_db(well_name, session) if well is None: self._logger.warn("No well with name [{}] found...".format(well_name)) failed_imports += 1 continue well.reference_system = reference # add / update properties for item in self._properties: self._logger.debug("Property: {}".format(item)) if well.has_log(item.name): log = well.get_log(item.name) else: log = WellLog(property_name = item.name, property_unit = item.unit, session=session) well.add_log(log) depth = self._data[depth_col]["values"][i] value = self._data[item.name]["values"][i] try: log_value: WellLogValue = log.get_value_by_depth(depth) except ValueError: log_value = WellLogValue(depth, value, session=session) log_value.value = value log.insert_log_value(log_value) self._logger.debug("well: {}".format(well)) well.save_to_db() except DatabaseRequestException: self._logger.warn("Cannot find well with name [{}]. Skipping log import".format(well_name)) failed_imports += 1 if self._cancel: self._logger.debug("Import canceled") self.import_failed.emit(self._message) break if not self._cancel: if failed_imports > 0: self.import_finished_with_warnings.emit("Could not import {} properties.".format(failed_imports)) self.update_progress.emit(100) self.import_finished.emit() except Exception as e: msg = str(ExceptionHandler(e)) self.import_failed.emit(msg) self._logger.error("Error", msg, to_messagebar=True) finally: service.close_session() self._mutex.unlock() self.quit()
def run(self) -> bool: """ Save the Well Object(s) to the database :return: True if function executed successfully, else False """ self._mutex.lock() service = DatabaseService.get_instance() service.close_session() service.connect() session = DatabaseService.get_instance().get_session() try: onekey = self._data[next(iter(self._data.keys()))]["values"] count = len(onekey) name = self._selection["name"] short_name = self._selection["short_name"] east = self._selection["easting"] north = self._selection["northing"] alt = self._selection["altitude"] total_depth = self._selection["total_depth"] strat = self._selection["strat"] depth_to = self._selection["depth_to"] comment = self._selection["comment"] reference = ImportService.get_instance().get_crs() if reference is None: reference = "" else: reference = reference.toWkt() self._logger.debug("Saving with reference system\n{}".format(reference)) wells = dict() maximum = count for i in range(count): if (self._data[east]["values"][i] == "") and (self._data[north]["values"][i] == ""): continue na = self._data[name]["values"][i] sn = "" if short_name == "" else self._data[short_name]["values"][i] e = float(self._data[east]["values"][i]) n = float(self._data[north]["values"][i]) kb = None if alt == "" else float(self._data[alt]["values"][i]) td = -1 if total_depth == "" else float(self._data[total_depth]["values"][i]) s = "" if strat == "" else self._data[strat]["values"][i] dt = -1 if depth_to == "" else float(self._data[depth_to]["values"][i]) c = "" if comment == "" else self._data[comment]["values"][i] strat_obj = StratigraphicObject.init_stratigraphy(session, s, -1) strat_obj.save_to_db() marker = WellMarker(dt, strat_obj, session=session, comment=c) # marker.save_to_db() # point = GeoPoint(None, False if (h is None) else True, reference, # e, n, 0 if (h is None) else h, session, sn, c) if na in wells: wells[na]["marker"].append(marker) else: wells[na] = { "short_name": sn, "easting": e, "northing": n, "altitude": kb, "total_depth": td, "marker": [marker] } maximum += 1 if self._cancel: self._logger.debug("Import canceled") self.import_failed.emit(self._message) break self.update_progress.emit(100 * i / maximum) i = count if not self._cancel: for well_name in wells: i += 1 well = wells[well_name] new_well = Well.load_by_wellname_from_db(well_name, session) if new_well is not None: try: self._logger.debug("Updating existing well: {}".format(new_well)) for marker in new_well.marker: WellMarker.delete_from_db(marker, session) new_well.save_to_db() new_well.marker = well["marker"] new_well.short_name = well["short_name"] new_well.easting = well["easting"] new_well.northing = well["northing"] new_well.depth = well["total_depth"] except WellMarkerDepthException as e: self._logger.error("WellMarkerDepthException", "{}\n{}".format(new_well, str(e))) return False else: self._logger.debug("Creating new well with name [{}]".format(well_name)) new_well = Well(well_name, well["short_name"], well["total_depth"], reference_system=reference, easting=well["easting"], northing=well["northing"], altitude=well["altitude"], session=session) new_well.marker = well["marker"] new_well.save_to_db() self._logger.debug("Saved well:\n{}".format(new_well)) self.update_progress.emit(100 * i / maximum) if self._cancel: self._logger.debug("Import canceled") self.import_failed.emit(self._message) break if not self._cancel: self.update_progress.emit(100) self._logger.debug("Lines successfully imported") self.import_finished.emit() except Exception as e: msg = str(ExceptionHandler(e)) self.import_failed.emit(msg) self._logger.error("Error", msg) finally: service.close_session() self._mutex.unlock() self.quit()
def setUp(self): # type: () -> None """ Initialise a temporary database connection for all test cases and fill the database with test data :return: None """ # initialise a in-memory sqlite database self.handler = DBHandler(connection="sqlite://", echo=False) self.session = self.handler.get_session() # add test data to the database self.wells = [ { "name": "Well_1", "short_name": "W1", "comment": "A drilled well", "east": 1234.56, "north": 123.45, "altitude": 10.5, "depth": 555, "marker": ((10, "mu", 4, ""), (15, "so", 3, "Comment 1"), (16, "sm", 2, ""), (17, "su", 1, "Comment 2"), (5, "mm", 5, "Comment 3")) }, { "name": "Well_2", "short_name": "W2", "comment": "", "east": 1000.23, "north": 2300.34, "altitude": 342.23, "depth": 341, "marker": ((12, "mo", 6, ""), (120, "mm", 5, "Comment 1"), (300, "Fault", 0, "Comment 2"), (320, "mo", 6, "")) }, { "name": "Well_3", "short_name": "W3", "comment": "A third well", "east": 3454.34, "north": 2340.22, "altitude": 342.20, "depth": 645.21, "marker": ((34, "mu", 4, ""), (234, "so", 3, "Comment 1"), (345, "Fault", 0, "Comment 2"), (635, "mu", 4, "Comment 3")) } ] for well in self.wells: new_well = Well(well["name"], well["short_name"], well["depth"], "spatial_reference_unknown", well["east"], well["north"], well["altitude"], self.session, "well_set", well["comment"]) new_well.save_to_db() for mark in well["marker"]: new_well.marker.append( WellMarker(mark[0], StratigraphicObject.init_stratigraphy(self.session, mark[1], mark[2], False), self.session, well["name"], mark[3])) new_well.marker[-1].save_to_db()
def test_setter_and_getter(self): # type: () -> None """ Test setter and getter functionality :return: Nothing :raises AssertionError: Raises Assertion Error if a test fails """ # first part: test setter wells = Well.load_all_from_db(self.session) test_string = "abcdefghijklmnopqrstuvwxyz1234567890" wells[0].comment = "new comment set" wells[1].comment = 4 * test_string wells[0].easting = "-344.3" wells[1].easting = -1234.34 # self.assertRaises(ValueError, setattr, wells[2], "easting", "test") # python >= 2.7 => not included in all ArcGIS versions... with(self.assertRaises(ValueError)): # python <= 2.6 wells[2].easting = "test" wells[0].northing = -234.56 wells[1].northing = "-2345.356" with(self.assertRaises(ValueError)): wells[2].northing = "test" wells[0].altitude = -343.67 wells[1].altitude = "-235.34" with(self.assertRaises(ValueError)): wells[2].altitude = "test" wells[0].depth = 235.65 wells[1].depth = "3456.14" with(self.assertRaises(ValueError)): wells[2].depth = "test" with(self.assertRaises(ValueError)): wells[2].depth = -123.43 with(self.assertRaises(WellMarkerDepthException)): wells[2].depth = 500 wells[0].well_name = "new Well Name" wells[1].well_name = 4 * test_string wells[0].short_name = "NWN" wells[1].short_name = test_string # changes are stored automatically to the database through SQLAlchemy del wells # second part: test getters wells = Well.load_all_from_db(self.session) self.assertEqual(wells[0].comment, "new comment set") self.assertEqual(len(wells[1].comment), 100) self.assertEqual(wells[0].easting, -344.3) self.assertEqual(wells[1].easting, -1234.34) self.assertEqual(wells[2].easting, 3454.34) self.assertEqual(wells[0].northing, -234.56) self.assertEqual(wells[1].northing, -2345.356) self.assertEqual(wells[2].northing, 2340.22) self.assertEqual(wells[0].altitude, -343.67) self.assertEqual(wells[1].altitude, -235.34) self.assertEqual(wells[2].altitude, 342.2) self.assertEqual(wells[0].depth, 235.65) self.assertEqual(wells[1].depth, 3456.14) self.assertEqual(wells[2].depth, 645.21) self.assertEqual(wells[0].well_name, "new Well Name") self.assertEqual(len(wells[1].well_name), 100) self.assertEqual(wells[0].short_name, "NWN") self.assertEqual(len(wells[1].short_name), 20) # setter and getter for session wells[2].session = wells[1].session