def test_basic(self) -> None: """Test values.""" from pineboolib.application.database import pnsqlcursor from pineboolib.application.qsatypes import date cursor = pnsqlcursor.PNSqlCursor("flupdates") cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() date_ = date.Date() cursor.setValueBuffer("fecha", date_) cursor.setValueBuffer("hora", "00:00:01") cursor.setValueBuffer("nombre", "nombre de prueba") cursor.setValueBuffer("modulesdef", "module_1\nmodule_2\nmodule_3") cursor.setValueBuffer("filesdef", "file_1\nfile_2\nfile_3") cursor.setValueBuffer("shaglobal", "1234567890") cursor.setValueBuffer("auxtxt", "aux_1\naux_2\naux_3") self.assertEqual(cursor.commitBuffer(), True) self.assertEqual( str(cursor.valueBuffer("fecha"))[0:8], str(date_)[0:8]) self.assertEqual(cursor.valueBuffer("hora"), "00:00:01") self.assertEqual(cursor.valueBuffer("nombre"), "nombre de prueba") cursor_2 = pnsqlcursor.PNSqlCursor("fltest3") cursor_2.setModeAccess(cursor_2.Insert) cursor_2.refreshBuffer() cursor_2.setValueBuffer("string_field", "Campo de prueba test_pnsqlcursor_test_basic") self.assertTrue(cursor_2.commitBuffer()) cursor_2.select() self.assertTrue(cursor_2.first()) self.assertTrue(cursor_2.valueBuffer("counter"), "000001") cursor_2.setModeAccess(cursor_2.Del) cursor_2.refreshBuffer() self.assertTrue(cursor_2.commitBuffer())
def test_cursor_asignment(self) -> None: """Test flformrecord cursor assignment""" from pineboolib.qsa import dictmodules from pineboolib.application.database import pnsqlcursor from pineboolib.fllegacy import systype import os qsa_sys = systype.SysType() path = fixture_path("principal.eneboopkg") self.assertTrue(os.path.exists(path)) qsa_sys.loadModules(path, False) application.PROJECT.actions["flareas"].load() cursor_1 = pnsqlcursor.PNSqlCursor("flareas") cursor_1.select() cursor_1.setModeAccess(cursor_1.Insert) cursor_1.refreshBuffer() cursor_1.editRecord(False) cursor_3 = pnsqlcursor.PNSqlCursor("flareas") module_ = dictmodules.from_project("formRecordflareas") self.assertTrue(module_) cursor_2 = module_.cursor() self.assertNotEqual(cursor_1, cursor_3) self.assertEqual(cursor_1, cursor_2)
def test_basic_1(self) -> None: """Basic tests 1.""" from pineboolib import application from pineboolib.application.database import pnsqlcursor cursor = pnsqlcursor.PNSqlCursor("fltest") cursor2 = pnsqlcursor.PNSqlCursor( "flareas", True, application.PROJECT.conn_manager.mainConn()) self.assertEqual(cursor.table(), "fltest") action = cursor.action() action2 = cursor2.action() self.assertTrue(action) if action is None: raise Exception("action is None!") if action2 is None: raise Exception("action2 is None!") self.assertEqual(cursor.actionName(), "fltest") self.assertTrue(cursor.setAction(action)) self.assertTrue(cursor.setAction(action2)) cursor3 = pnsqlcursor.PNSqlCursor("fltest") cursor3.setMainFilter("id > 1") cursor3.select() cursor3.refresh() self.assertEqual(cursor3.mainFilter(), "id > 1") cursor3.refreshBuffer() self.assertEqual(cursor3.valueBuffer("id"), cursor3.valueBufferCopy("id")) self.assertEqual(cursor3.baseFilter(), "id > 1") # self.assertFalse(cursor3.meta_model()) self.assertFalse(cursor3.inTransaction()) self.assertTrue(cursor3.commit()) cursor3.refreshBuffer() cursor4 = pnsqlcursor.PNSqlCursor("flareas", "default") cursor = pnsqlcursor.PNSqlCursor("flareas") cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() cursor.setValueBuffer("bloqueo", True) cursor.setValueBuffer("idarea", "T") cursor.setValueBuffer("descripcion", "Área de prueba T") self.assertTrue(cursor.commitBuffer()) cursor4.select() cursor4.first() cursor4.setModeAccess(cursor4.Edit) cursor4.refreshBuffer() self.assertFalse(cursor4.isNull("idarea")) self.assertFalse(cursor4.isCopyNull("idarea"))
def test_basic_2(self) -> None: """Test Deleteting.""" from pineboolib.application.database import pnsqlcursor from pineboolib.qsa import qsa cursor = pnsqlcursor.PNSqlCursor("fltest") cursor.select() self.assertEqual(cursor.size(), 100) cursor.select("string_field ='Linea 10'") self.assertEqual(cursor.size(), 1) self.assertTrue(cursor.first()) cursor.setModeAccess(cursor.Edit) self.assertTrue(cursor.refreshBuffer()) cursor.setValueBuffer("string_field", "Linea 10 m.") qsa.FLUtil().sqlDelete("fltest", "string_field='Linea 10'") cursor_2 = pnsqlcursor.PNSqlCursor("fltest") cursor_2.select() self.assertEqual(cursor_2.size(), 99) self.assertTrue(cursor.commitBuffer()) cursor.select("string_field ='Linea 9'") self.assertEqual(cursor.size(), 1) self.assertTrue(cursor.first()) cursor.setModeAccess(cursor.Edit) self.assertTrue(cursor.refreshBuffer()) cursor.setValueBuffer("string_field", "Linea 9 m.") self.assertTrue(cursor.commitBuffer()) cursor.refresh() self.assertEqual(cursor.size(), 99) cursor_3 = pnsqlcursor.PNSqlCursor("fltest") cursor_3.select() i = 0 size = 99 while cursor_3.next(): if i == 10: qsa.FLUtil().sqlDelete("fltest", "string_field='Linea 20'") size -= 1 i += 1 self.assertTrue( cursor_3.valueBuffer("string_field").find("Linea %s" % i) > -1) self.assertEqual(cursor_3.size(), 99) i += 1 cursor_3.refresh() self.assertEqual(cursor_3.size(), 98)
def test_full(self) -> None: """Test full.""" self._transaction_begin = False self._transaction_end = False self._transaction_roll_back = False from pineboolib.application.database import pnsignals from pineboolib.application.database import pnsqlcursor signals = pnsignals.PNSignals() signals.notify_begin_transaction_ = True signals.notify_end_transaction_ = True signals.notify_roll_back_transaction_ = True cursor = pnsqlcursor.PNSqlCursor("test") cursor.transactionBegin.connect(self.mark_transaction_begin) cursor.transactionEnd.connect(self.mark_transaction_end) cursor.transactionRollBack.connect(self.mark_transaction_roll_back) signals.emitTransactionBegin(cursor) signals.emitTransactionEnd(cursor) signals.emitTransactionRollback(cursor) self.assertTrue(self._transaction_begin) self.assertTrue(self._transaction_end) self.assertTrue(self._transaction_roll_back)
def test_basic5(self) -> None: """Basic test 5.""" conn_manager = application.PROJECT.conn_manager conn_ = conn_manager.mainConn() cursor = pnsqlcursor.PNSqlCursor("flareas") conn_.doTransaction(cursor) cursor.setModeAccess(cursor.Insert) cursor.setValueBuffer("idarea", "test") cursor.setValueBuffer("bloqueo", "false") cursor.setValueBuffer("descripcion", "test area") cursor.commitBuffer() conn_.doRollback(cursor) conn_.doTransaction(cursor) cursor.setModeAccess(cursor.Insert) cursor.setValueBuffer("idarea", "test") cursor.setValueBuffer("bloqueo", "false") cursor.setValueBuffer("descripcion", "test area") cursor.commitBuffer() conn_.doCommit(cursor, False) conn_.canRegenTables() self.assertEqual( conn_.tables(1)[0:3], ["flareas", "flfiles", "flgroups"]) self.assertEqual(conn_.tables(2), ["sqlite_master"]) self.assertEqual(conn_.tables(3), []) if settings.config.value("ebcomportamiento/orm_enabled", False): self.assertTrue(conn_.session()) self.assertTrue(conn_.engine()) self.assertTrue(conn_.declarative_base()) self.assertFalse(conn_.port()) self.assertFalse(conn_.returnword())
def del_( self, cur_or_table: Union[str, "isqlcursor.ISqlCursor"], where: str = "", conn_name: str = "default", ): """Remove a recordset from a cursor.""" cur: "isqlcursor.ISqlCursor" if not isinstance(cur_or_table, str): cur = cur_or_table else: cur = pnsqlcursor.PNSqlCursor(cur_or_table, True, conn_name) act_check = cur.activatedCheckIntegrity() cur.select(where) if cur.first(): while True: cur.setModeAccess(cur.Del) cur.refreshBuffer() cur.setActivatedCheckIntegrity(False) res_commit = cur.commitBuffer() cur.setActivatedCheckIntegrity(act_check) if not res_commit: return False if not cur.next(): break return True
def test_date_result(self) -> None: """Test date values.""" cursor = pnsqlcursor.PNSqlCursor("fltest") cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() self.assertTrue(cursor.commitBuffer()) cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() cursor.setValueBuffer("date_field", "2020-01-01") self.assertTrue(cursor.commitBuffer()) cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() self.assertTrue(cursor.commitBuffer()) cursor.commit() qry = pnsqlquery.PNSqlQuery() qry.setSelect("date_field") qry.setFrom("fltest") qry.setWhere("1=1") self.assertTrue(qry.exec_()) self.assertTrue(qry.next()) self.assertTrue(qry.isNull("date_field")) self.assertEqual(qry.value(0), "") self.assertEqual(qry.value("date_field"), "") self.assertTrue(qry.next()) self.assertFalse(qry.isNull("date_field")) self.assertEqual(str(qry.value(0)), "2020-01-01T00:00:00") self.assertEqual(str(qry.value("date_field")), "2020-01-01T00:00:00") self.assertTrue(qry.next()) self.assertTrue(qry.isNull("date_field")) self.assertEqual(qry.value(0), "") self.assertEqual(qry.value("date_field"), "")
def test_basic(self) -> None: """Basic test.""" cursor = pnsqlcursor.PNSqlCursor("fltest") cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() cursor.setValueBuffer("string_field", "Campo texto 1") cursor.setValueBuffer("date_field", "2019-01-01") cursor.setValueBuffer("time_field", "01:01:01") cursor.setValueBuffer("bool_field", False) cursor.setValueBuffer("double_field", 1.01) cursor.commitBuffer() cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() cursor.setValueBuffer("string_field", "Campo texto 2") cursor.setValueBuffer("date_field", "2019-02-02T00:00:00") cursor.setValueBuffer("time_field", "02:02:02.1234") cursor.setValueBuffer("bool_field", "true") cursor.setValueBuffer("double_field", 2.02) cursor.commitBuffer() cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() cursor.setValueBuffer("string_field", "Campo texto 3") cursor.setValueBuffer("date_field", "2019-03-03") cursor.setValueBuffer("time_field", "2019-03-03T03:03:03 +2") cursor.setValueBuffer("bool_field", "false") cursor.setValueBuffer("double_field", 3.03) cursor.commitBuffer()
def test_basic4(self) -> None: """Basic test 4.""" cursor = pnsqlcursor.PNSqlCursor("fltest") cursor.select() cursor.first() buffer_ = cursor.buffer() if buffer_ is None: raise Exception("buffer is empty!.") self.assertEqual(buffer_.pK(), "id") self.assertEqual(buffer_.indexField("string_field"), 1) field_ = buffer_.field("bool_field") if field_ is None: raise Exception("field_ is empty!.") self.assertEqual(field_.name, "bool_field") cursor_2 = buffer_.cursor() self.assertTrue(cursor_2) self.assertFalse(buffer_.field("new_field"))
def test_basic_1(self) -> None: """Basic test 1.""" cursor = pnsqlcursor.PNSqlCursor("fltest") cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() cursor.setValueBuffer("string_field", "xxx") cursor.setValueBuffer("double_field", 0.02) cursor.setValueBuffer("date_field", "2019-01-01") cursor.commitBuffer() cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() cursor.setValueBuffer("string_field", "zzz") cursor.setValueBuffer("double_field", 0.01) cursor.commitBuffer() cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() cursor.setValueBuffer("string_field", "yyy") cursor.setValueBuffer("double_field", 0.03) # cursor.setValueBuffer("check_field", True) cursor.commitBuffer() cursor.setSort("string_field ASC") self.assertEqual(cursor.currentRegister(), 2) cursor.select() self.assertTrue(cursor.last()) self.assertEqual(cursor.valueBuffer("string_field"), "zzz") self.assertEqual(cursor.valueBuffer("double_field"), 0.01) cursor.prev() self.assertEqual(cursor.valueBuffer("string_field"), "yyy")
def test_basic(self) -> None: """Delete data from a database.""" cursor = pnsqlcursor.PNSqlCursor("flareas") cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() cursor.setValueBuffer("bloqueo", True) cursor.setValueBuffer("idarea", "T") cursor.setValueBuffer("descripcion", "Área de prueba T") self.assertTrue(cursor.commitBuffer()) cursor.select("idarea ='T'") first_result = cursor.first() self.assertEqual(first_result, True) size_1 = cursor.size() self.assertEqual(size_1, 1) cursor.setModeAccess(cursor.Del) cursor.refreshBuffer() value_idarea = cursor.valueBuffer("idarea") self.assertEqual(value_idarea, "T") cursor.commitBuffer() size_2 = cursor.size() self.assertEqual(size_2, 1) cursor.refresh() size_3 = cursor.size() self.assertEqual(size_3, 0)
def setContent(self, file_name: str, id_module: str, content: str) -> None: """ Store the contents of a file in a given module. @param file_name File name. @param id_module Identifier of the module to which the file will be associated @param content File content. """ format_val = (self.conn_.connManager().manager().formatAssignValue( "nombre", "string", file_name, True)) format_val2 = (self.conn_.connManager().manager().formatAssignValue( "idmodulo", "string", id_module, True)) cursor = pnsqlcursor.PNSqlCursor("flfiles", True, "dbAux") cursor.setActivatedCheckIntegrity(False) cursor.select("%s AND %s" % (format_val, format_val2)) if cursor.first(): cursor.setModeAccess(cursor.Edit) cursor.refreshBuffer() else: cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() cursor.setValueBuffer("nombre", file_name) cursor.setValueBuffer("idmodulo", id_module) cursor.setValueBuffer("contenido", content) cursor.setValueBuffer("sha", flutil.FLUtil().sha1(content)) cursor.commitBuffer()
def test_basic_relations_1(self) -> None: """Test basic relations 1.""" from pineboolib.application.database import pnsqlcursor from pineboolib.application.metadata import pnrelationmetadata cur_areas = pnsqlcursor.PNSqlCursor("flareas") cursor_6 = pnsqlcursor.PNSqlCursor("flareas") cursor_6.setModeAccess(cursor_6.Insert) cursor_6.refreshBuffer() cursor_6.setValueBuffer("bloqueo", True) cursor_6.setValueBuffer("idarea", "O") cursor_6.setValueBuffer("descripcion", "Área de prueba O") self.assertTrue(cursor_6.commitBuffer()) rel = pnrelationmetadata.PNRelationMetaData( "flareas", "idarea", pnrelationmetadata.PNRelationMetaData.RELATION_1M) rel.setField("idarea") cur_areas.select() cur_areas.first() self.assertEqual(cur_areas.valueBuffer("idarea"), "O") cur_areas.setModeAccess(cur_areas.Edit) cur_areas.refreshBuffer() cur_modulos = pnsqlcursor.PNSqlCursor("flmodules", True, "default", cur_areas, rel) cur_modulos.select() cur_modulos.refreshBuffer() cur_rel = cur_modulos.cursorRelation() if cur_rel: self.assertEqual(cur_rel.valueBuffer("idarea"), "O") self.assertFalse(cur_areas.isLocked()) self.assertFalse(cur_modulos.fieldDisabled("icono")) self.assertEqual(cur_modulos.msgCheckIntegrity(), "\nBuffer vacío o no hay metadatos") self.assertTrue(cur_modulos.isLocked()) cur_modulos.bufferSetNull("icono") cur_modulos.bufferCopySetNull("icono") self.assertTrue(cur_modulos.bufferCopyIsNull("icono")) cur_modulos.setModeAccess(cur_modulos.Insert) cur_modulos.refreshBuffer() cur_modulos.setValueBuffer("idmodulo", "TM") cur_modulos.setValueBuffer("descripcion", "Desc") self.assertEqual(cur_modulos.checkIntegrity(False), True) self.assertTrue(cur_modulos.commitBuffer()) self.assertTrue(cur_areas.rollback())
def threaded_function(self) -> None: """Threaded function.""" try: cur = pnsqlcursor.PNSqlCursor("flfiles") cur.select() except Exception: time.sleep(1) pnsqlcursor.CONNECTION_CURSORS[ application.PROJECT.conn_manager.session_id()].pop()
def test_limit_offset(self) -> None: """Test limit and offset clausules from a query.""" cursor = pnsqlcursor.PNSqlCursor("fltest") cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() self.assertTrue(cursor.commitBuffer()) cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() self.assertTrue(cursor.commitBuffer()) cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() self.assertTrue(cursor.commitBuffer()) cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() self.assertTrue(cursor.commitBuffer()) cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() self.assertTrue(cursor.commitBuffer()) cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() self.assertTrue(cursor.commitBuffer()) # 9 rows total! cursor.commit() qry_one = pnsqlquery.PNSqlQuery() qry_one.setSelect("date_field") qry_one.setFrom("fltest") qry_one.setWhere("1 = 1") qry_one.setLimit(4) self.assertTrue(qry_one.exec_()) self.assertTrue(qry_one.sql().lower().find("limit") > -1) self.assertEqual(qry_one.size(), 4) qry_two = pnsqlquery.PNSqlQuery() qry_two.setSelect("date_field") qry_two.setFrom("fltest") qry_two.setWhere("1 = 1") qry_two.setLimit(100) qry_two.setOffset(7) self.assertTrue(qry_two.exec_()) self.assertTrue(qry_two.sql().lower().find("offset") > -1) self.assertEqual(qry_two.size(), 2) # 7 + 2 = 9 rows qry_tree = pnsqlquery.PNSqlQuery() qry_tree.setSelect("date_field") qry_tree.setFrom("fltest") qry_tree.setWhere("1 = 1") qry_tree.setOrderBy("date_field") qry_tree.setOffset(5) self.assertTrue(qry_tree.exec_()) sql = qry_tree.sql() self.assertTrue(sql.lower().find("offset") > -1) self.assertTrue(sql.lower().find("order by") > -1) self.assertEqual(qry_tree.size(), 4)
def test_basic_1(self) -> None: """Test Populate cursor.""" from pineboolib.application.database import pnsqlcursor cursor = pnsqlcursor.PNSqlCursor("fltest") for i in range(100): cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() cursor.setValueBuffer("string_field", "Linea %s" % i) self.assertTrue(cursor.commitBuffer())
def test_basic_3(self) -> None: """Basic tests 3.""" from pineboolib.application.database import pnsqlcursor cursor = pnsqlcursor.PNSqlCursor("fltest", "default") self.assertEqual(cursor.msgCheckIntegrity(), "\nBuffer vacío o no hay metadatos") self.assertFalse(cursor.checkIntegrity(False)) cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() self.assertEqual(cursor.msgCheckIntegrity(), "") self.assertTrue(cursor.checkIntegrity(False)) self.assertFalse(cursor.cursorRelation()) cursor3 = pnsqlcursor.PNSqlCursor("flareas") cursor3.setModeAccess(cursor.Insert) cursor3.refreshBuffer() cursor3.setValueBuffer("bloqueo", True) cursor3.setValueBuffer("idarea", "T") cursor3.setValueBuffer("descripcion", "Área de prueba T") self.assertTrue(cursor3.commitBuffer()) cursor2 = pnsqlcursor.PNSqlCursor("flareas") cursor2.select() self.assertTrue(cursor2.first()) cursor2.setUnLock("bloqueo", True) self.assertFalse(cursor2.isLocked()) cursor2.setUnLock("bloqueo", False) self.assertFalse(cursor2.isLocked()) cursor2.setModeAccess(cursor2.Del) cursor2.refreshBuffer() self.assertTrue(cursor2.commitBuffer()) self.assertEqual(cursor2.curFilter(), "") cursor2.setFilter("bloqueo = true") self.assertEqual(cursor2.curFilter(), "bloqueo = true") cursor2.setSort("bloqueo ASC")
def test_parser_tools_1(self) -> None: """Test parser tools.""" from pineboolib.application.parsers.kugarparser import kparsertools from pineboolib.core.utils.utils_base import load2xml from pineboolib.application.database import pnsqlquery, pnsqlcursor from pineboolib.qsa import qsa import datetime import os qry = pnsqlquery.PNSqlQuery() qry.setTablesList("paises") qry.setSelect("codpais, bandera") qry.setFrom("paises") qry.setWhere("1=1") self.assertTrue(qry.exec_()) self.assertTrue(qry.first()) data = qsa.sys.toXmlReportData(qry) parser_tools = kparsertools.KParserTools() xml_data = load2xml(data.toString()).getroot() child = xml_data.findall("Row")[0] element = parser_tools.convertToNode(child) self.assertTrue(element) fecha_ = str( datetime.date.__format__(datetime.date.today(), "%d.%m.%Y")) self.assertEqual(parser_tools.getSpecial("Fecha"), fecha_) self.assertEqual(parser_tools.getSpecial("[Date]"), fecha_) self.assertEqual(parser_tools.getSpecial("NúmPágina", 1), "1") self.assertEqual(parser_tools.getSpecial("PageNo", 6), "6") self.assertEqual(parser_tools.getSpecial("[NúmPágina]", 12), "12") from PyQt5 import QtCore ret_ = QtCore.QLocale.system().toString(float("11.22"), "f", 2) self.assertEqual(parser_tools.calculated("11.22", 2, 2), ret_) self.assertEqual(parser_tools.calculated("2019-01-31T00:01:02", 3), "31-01-2019") self.assertEqual(parser_tools.calculated("codpais", 1, None, child), "ES") cur = pnsqlcursor.PNSqlCursor("paises") cur.select("1=1") cur.first() buffer = cur.buffer() if buffer: bandera = buffer.value("bandera") self.assertEqual( parser_tools.parseKey(str(bandera)), os.path.abspath("%s/%s.png" % (application.PROJECT.tmpdir, bandera)), )
def test_basic1(self) -> None: """Basic test 1.""" global USER_ID USER_ID = "usu0" application.PROJECT.set_session_function(self.user_id) conn_manager = application.PROJECT.conn_manager self.assertEqual(conn_manager.session_id(), USER_ID) cursor_1 = pnsqlcursor.PNSqlCursor("flfiles") # noqa: F841 self.assertEqual(conn_manager.session_id(), "usu0") self.assertEqual(conn_manager.active_pncursors(True), ["flfiles"])
def test_basic(self) -> None: """Insert data into a database.""" cursor = pnsqlcursor.PNSqlCursor("flareas") cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() cursor.setValueBuffer("bloqueo", True) cursor.setValueBuffer("idarea", "T") cursor.setValueBuffer("descripcion", "Área de prueba T") self.assertTrue(cursor.commitBuffer()) mode_access = cursor.modeAccess() self.assertEqual(mode_access, cursor.Edit)
def test_basic_2(self) -> None: """Basic tests 2.""" from pineboolib.application.database import pnsqlcursor cursor = pnsqlcursor.PNSqlCursor("flareas") cursor.setModeAccess(cursor.Insert) cursor.refreshBuffer() cursor.setValueBuffer("bloqueo", True) cursor.setValueBuffer("idarea", "X") cursor.setValueBuffer("descripcion", "Área de prueba X") self.assertTrue(cursor.commitBuffer()) cursor = pnsqlcursor.PNSqlCursor("flareas", "default") cursor.select() cursor.first() cursor.setModeAccess(cursor.Edit) self.assertFalse(cursor.isModifiedBuffer()) cursor.setValueBuffer("descripcion", "Descripcion de prueba para a") self.assertTrue(cursor.isModifiedBuffer()) cursor2 = pnsqlcursor.PNSqlCursor("flmodules", "default") cursor2.setAskForCancelChanges(False) cursor2.setActivatedCheckIntegrity(False) cursor2.setActivatedCommitActions(False) self.assertFalse(cursor2.activatedCommitActions()) cursor2.setModeAccess(cursor2.Insert) cursor2.refreshBuffer() cursor2.setValueBuffer("idmodulo", "Z") cursor2.setValueBuffer("descripcion", "Esta es la descripción") cursor2.setValueBuffer("version", "0.0") cursor2.commitBuffer() cursor2.select('idmodulo = "Z"') cursor2.first() cursor2.setModeAccess(cursor2.Del) cursor2.refreshBuffer() cursor2.commitBuffer()
def test_basic2(self) -> None: """Basic test 2.""" global USER_ID USER_ID = "usu1" conn_manager = application.PROJECT.conn_manager self.assertEqual(conn_manager.session_id(), "usu1") self.assertEqual(conn_manager.active_pncursors(True), []) cursor_1 = pnsqlcursor.PNSqlCursor("flfiles") # noqa: F841 self.assertEqual(conn_manager.active_pncursors(True), ["flfiles"]) self.assertTrue("flfiles" in conn_manager.active_pncursors(True, True)) USER_ID = "usu2" self.assertEqual(conn_manager.session_id(), "usu2") self.assertEqual(conn_manager.active_pncursors(True), []) cursor_2 = pnsqlcursor.PNSqlCursor("flfiles") # noqa: F841 cursor_3 = pnsqlcursor.PNSqlCursor("flareas") # noqa: F841 self.assertEqual(conn_manager.active_pncursors(True), ["flfiles", "flareas"]) self.assertTrue(len(conn_manager.active_pncursors(True, True)) > 2) USER_ID = "usu1" self.assertEqual(conn_manager.active_pncursors(True), ["flfiles"]) self.assertTrue(len(conn_manager.active_pncursors(True, True)) > 2)
def test_basic_4(self) -> None: """Basic tests 4.""" from pineboolib.application.database import pnsqlcursor cursor_fake = pnsqlcursor.PNSqlCursor("fake") self.assertFalse(cursor_fake._valid) self.assertFalse(cursor_fake.isModifiedBuffer()) self.assertTrue(cursor_fake.activatedCheckIntegrity()) self.assertEqual(cursor_fake.checkIntegrity(False), False) self.assertEqual(cursor_fake.table(), "") self.assertEqual(cursor_fake.mainFilter(), "") cursor_fake.setValueBuffer("no_field", "XXX") self.assertFalse(cursor_fake.valueBuffer("no_field")) cursor = pnsqlcursor.PNSqlCursor("fltest") self.assertTrue(cursor._valid) cursor_2 = pnsqlcursor.PNSqlCursor("flareas") cursor_2.select() cursor_2.first() cursor_2.setModeAccess(cursor_2.Insert) self.assertFalse(cursor_2.fieldDisabled("descripcion")) cursor_2.refreshBuffer() self.assertEqual( cursor_2.msgCheckIntegrity(), "\nflareas:Área : No puede ser nulo\nflareas:Descripción : No puede ser nulo", ) self.assertEqual(cursor_2.valueBuffer("descripcion"), cursor_2.valueBufferCopy("descripcion")) self.assertTrue(cursor_2.field("idarea")) buffer = cursor_2.buffer() if buffer: self.assertTrue(buffer.isGenerated("idarea")) cursor_2.setEdition(True, "prueba") self.assertTrue(cursor_2.private_cursor.edition_states_) cursor_2.restoreEditionFlag("prueba") cursor_2.setBrowse(True, "prueba2") self.assertTrue(cursor_2.private_cursor.browse_states_) cursor_2.restoreBrowseFlag("prueba2")
def test_basic_1(self) -> None: """Test fetchmoderows 1.""" from pineboolib.application.database import pnsqlcursor cur_test = pnsqlcursor.PNSqlCursor("fltest") size = 2102 for i in range(size): cur_test.setModeAccess(cur_test.Insert) self.assertTrue(cur_test.refreshBuffer()) cur_test.setValueBuffer("string_field", "Registro %s" % i) self.assertTrue(cur_test.commitBuffer()) self.assertEqual(cur_test.size(), size)
def testSetAcosCondition(self) -> None: """Test setAcosCondition.""" from pineboolib.application.database import pnsqlcursor cur_grupos = pnsqlcursor.PNSqlCursor("flgroups") cur_grupos.setModeAccess(cur_grupos.Insert) cur_grupos.refreshBuffer() cur_grupos.setValueBuffer("idgroup", "a") cur_grupos.setValueBuffer("descripcion", "desc a") cur_grupos.commitBuffer() cur_grupos.setModeAccess(cur_grupos.Insert) cur_grupos.refreshBuffer() cur_grupos.setValueBuffer("idgroup", "b") cur_grupos.setValueBuffer("descripcion", "desc b") cur_grupos.commitBuffer() cur_grupos.setModeAccess(cur_grupos.Insert) cur_grupos.refreshBuffer() cur_grupos.setValueBuffer("idgroup", "c") cur_grupos.setValueBuffer("descripcion", "desc c") cur_grupos.commitBuffer() cur_grupos.setModeAccess(cur_grupos.Insert) cur_grupos.refreshBuffer() cur_grupos.setValueBuffer("idgroup", "d") cur_grupos.setValueBuffer("descripcion", "desc d") cur_grupos.commitBuffer() cur_grupos.select() field = cur_grupos.metadata().field("descripcion") if field is None: raise Exception("field is None!") while cur_grupos.next(): self.assertTrue(field.editable()) cur_grupos.setAcTable("r-") cur_grupos.setAcosCondition("descripcion", cur_grupos.Value, "desc c") cur_grupos.select() while cur_grupos.next(): field_2 = cur_grupos.metadata().field("descripcion") if field_2 is None: raise Exception("field is None!") if cur_grupos.valueBuffer("descripcion") == "desc c": self.assertFalse(field_2.editable()) else: self.assertTrue(field_2.editable())
def initForm(self) -> None: """ Initialize the associated script. """ from pineboolib.fllegacy import flapplication acl = flapplication.aqApp.acl() if acl: acl.process(self) self.loadControls() if self._action is None: raise Exception("_action is empty!") if self._action.table(): if (not self.cursor_ or not self.cursor_._action or self.cursor_._action.table() is not self._action.table()): cursor = pnsqlcursor.PNSqlCursor(self._action.table()) self.setCursor(cursor) v = None preload_main_filter = getattr(self.iface, "preloadMainFilter", None) if preload_main_filter: v = preload_main_filter() if v is not None and self.cursor_: self.cursor_.setMainFilter(v, False) # if self._loaded and not self.__class__.__name__ == "FLFormRecordDB": # application.PROJECT.conn_manager.managerModules().loadFLTableDBs(self) if self._action.description() not in ("", None): self.setWhatsThis(self._action.description()) caption = self._action.caption() if caption in ("", None) and self.cursor_ and self.cursor_.metadata(): caption = self.cursor_.metadata().alias() if caption in ("", None): caption = QtWidgets.QApplication.translate( "FLFormDB", "No hay metadatos") self.setCaptionWidget(caption)
def test_basic_2(self) -> None: """Test fetchmoderows 2.""" from pineboolib.application.database import pnsqlcursor cur_test = pnsqlcursor.PNSqlCursor("fltest") cur_test.select() self.assertTrue(cur_test.first()) self.assertEqual(cur_test.valueBuffer("string_field"), "Registro 0") self.assertTrue(cur_test.next()) self.assertEqual(cur_test.valueBuffer("string_field"), "Registro 1") self.assertTrue(cur_test.last()) self.assertEqual(cur_test.valueBuffer("string_field"), "Registro 2101") self.assertTrue(cur_test.prev()) self.assertEqual(cur_test.valueBuffer("string_field"), "Registro 2100")
def test_basic_5(self) -> None: """Test basic 5.""" from PyQt5 import QtCore cursor = pnsqlcursor.PNSqlCursor("fltest2") model = cursor.model() model.disable_refresh(True) model.sort(1, QtCore.Qt.DescendingOrder) self.assertTrue(model._disable_refresh) model.disable_refresh(False) model.updateRows() cursor.select() model.updateColumnsCount() self.assertEqual(model.size(), 3)
def test_afterCommit_flFiles(self) -> None: """Test aftercommit_flfiles function.""" from pineboolib.application.database import pnsqlcursor cur_area = pnsqlcursor.PNSqlCursor("flareas") cur_area.setModeAccess(cur_area.Insert) cur_area.refreshBuffer() cur_area.setValueBuffer("idarea", "A") cur_area.setValueBuffer("descripcion", "area A") self.assertTrue(cur_area.commitBuffer()) _cur_modulo = pnsqlcursor.PNSqlCursor("flmodules") _cur_modulo.setModeAccess(_cur_modulo.Insert) _cur_modulo.refreshBuffer() _cur_modulo.setValueBuffer("idarea", "A") _cur_modulo.setValueBuffer("idmodulo", "TM") _cur_modulo.setValueBuffer("descripcion", "modulo TM") self.assertTrue(_cur_modulo.commitBuffer()) _cur = pnsqlcursor.PNSqlCursor("flfiles") _cur.setModeAccess(_cur.Insert) _cur.refreshBuffer() _cur.setValueBuffer("nombre", "prueba") _cur.setValueBuffer("idmodulo", "TM") _cur.setValueBuffer("contenido", "Pablito clavó un clavito!") self.assertTrue(_cur.commitBuffer())