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)