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())
