def populate(cls, con, items, log=None):
log = log or LogManager().get_logger(
"turberfield.dialogue.schema.populate")
states = [i for i in items if type(i) is enum.EnumMeta]
entities = [i for i in items if i not in states]
rv = 0
for state in states:
for defn in state:
try:
Insertion(cls.tables["state"],
data={
"class": defn.__objclass__.__name__,
"name": defn.name,
"value": defn.value
}).run(con)
except sqlite3.IntegrityError as e:
log.warning(e)
con.rollback()
except Exception as e:
log.error(e)
con.rollback()
else:
rv += 1
for entity in entities:
try:
Insertion(cls.tables["entity"],
data={
"name":
getattr(
entity, "_name",
getattr(entity, "name",
entity.__class__.__name__))
}).run(con)
except sqlite3.IntegrityError as e:
log.warning(e)
con.rollback()
except Exception as e:
log.error(e)
con.rollback()
else:
rv += 1
return rv
def test_insert_entity(self):
expected = (
"insert into entity (name) values (:name)",
{"name": "qwerty"}
)
rv = Insertion(
SchemaBase.tables["entity"],
data=dict(
name="qwerty"
)
).sql
self.assertEqual(expected, rv)
def test_insert_entity(self):
expected = (
"insert into entity (session, name) values (:session, :name)",
{"session": "1234567890", "name": "qwerty"}
)
rv = Insertion(
schema["entity"],
data=dict(
session="1234567890",
name="qwerty"
)
).sql
self.assertEqual(expected, rv)
def test_primary_keys(self):
con = Connection(**Connection.options())
with con as db:
rv = Creation(schema["entity"]).run(db)
session=uuid.uuid4().hex
rv = Insertion(
schema["entity"],
data=dict(
name="test",
session=session
)
).run(db)
self.assertRaises(
sqlite3.IntegrityError,
Insertion(
schema["entity"],
data=dict(
session=session
)
).run,
db
)
def test_not_null(self):
con = Connection(**Connection.options())
with con as db:
rv = Creation(schema["entity"]).run(db)
self.assertRaises(
sqlite3.IntegrityError,
Insertion(
schema["entity"],
data=dict(
session=uuid.uuid4().hex
)
).run,
db
)
def test_insertion_keys(self):
con = Connection(**Connection.options())
with con as db:
rv = Creation(schema["touch"]).run(db)
session=uuid.uuid4().hex
self.assertRaises(
sqlite3.OperationalError,
Insertion(
schema["touch"],
data=dict(
sbjct=1,
objct=1
)
).run,
db
)
def test_insertion_entity(self):
con = Connection(**Connection.options())
with con as db:
rv = Creation(schema["entity"]).run(db)
session=uuid.uuid4().hex
Insertion(
schema["entity"],
data=dict(
session=session,
name="test"
)
).run(db)
cur = db.cursor()
cur.execute("select * from entity")
rv = cur.fetchall()
self.assertEqual(1, len(rv))
self.assertEqual(rv[0]["id"], 1)
self.assertEqual(rv[0]["name"], "test")
def test_insertion_entities(self):
con = Connection(**Connection.options())
session = uuid.uuid4().hex
with con as db:
rv = Creation(schema["entity"]).run(db)
Insertion(
schema["entity"],
data=[
{"name": "test_one", "session": session},
{"name": "test_two", "session": session}
]
).run(db)
cur = db.cursor()
cur.execute("select * from entity")
rv = cur.fetchall()
self.assertEqual(2, len(rv))
self.assertEqual(rv[0]["id"], 1)
self.assertEqual(rv[0]["name"], "test_one")
self.assertEqual(rv[1]["id"], 2)
self.assertEqual(rv[1]["name"], "test_two")
def note(cls,
con,
sbjct,
state,
objct=None,
ts=None,
text="",
html="",
log=None):
rv = cls.touch(con, sbjct, state, objct, ts, log=log)
op = Insertion(cls.tables["note"],
data={
"touch": rv,
"text": text,
"html": html,
})
if log is not None:
log.debug(op.sql)
cur = op.run(con)
rv = cur.lastrowid
cur.close()
return rv
def touch(cls,
con,
sbjct,
state,
objct=None,
ts=None,
text="",
html="",
log=None):
refs = list(cls.reference(con, [sbjct, state, objct]))
op = Insertion(cls.tables["touch"],
data={
"ts": ts or datetime.datetime.utcnow(),
"sbjct": refs[0]["id"],
"state": refs[1]["id"],
"objct": refs[2] and refs[2]["id"]
})
if log is not None:
log.debug(op.sql)
cur = op.run(con)
rv = cur.lastrowid
cur.close()
return rv
def test_selection_entity(self):
class Selection(SQLOperation):
@property
def sql(self):
return ("select * from {0.name}".format(self.tables[0]) , {})
con = Connection(**Connection.options())
with con as db:
rv = Creation(schema["entity"]).run(db)
session = uuid.uuid4().hex
cur = Insertion(
schema["entity"],
data=dict(
session=session,
name="test"
)
).run(db)
rv = Selection(schema["entity"]).run(db)
rows = rv.fetchall()
self.assertEqual(1, len(rows))
self.assertEqual(rows[0]["id"], 1)
self.assertEqual(rows[0]["name"], "test")