def test_field_mass(self):
# Standard
field = relations.Field(int, name="id")
self.source.field_init(field)
values = {}
field.value = 1
self.source.update_field(field, values)
self.assertEqual(values, {"id": 1})
# not changed
field.changed = False
values = {}
self.source.update_field(field, values)
self.assertEqual(values, {})
self.assertFalse(field.changed)
# auto
field = relations.Field(int, name="id", auto=True)
self.source.field_init(field)
values = {}
field.value = 1
self.source.update_field(field, values)
self.assertEqual(values, {})
def test_field_update(self):
# Standard
field = relations.Field(int, name="id")
self.source.field_init(field)
clause = []
values = []
self.source.field_update(field, {"id": 1}, clause, values)
self.assertEqual(clause, ['"id"=%s'])
self.assertEqual(values, [1])
# Non standard
field = relations.Field(dict, name="id")
self.source.field_init(field)
clause = []
values = []
self.source.field_update(field, {"id": {"a": 1}}, clause, values)
self.assertEqual(clause, ['"id"=%s'])
self.assertEqual(values, ['{"a": 1}'])
# Non existent
field = relations.Field(dict, name="id")
self.source.field_init(field)
clause = []
values = []
self.source.field_update(field, {}, clause, values)
self.assertEqual(clause, [])
self.assertEqual(values, [])
def test_field_create(self):
# Standard
field = relations.Field(int, name="id")
self.source.field_init(field)
fields = []
clause = []
self.source.field_create( field, fields, clause)
self.assertEqual(fields, ['"id"'])
self.assertEqual(clause, ["%(id)s"])
# auto
field = relations.Field(int, name="id", auto=True)
self.source.field_init(field)
fields = []
clause = []
self.source.field_create( field, fields, clause)
self.assertEqual(fields, [])
self.assertEqual(clause, [])
# inject
field = relations.Field(int, name="id", inject=True)
self.source.field_init(field)
fields = []
clause = []
self.source.field_create( field, fields, clause)
self.assertEqual(fields, [])
self.assertEqual(clause, [])
def test_like(self):
field = relations.Field(int, store="_id")
self.assertTrue(field.like({"_id": '1'}, 1, {}))
self.assertFalse(field.like({"_id": '2'}, 1, {}))
self.assertTrue(field.like({"_id": '1'}, None, {'_id': [1]}))
self.assertFalse(field.like({"_id": '2'}, None, {'_id': [1]}))
field = relations.Field(str, store="name")
self.assertTrue(field.like({"name": ' yES adsfadsf'}, "Yes", {}))
self.assertFalse(field.like({"name": 'no'}, "Yes", {}))
field = relations.Field(ipaddress.IPv4Address,
store="ip",
attr={"compressed": "address"},
titles="address")
self.assertTrue(
field.like({"ip": {
"address": '1.2.3.4'
}}, "1.2.3.", {}))
self.assertTrue(
field.like({"ip": {
"address": '1.2.3.4'
}}, "1.2.3.", {}, "address"))
self.assertFalse(
field.like({"ip": {
"address": '1.2.3.4'
}}, "1.3.2.", {}))
self.assertFalse(field.like({}, "1.3.2.4", {}))
def test_field_update(self):
# Standard
field = relations.Field(int, name="id")
self.source.field_init(field)
values = {}
field.value = 1
self.source.field_update(field, values)
self.assertEqual(values, {"id": 1})
self.assertFalse(field.changed)
# not changed
values = {}
self.source.field_update(field, values, changed=True)
self.assertEqual(values, {})
self.assertFalse(field.changed)
# readonly
field = relations.Field(int, name="id", readonly=True)
self.source.field_init(field)
values = {}
field.value = 1
self.source.field_update(field, values)
self.assertEqual(values, {})
def test_write(self):
field = relations.Field(int, store="_id", default=-1, refresh=True)
field.value = 1
values = {}
field.write(values)
self.assertEqual(values, {'_id': 1})
field = relations.Field(ipaddress.IPv4Address,
store="ip",
attr={
"compressed": "address",
"__int__": "value"
})
field.value = ipaddress.IPv4Address('1.2.3.4')
values = {}
field.write(values)
self.assertEqual(values,
{'ip': {
"address": "1.2.3.4",
"value": 16909060
}})
field = relations.Field(str, inject="things__a__b__0____1")
field.value = "yep"
values = {}
field.write(values)
self.assertEqual(values, {"a": {"b": [{"1": "yep"}]}})
def test_update_field(self):
# Standard
field = relations.Field(int, name="id")
query = self.source.UPDATE("table")
self.source.update_field(field, {"id": 1}, query)
query.generate()
self.assertEqual(query.sql, """UPDATE `table` SET `id`=%s""")
self.assertEqual(query.args, [1])
# Non standard
field = relations.Field(dict, name="id")
query = self.source.UPDATE("table")
self.source.update_field(field, {"id": {"a": 1}}, query)
query.generate()
self.assertEqual(query.sql,
"""UPDATE `table` SET `id`=CAST(%s AS JSON)""")
self.assertEqual(query.args, ['{"a": 1}'])
# Non existent
field = relations.Field(dict, name="id")
query = self.source.UPDATE("table")
self.source.update_field(field, {}, query)
query.generate()
self.assertEqual(query.sql, """UPDATE `table`""")
self.assertEqual(query.args, [])
def test_export(self):
field = relations.Field(int)
field.value = 1
self.assertEqual(field.export(), 1)
field = relations.Field(set)
field.value = {"people", "stuff", "things"}
self.assertEqual(field.export(), ["people", "stuff", "things"])
field.options = ["stuff", "people", "things"]
field.value = {"people", "stuff"}
self.assertEqual(field.export(), ["stuff", "people"])
field = relations.Field(dict)
field.value = {"a": 1}
value = field.export()
self.assertEqual(value, {"a": 1})
value["a"] = 2
self.assertEqual(field.export(), {"a": 1})
field = relations.Field(ipaddress.IPv4Address,
attr={
"compressed": "ip__address",
"__int__": "ip__value"
})
field.value = "1.2.3.4"
self.assertEqual(field.export(),
{"ip": {
"address": "1.2.3.4",
"value": 16909060
}})
def hurl(values, value):
values["address"] = str(value)
min_ip = value[0]
max_ip = value[-1]
values["min_address"] = str(min_ip)
values["min_value"] = int(min_ip)
values["max_address"] = str(max_ip)
values["max_value"] = int(max_ip)
field = relations.Field(ipaddress.IPv4Network,
attr=hurl,
init="address",
titles="address")
field.value = '1.2.3.0/24'
self.assertEqual(
field.export(), {
"address": "1.2.3.0/24",
"min_address": "1.2.3.0",
"min_value": 16909056,
"max_address": "1.2.3.255",
"max_value": 16909311
})
def setUp(self):
self.source = unittest.mock.MagicMock()
self.record = relations.Record()
self.id = relations.Field(int, name="id", store="_id")
self.name = relations.Field(str, name="name", store="_name")
self.record.append(self.id)
self.record.append(self.name)
def test_read(self):
field = relations.Field(int, store="_id")
field.read({"_id": "1"})
self.assertEqual(field.value, 1)
self.assertFalse(field.delta())
field = relations.Field(str, inject="things__a__b__0____1")
field.read({"a": {"b": [{"1": "yep"}]}})
self.assertEqual(field.value, "yep")
self.assertFalse(field.delta())
def test_field_update(self):
# Standard
field = relations.Field(int, name="id")
self.source.field_init(field)
clause = []
values = []
field.value = 1
self.source.field_update(field, clause, values)
self.assertEqual(clause, ['"id"=%s'])
self.assertEqual(values, [1])
self.assertFalse(field.changed)
# replace
field = relations.Field(int, name="id", default=-1, replace=True)
self.source.field_init(field)
clause = []
values = []
field.value = 1
self.source.field_update(field, clause, values)
self.assertEqual(clause, ['"id"=%s'])
self.assertEqual(values, [1])
field.changed = False
clause = []
values = []
self.source.field_update(field, clause, values)
self.assertEqual(clause, ['"id"=%s'])
self.assertEqual(values, [-1])
# not changed
field = relations.Field(int, name="id")
clause = []
values = []
self.source.field_update(field, clause, values, changed=True)
self.assertEqual(clause, [])
self.assertEqual(values, [])
self.assertFalse(field.changed)
# readonly
field = relations.Field(int, name="id", readonly=True)
self.source.field_init(field)
clause = []
values = []
field.value = 1
self.source.field_update(field, clause, values)
self.assertEqual(clause, [])
self.assertEqual(values, [])
def test_append(self):
record = relations.Record()
id = relations.Field(int, name="id", store="_id")
record.append(id)
self.assertEqual(record._order, [id])
self.assertEqual(record._names, {"id": id})
name = relations.Field(str, name="name", store="_name")
record.append(name)
self.assertEqual(record._order, [id, name])
self.assertEqual(record._names, {"id": id, "name": name})
def test_access(self):
field = relations.Field(int)
field.value = 1
self.assertRaisesRegex(relations.FieldError, "no access for int",
field.access, 0)
field = relations.Field(ipaddress.IPv4Address,
attr={
"compressed": "ip__address",
"__int__": "ip__value"
})
field.value = "1.2.3.4"
self.assertEqual(field.access("ip__address"), "1.2.3.4")
def test_read(self):
self.things = relations.Field(dict, name="things", store="_things", default=dict)
self.push = relations.Field(str, name="push", inject="things__a__b__0____1")
self.record.append(self.things)
self.record.append(self.push)
self.record.read({"_id": 1, "_name": "unit", "_things": {"a":{"b": [{"1": "yep"}]}}})
self.assertEqual(self.record.id, 1)
self.assertEqual(self.record.name, "unit")
self.assertEqual(self.record.things, {"a":{"b": [{"1": "yep"}]}})
self.assertEqual(self.record.push, "yep")
def test_create(self):
self.things = relations.Field(dict, name="things", store="_things", default=dict)
self.push = relations.Field(str, name="push", inject="things__a__b__0____1")
self.record.append(self.things)
self.record.append(self.push)
self.record.id = 1
self.record.name = "unit"
self.record.things = {}
self.record.push = "yep"
self.assertEqual(self.record.create({}), {"_id": 1, "_name": "unit", "_things": {"a":{"b": [{"1": "yep"}]}}})
def test_update(self):
field = relations.Field(int, store="_id")
field.value = 1
field.original = 2
values = {}
field.update(values)
self.assertEqual(values, {'_id': 1})
self.assertEqual(field.original, 1)
values = {}
field.update(values)
self.assertEqual(values, {})
self.assertEqual(field.original, 1)
field.refresh = True
field.default = 2
values = {}
field.update(values)
self.assertEqual(values, {'_id': 2})
self.assertEqual(field.value, 2)
self.assertEqual(field.original, 2)
values = {}
field.value = 1
values = {}
field.update(values)
self.assertEqual(values, {'_id': 1})
self.assertEqual(field.original, 1)
field = relations.Field(ipaddress.IPv4Address,
store="ip",
attr={
"compressed": "address",
"__int__": "value"
})
field.value = ipaddress.IPv4Address('1.2.3.4')
values = {}
field.update(values)
self.assertEqual(values,
{'ip': {
"address": "1.2.3.4",
"value": 16909060
}})
self.assertEqual(field.original, {
"address": "1.2.3.4",
"value": 16909060
})
def test_create(self):
field = relations.Field(int, store="_id")
field.value = 1
values = {}
field.create(values)
self.assertEqual(values, {'_id': 1})
self.assertEqual(field.original, 1)
field = relations.Field(int, store="_id")
field.auto = True
values = {}
field.create(values)
self.assertEqual(values, {})
self.assertIsNone(field.original)
def test_mass(self):
field = relations.Field(int, store="_id")
field.value = 1
field.changed = True
values = {}
field.mass(values)
self.assertEqual(values, {'_id': 1})
field.changed = False
values = {}
field.mass(values)
self.assertEqual(values, {})
field.refresh = True
field.default = 2
values = {}
field.mass(values)
self.assertEqual(values, {'_id': 2})
self.assertEqual(field.value, 2)
values = {}
field.value = 1
values = {}
field.mass(values)
self.assertEqual(values, {'_id': 1})
field = relations.Field(ipaddress.IPv4Address,
store="ip",
attr={
"compressed": "address",
"__int__": "value"
})
field.value = ipaddress.IPv4Address('1.2.3.4')
values = {}
field.mass(values)
self.assertEqual(values,
{'ip': {
"address": "1.2.3.4",
"value": 16909060
}})
field.inject = True
self.assertRaisesRegex(relations.FieldError,
"no mass update with inject", field.mass, {})
def test_retrieve_field(self):
field = relations.Field(int, name="id")
self.source.field_init(field)
field.filter(1)
query = self.source.SELECT()
self.source.retrieve_field(field, query)
query.generate()
self.assertEqual(query.sql, """SELECT WHERE "id"=%s""")
self.assertEqual(query.args, [1])
field = relations.Field(dict,
name="things",
extract={"for__0____1": str})
self.source.field_init(field)
field.filter({"a": 1})
query = self.source.SELECT()
self.source.retrieve_field(field, query)
query.generate()
self.assertEqual(query.sql, """SELECT WHERE "things"=(%s)::JSONB""")
self.assertEqual(query.args, ['{"a": 1}'])
field = relations.Field(dict,
name="things",
extract={"for__0____1": str})
self.source.field_init(field)
field.filter("yes", "a__b")
query = self.source.SELECT()
self.source.retrieve_field(field, query)
query.generate()
self.assertEqual(
query.sql, """SELECT WHERE ("things"#>>%s)::JSONB=(%s)::JSONB""")
self.assertEqual(query.args, ['{a,b}', '"yes"'])
field = relations.Field(dict,
name="things",
extract={"for__0____1": str})
self.source.field_init(field)
field.filter("yes", "for__0____1")
query = self.source.SELECT()
self.source.retrieve_field(field, query)
query.generate()
self.assertEqual(query.sql,
"""SELECT WHERE "things__for__0____1"=%s""")
self.assertEqual(query.args, ['yes'])
def test_retrieve_field(self):
field = relations.Field(int, name="id")
self.source.field_init(field)
field.filter(1)
query = self.source.SELECT()
self.source.retrieve_field(field, query)
query.generate()
self.assertEqual(query.sql, """SELECT WHERE `id`=%s""")
self.assertEqual(query.args, [1])
field = relations.Field(dict,
name="things",
extract={"for__0____1": str})
self.source.field_init(field)
field.filter({"a": 1})
query = self.source.SELECT()
self.source.retrieve_field(field, query)
query.generate()
self.assertEqual(query.sql,
"""SELECT WHERE `things`=CAST(%s AS JSON)""")
self.assertEqual(query.args, ['{"a": 1}'])
field = relations.Field(dict,
name="things",
extract={"for__0____1": str})
self.source.field_init(field)
field.filter("yes", "a__b")
query = self.source.SELECT()
self.source.retrieve_field(field, query)
query.generate()
self.assertEqual(query.sql, """SELECT WHERE `things`->>%s=%s""")
self.assertEqual(query.args, ['$.a.b', 'yes'])
field = relations.Field(dict,
name="things",
extract={"for__0____1": str})
self.source.field_init(field)
field.filter("yes", "for__0____1")
query = self.source.SELECT()
self.source.retrieve_field(field, query)
query.generate()
self.assertEqual(query.sql,
"""SELECT WHERE `things__for__0____1`=%s""")
self.assertEqual(query.args, ['yes'])
def test___setattr__(self):
self.record.id = "1"
self.assertEqual(self.id.value, 1)
self.things = relations.Field(dict, name="things", store="_things", default=dict)
self.record.append(self.things)
self.record.things__a__b__0____1 = "yep"
self.assertEqual(self.things.value, {"a":{"b": [{"1": "yep"}]}})
def test_define(self):
field = relations.Field(int, name="test", default=False)
self.assertEqual(
field.define(), {
"kind": 'int',
"name": "test",
"store": "test",
"none": False,
"default": False
})
field = relations.Field(int, name="test", default=int)
self.assertEqual(field.define(), {
"kind": 'int',
"name": "test",
"store": "test",
"none": False
})
field = relations.Field(dict,
name='grab',
extract={
"a__b__0___1": bool,
"c__b__0___1": int,
"c__d__0___1": float,
"c__d__1___1": str,
"c__d__1___2": list
})
self.assertEqual(
field.define(), {
"kind": 'dict',
"name": "grab",
"store": "grab",
"none": False,
"extract": {
"a__b__0___1": 'bool',
"c__b__0___1": 'int',
"c__d__0___1": 'float',
"c__d__1___1": 'str',
"c__d__1___2": 'list'
}
})
def test_like(self):
self.things = relations.Field(dict, name="things", store="_things", default=dict)
self.record.append(self.things)
self.assertTrue(self.record.like({"_id": 1, "_name": "test"}, ["id", "name"], "unit", {'_id': [1]}))
self.assertTrue(self.record.like({"_id": 2, "_name": "unit"}, ["id", "name"], "unit", {'_id': [1]}))
self.assertFalse(self.record.like({"_id": 2, "_name": "test"}, ["id", "name"], "unit", {'_id': [1]}))
self.assertTrue(self.record.like({"_id": 1, "_name": "unit", "_things": {"a":{"b": [{"1": "yep"}]}}}, ["things__a__b__0____1"], "y", {'things': [1]}))
self.assertFalse(self.record.like({"_id": 1, "_name": "unit", "_things": {"a":{"b": [{"1": "yep"}]}}}, ["things__a__b__0____1"], "n", {'things': [1]}))
def test_mass(self):
self.things = relations.Field(dict, name="things", store="_things", default=dict)
self.push = relations.Field(str, name="push", inject="things__a__b__0____1")
self.record.append(self.things)
self.record.append(self.push)
self.assertEqual(self.record.mass({}), {})
self.record.id = 1
self.record.name = "unit"
self.assertEqual(self.record.mass({}), {"_id": 1, "_name": "unit"})
self.record.things = {}
self.record.push = "yep"
self.things.changed = False
self.assertRaisesRegex(relations.FieldError, "no mass update with inject", self.record.mass, {})
def test_delta(self):
field = relations.Field(int)
field.original = 0
field.value = 1
self.assertTrue(field.delta())
field.value = "0"
self.assertFalse(field.delta())
field = relations.Field(ipaddress.IPv4Address,
attr={
"compressed": "ip__address",
"__int__": "ip__value"
})
field.value = "1.2.3.4"
self.assertTrue(field.delta())
field.original = field.export()
field.value = ipaddress.IPv4Address("1.2.3.4")
self.assertFalse(field.delta())
def test_field_create(self):
# Standard
field = relations.Field(int, name="id")
self.source.field_init(field)
fields = []
clause = []
self.source.field_create(field, fields, clause)
self.assertEqual(fields, ['"id"'])
self.assertEqual(clause, ["%(id)s"])
self.assertFalse(field.changed)
# readonly
field = relations.Field(int, name="id", readonly=True)
self.source.field_init(field)
fields = []
clause = []
self.source.field_create(field, fields, clause)
self.assertEqual(fields, [])
self.assertEqual(clause, [])
def test_export(self):
self.things = relations.Field(dict, name="things", store="_things", default=dict)
self.push = relations.Field(str, name="push", inject="things__a__b__0____1")
self.ip = relations.Field(ipaddress.IPv4Address, name="ip", attr={"compressed": "address", "__int__": "value"})
self.record.append(self.things)
self.record.append(self.push)
self.record.append(self.ip)
self.record.read({"_id": 1, "_name": "unit", "_things": {"a":{"b": [{"1": "yep"}]}}, "ip": "1.2.3.4"})
self.assertEqual(self.record.export(), {
"id": 1,
"name": "unit",
"things": {"a":{"b": [{"1": "yep"}]}},
"push": "yep",
"ip": {
"address": "1.2.3.4",
"value": 16909060
}
})
def test___getattr__(self):
self.id.value = "1"
self.assertEqual(self.record.id, 1)
self.things = relations.Field(dict, name="things", store="_things", default=dict)
self.record.append(self.things)
self.things.value = {"a":{"b": [{"1": "yep"}]}}
self.assertEqual(self.record.things__a__b__0____1, "yep")
def nope():
self.record.nope
self.assertRaisesRegex(AttributeError, "has no attribute 'nope'", nope)
def test___setattr__(self):
field = relations.Field(int)
field.name = "id"
self.assertEqual(field.kind, int)
self.assertEqual(field.name, "id")
self.assertEqual(field.store, "id")
# Store override
field = relations.Field(int, store="_id")
field.name = "id"
self.assertEqual(field.name, "id")
self.assertEqual(field.store, "_id")
def rename(name):
field.name = name
self.assertRaisesRegex(
relations.FieldError,
"field name 'define' is reserved - use the store attribute for this name",
rename, 'define')
self.assertRaisesRegex(
relations.FieldError,
"field name 'def__ine' cannot contain '__' - use the store attribute for this name",
rename, 'def__ine')
self.assertRaisesRegex(
relations.FieldError,
"field name '_define' cannot start with '_' - use the store attribute for this name",
rename, '_define')
field.value = "1"
self.assertEqual(field.value, 1)
self.assertTrue(field.changed)
field.value = None
self.assertIsNone(field.value)
def test___getitem__(self):
self.id.value = "1"
self.assertEqual(self.record[0], 1)
self.assertEqual(self.record['id'], 1)
self.things = relations.Field(dict, name="things", store="_things", default=dict)
self.record.append(self.things)
self.things.value = {"a":{"b": [{"1": "yep"}]}}
self.assertEqual(self.record["things__a__b__0____1"], "yep")
def nope():
self.record['nope']
self.assertRaisesRegex(relations.RecordError, "unknown field 'nope'", nope)
