class ArrayMapCastingTestSchema(omm.Mapper):
"""Array mapper test data with casting."""
name = omm.MapField("users[1][1].name", set_cast=str)
age = omm.MapField("users[1][1].age", get_cast=int)
lastest_score = omm.MapField("users[1][1].scores[3]", get_cast=int)
@staticmethod
def generate_test_data(asdict=False):
"""Generate test data."""
class NameAge(object):
def __init__(self, name, age, scores):
self.name = name
self.age = age
self.scores = scores
def to_dict(self):
return {
"name": self.name,
"age": self.age,
"scores": self.scores
}
class Users(object):
def __init__(self):
self.users = [
None,
[None, NameAge(1498, "119", ["g", "gk", "gi", "10"])]
]
def to_dict(self):
return {"users": [None, [None, self.users[1][1].to_dict()]]}
users = Users()
return users.to_dict() if asdict else users
class SimpleTestMapper(omm.Mapper):
"""Simple mapper."""
name = omm.MapField("test.name")
age = omm.MapField("test.age")
sex = omm.MapField("test.sex")
@staticmethod
def generate_test_data(type_dict=False):
"""
Generate test data.
Parameters:
type_dict: Set True if the data is expected to be typed as dict.
"""
class User(object):
def __init__(self):
self.name = "Test Example"
self.age = 960
self.sex = None
class GenObj(object):
def __init__(self):
self.test = User()
gen_obj = GenObj()
return {
"test": {
"name": gen_obj.test.name,
"age": gen_obj.test.age,
"sex": gen_obj.test.sex
}
} if type_dict else gen_obj
class SimpleTestSchemaWithSimpleCastWithDictFunction(
SimpleTestSchemaWithSimpleCast):
"""Simple Test Data with casting, to_dict and from_dict in cast."""
class BaseField(object):
"""Base field."""
def __init__(self, value):
"""Init."""
self.value = value
class IntegerField(BaseField):
"""Integer Field."""
def to_dict(self):
"""Convert to dict."""
return int(self.value)
class StringField(BaseField):
"""String field."""
def to_dict(self):
"""Convert to dict."""
return str(self.value)
name = omm.MapField("test.user.name",
set_cast=StringField,
get_cast=StringField)
age = omm.MapField("test.user.age",
set_cast=IntegerField,
get_cast=IntegerField)
class SimpleTestMapperWithSeperate(omm.Mapper):
"""Simple mapper with sep_char flag."""
name = omm.MapField("test name", sep_char=" ")
age = omm.MapField("test.age", sep_char=" ")
sex = omm.MapField("test.sex", sep_char=" ")
@staticmethod
def generate_test_data(type_dict=False):
"""
Generate test data.
Parameters:
type_dict: Set True if the data is expected to be typed as dict.
"""
class User(object):
def __init__(self):
self.name = "Test Example"
class GenObj(object):
def __init__(self):
self.test = User()
setattr(self, "test.age", 20)
setattr(self, "test.sex", "Xe")
gen_obj = GenObj()
return {
"test": {
"name": gen_obj.test.name
},
"test.age": getattr(gen_obj, "test.age"),
"test.sex": getattr(gen_obj, "test.sex")
} if type_dict else gen_obj
class SimpleTestSchemaWithSimpleCast(omm.Mapper):
"""Simple Test Data with casting."""
name = omm.MapField("test.user.name", set_cast=str)
age = omm.MapField("test.user.age", get_cast=int)
@staticmethod
def generate_test_data(asdict=False):
"""Generate test data."""
class User(object):
def __init__(self):
self.name = 41561234
self.age = "199"
def to_dict(self):
return {"name": self.name, "age": self.age}
class Test(object):
def __init__(self):
self.user = User()
def to_dict(self):
return {"user": self.user.to_dict()}
class DataClass(object):
def __init__(self):
self.test = Test()
def to_dict(self):
return {"test": self.test.to_dict()}
test = DataClass()
return test.to_dict() if asdict else test
class TestSchema(omm.Mapper):
test = omm.MapField("test.example")
test2 = omm.MapField("test.example2")
def __new__(cls, *args, **kwargs):
cls.test.validate = MagicMock(
side_effect=ValueError("It works"))
cls.test2.validate = MagicMock(
side_effect=ValueError("It works"))
return super(TestSchema, cls).__new__(cls, *args, **kwargs)
class InvalidCastingLengthTestSchema(omm.Mapper):
"""Invalid cast schema because of the length of set_cast is invalid."""
name = omm.MapField("test.user.name", set_cast=[object, object, object])
age = omm.MapField("test.user.age",
set_cast=[object, object, object, object, object])
admin_bit = omm.MapField("test.user.admin[1][2]",
set_cast=[object, object, object, object, object])
manage_bit = omm.MapField(
"test.user.admin[1][3]",
set_cast=[object, object, object, object, object, object, object])
class TestSchema(omm.Mapper):
GeneratedObject = type("GeneratedObject", (object, ), {})
name = omm.MapField("test.user.map",
get_cast=TestField,
set_cast=TestField)
age = omm.MapField("test2.user.age",
get_cast=TestField,
set_cast=[
GeneratedObject, GeneratedObject,
GeneratedObject, TestField
])
class InconsistentTypeSchema(omm.Mapper):
"""Inconsistent cast schema."""
StartObj = type("StartObj", (object, ), {})
TestObj = type("TestObj", (object, ), {})
UserObj = type("UserObj", (object, ), {})
name = omm.MapField("test.user.name",
set_cast=[StartObj, TestObj, UserObj, str])
alias = omm.MapField("test.user.name",
set_cast=[TestObj, UserObj, TestObj, int])
display_name = omm.MapField("test.user.name",
set_cast=[StartObj, UserObj, TestObj, str])
class ArrayMapTestSchema(omm.Mapper):
"""Array Mapper."""
array = omm.MapField("test.array[1][1].correct")
last_array = omm.MapField("test.array[1][2]")
@staticmethod
def generate_test_data(type_dict=False):
"""
Generate test data.
Parameters:
type_dict: Set True if the data is expected to be typed as dict.
"""
class ObjectClass(object):
class Test(object):
class ArrayElement(object):
def __init__(self, correct):
self.correct = correct
def __init__(self):
self.array = [[
type(self).ArrayElement(False),
type(self).ArrayElement(False)
],
[
type(self).ArrayElement(False),
type(self).ArrayElement(True),
"Hello World"
]]
def __init__(self):
self.test = type(self).Test()
return {
"test": {
"array": [
[{
"correct": False
}, {
"correct": False
}],
[{
"correct": False
}, {
"correct": True
}, "Hello World"],
]
}
} if type_dict else ObjectClass()
class SimpleTestSchemaWithComplexCast1(omm.Mapper):
"""Object based test mapper with complex casting."""
TestObj1 = type("TestObj1", (object, ), {})
TestObj2 = type("TestObj2", (object, ), {})
name = omm.MapField("test.user.name",
set_cast=[TestObj1, dict, TestObj2, str])
class ExclusionMapper(SimpleTestMapper):
age = omm.MapField(
"test.age", exclude={
"json": True,
"dict": False,
"custom": True
}, exclude_serialize=True, exclude_deserialize=False
)
class ArrayMapTestSchemaWithClear(omm.Mapper):
"""Array Mapper with clear_parent flag."""
first_first = omm.MapField("test.array[0][0]", clear_parent=True)
first_mid = omm.MapField("test.array[0][1]", clear_parent=True)
first_last = omm.MapField("test.array[0][2]", clear_parent=True)
mid_first = omm.MapField("test.array[1][0]", clear_parent=True)
mid_mid = omm.MapField("test.array[1][1]", clear_parent=True)
mid_last = omm.MapField("test.array[1][2]", clear_parent=True)
last_first = omm.MapField("test.array[2][0]", clear_parent=True)
last_mid = omm.MapField("test.array[2][1]", clear_parent=True)
last_last = omm.MapField("test.array[2][2]", clear_parent=True)
@staticmethod
def generate_test_data(type_dict=False):
"""
Generate test data.
Parameters:
type_dict: Set True if the data is expected to be typed as dict.
"""
slen = 3
class ArrayElement(object):
def __init__(self, correct):
self.correct = correct
def __eq__(self, other):
return self.correct == other.correct
class Test(object):
def __init__(self):
self.array = [[
ArrayElement(outer == inner) for inner in range(slen)
] for outer in range(slen)]
class ObjectClass(object):
def __init__(self):
self.test = Test()
return {
"test": {
"array": [[{
"correct": outer == inner
} for inner in range(slen)] for outer in range(slen)]
}
} if type_dict else ObjectClass()
def setUp(self):
"""Setup."""
self.Objs = [
type("Obj1", (object, ), {}),
type("Obj2", (object, ), {}),
type("Obj3", (object, ), {}),
type("Obj4", (object, ), {})
]
self.field = omm.MapField("test.name.aaaa")
class ArrayInconsistentTypeSchema(omm.Mapper):
"""Test schema."""
RootObj = type("RootObj", (object, ), {})
TestObj = type("TestObj", (object, ), {})
UsersObj = type("UserObj", (list, ), {})
UserProfilesObj = type("UserProfilesObj", (list, ), {})
UserProfileElementObj = type("UserProfileElementObj", (list, ), {})
name = omm.MapField("test.users[0][1].name",
set_cast=[
RootObj, TestObj, UsersObj, UserProfilesObj,
UserProfileElementObj, str
])
alias = omm.MapField("test.users[0][1].name",
set_cast=[
RootObj, TestObj, UserProfilesObj, UsersObj,
UserProfileElementObj, int
])
class SimpleTestSchemaWithSimpleCastWithJSONFunction(
SimpleTestSchemaWithSimpleCast):
"""Simple Test Data with casting, to_json and from_json in cast."""
class BaseField(object):
"""Base Field."""
def __init__(self, value):
"""Init."""
self.value = value
class IntegerField(BaseField):
"""Int field."""
def to_json(self):
"""Convert to json."""
return json.dumps({"value": int(self.value)})
@classmethod
def from_json(cls, jsonstr):
"""Restore from json."""
return cls(**list(json.loads(jsonstr).values())[0])
class StringField(BaseField):
"""Str field."""
def to_json(self):
"""Convert to JSON."""
return json.dumps({"value": str(self.value)})
@classmethod
def from_json(cls, jsonstr):
"""Restore from JSON."""
return cls(**list(json.loads(jsonstr).values())[0])
name = omm.MapField("test.user.name",
set_cast=StringField,
get_cast=StringField)
age = omm.MapField("test.user.age",
set_cast=IntegerField,
get_cast=IntegerField)
class ArrayMapComplexCastingTestSchema(omm.Mapper):
"""Array map test casting schema (complex version)."""
StartObj = type("StartObj", (object, ), {})
Users = type("Users", (list, ), {})
UserProfiles = type("UserProfiles", (list, ), {})
Profile = type("Profile", (object, ), {})
TestObj = type("TestObj", (object, ), {})
InfoObj = type("InfoObj", (dict, ), {})
name = omm.MapField("test.users[0][1].info.name",
set_cast=[
StartObj, TestObj, Users, UserProfiles, Profile,
InfoObj, str
])
def setUp(self):
"""Set up the class."""
self.target = "mapping.test"
self.field = omm.MapField()
self.field.target = self.target
class TestSchema(omm.Mapper):
name = omm.MapField("test.name")
class ExclusionMapper(SimpleTestMapper):
age = omm.MapField("test.age", exclude=True)
class ExclusionMapper(SimpleTestMapper):
age = omm.MapField(
"test.age", exclude={"json": True, "dict": False}
)
class ExclusionMapper(SimpleTestMapper):
age = omm.MapField("test.age", exclude_serialize=True)
name = omm.MapField("test.name", exclude_deserialize=True)
class SimpleTestMapperWithClear(SimpleTestMapper):
"""Simple mapper with clear_parent flag."""
name = omm.MapField("test.name", clear_parent=True)
age = omm.MapField("test.age", clear_parent=True)
sex = omm.MapField("test.sex", clear_parent=True)
class TestMapper(omm.Mapper):
GenObj = type("GenObj", (object, ), {})
test = omm.MapField("test", get_cast=TestField, set_cast=TestField)
test2 = omm.MapField("test2.user.test",
get_cast=TestField,
set_cast=[GenObj, GenObj, GenObj, TestField])
class SimpleTestSchemaWithComplexCast2(omm.Mapper):
"""Object based test mapper with complex casting."""
GeneratedObject = type("GeneratedObject", (object, ), {})
name = omm.MapField("test.user.name",
set_cast=[dict, GeneratedObject, dict, str])
