def test_dict_working(dict_type):
class TestModel(middle.Model):
ratings = middle.field(type=dict_type[str, float])
inst = TestModel(ratings={
"contender1": 4.2,
"contender2": 3.9,
"contender3": 3.4
})
assert isinstance(inst, TestModel)
assert len(inst.ratings.keys()) == 3
assert "contender1" in inst.ratings.keys()
assert "contender2" in inst.ratings.keys()
assert "contender3" in inst.ratings.keys()
assert 4.2 in inst.ratings.values()
assert 3.9 in inst.ratings.values()
assert 3.4 in inst.ratings.values()
assert inst.ratings.get("contender1") == 4.2
assert inst.ratings.get("contender2") == 3.9
assert inst.ratings.get("contender3") == 3.4
data = middle.asdict(inst)
assert isinstance(data, dict)
assert data.get("ratings", None) == {
"contender1": 4.2,
"contender2": 3.9,
"contender3": 3.4,
}
def test_enum_working():
@unique
class TestStrEnum(str, Enum):
TEST_1 = "TEST1"
TEST_2 = "TEST2"
TEST_3 = "TEST3"
@unique
class TestIntEnum(IntEnum):
TEST_1 = 1
TEST_2 = 2
TEST_3 = 3
class TestModel(middle.Model):
str_enum = middle.field(type=TestStrEnum)
int_enum = middle.field(type=TestIntEnum)
inst = TestModel(str_enum="TEST2", int_enum=3)
assert isinstance(inst, TestModel)
assert inst.str_enum == TestStrEnum.TEST_2
assert inst.int_enum == TestIntEnum.TEST_3
data = middle.asdict(inst)
assert isinstance(data, dict)
assert data.get("str_enum", None) == "TEST2"
assert data.get("int_enum", None) == 3
def test_union_working_with_none(val, expected):
class TestModel(middle.Model):
value = middle.field(type=Union[str, int, float, None])
inst = TestModel(value=val)
assert isinstance(inst, TestModel)
assert inst.value == expected
data = middle.asdict(inst)
assert isinstance(data, dict)
assert data.get("value", {}) == expected
def test_optional_working(value, expected):
class TestModel(middle.Model):
name = middle.field(type=Optional[str])
inst = TestModel(name=value)
assert isinstance(inst, TestModel)
assert inst.name == expected
data = middle.asdict(inst)
assert isinstance(data, dict)
assert data.get("name", {}) == expected
def test_decimal_working():
class TestModel(middle.Model):
value = middle.field(type=Decimal)
inst = TestModel(value="5")
assert isinstance(inst, TestModel)
assert inst.value == Decimal("5.0")
data = middle.asdict(inst)
assert isinstance(data, dict)
assert data.get("value", None) == 5.0
def test_union_one_parameter(val, expected, type_):
class TestModel(middle.Model):
value = middle.field(type=Union[type_])
inst = TestModel(value=val)
assert isinstance(inst, TestModel)
assert inst.value == expected
data = middle.asdict(inst)
assert isinstance(data, dict)
assert data.get("value", None) == expected
def test_int_working():
class TestModel(middle.Model):
const = middle.field(type=int)
inst = TestModel(const=42)
assert isinstance(inst, TestModel)
assert inst.const == 42
data = middle.asdict(inst)
assert isinstance(data, dict)
assert data.get("const", None) == 42
def test_datetime_working():
class TestModel(middle.Model):
ts = middle.field(type=datetime)
inst = TestModel(ts="2018-06-18T13:30:00.123456+00:00")
assert isinstance(inst, TestModel)
assert inst.ts == datetime(2018, 6, 18, 13, 30, 0, 123456, timezone.utc)
data = middle.asdict(inst)
assert isinstance(data, dict)
assert data.get("ts", None) == "2018-06-18T13:30:00.123456+00:00"
def test_str_working():
class TestModel(middle.Model):
name = middle.field(type=str)
inst = TestModel(name="some str")
assert isinstance(inst, TestModel)
assert inst.name == "some str"
data = middle.asdict(inst)
assert isinstance(data, dict)
assert data.get("name", None) == "some str"
def test_date_working():
class TestModel(middle.Model):
created_on = middle.field(type=date)
inst = TestModel(created_on="2018-06-18")
assert isinstance(inst, TestModel)
assert inst.created_on == date(2018, 6, 18)
data = middle.asdict(inst)
assert isinstance(data, dict)
assert data.get("created_on", None) == "2018-06-18"
def test_set_working(set_type):
class TestModel(middle.Model):
names = middle.field(type=set_type[str])
inst = TestModel(names=["foo", "bar"])
assert isinstance(inst, TestModel)
assert inst.names == {"bar", "foo"}
data = middle.asdict(inst)
assert isinstance(data, dict)
assert data.get("names", None) == {"bar", "foo"}
def test_tuple_working():
class TestModel(middle.Model):
value = middle.field(type=Tuple[str, int, float])
inst = TestModel(value=["hello", 1, "-.4"])
assert isinstance(inst, TestModel)
assert inst.value == ("hello", 1, -0.4)
data = middle.asdict(inst)
assert isinstance(data, dict)
assert data.get("value", None) == ("hello", 1, -0.4)
with pytest.raises(ValueError):
TestModel(value=["hello", 1, "-.4", "world"])
def test_bool_working():
class TestModel(middle.Model):
broken = middle.field(type=bool)
inst = TestModel(broken=True)
assert isinstance(inst, TestModel)
assert inst.broken is True
data = middle.asdict(inst)
assert isinstance(data, dict)
assert data.get("broken", False) is True
assert TestModel({"broken": True}).broken is True
def test_work_with_new_type():
class TestModel(middle.Model):
value = middle.field(type=Foo)
inst = TestModel(value="hello")
assert isinstance(inst, TestModel)
assert isinstance(inst.value, Foo)
assert inst.value.foo == "hello"
data = middle.asdict(inst)
assert isinstance(data, dict)
assert data.get("value", None) == "hello"
assert TestModel(value="world").value.foo == "world"
assert TestModel(value=Foo(foo="shh")).value.foo == "shh"
def test_attr_class_union():
@attr.s
class AttrModel:
name = attr.ib(type=str)
age = attr.ib(type=int)
class TestModel(middle.Model):
agent = middle.field(type=Optional[AttrModel])
inst = TestModel(agent=AttrModel(name="Foo", age=21))
assert isinstance(inst, TestModel)
inst = TestModel(agent=None)
assert inst.agent is None
assert middle.asdict(inst) == {"agent": None}
def test_instance_to_dict():
game = Game(
name="Cities: Skylines",
platform="PC",
score=9.0,
resolution_tested="1920x1080",
genre=["Simulators", "City Building"],
rating={"IGN": 8.5, "Gamespot": 8.0, "Steam": 4.5},
players=["Flux", "strictoaster"],
language=1,
awesome_city=City(name="Blumenau", region=CityRegionEnum.TEMPERATE),
)
data = middle.asdict(game)
assert isinstance(data, dict)
assert isinstance(data.get("awesome_city", None), dict)
assert data.get("awesome_city").get("region") == "TEMPERATE"
def test_inheritance():
@unique
class CityRegionEnum(str, Enum):
TROPICAL = "TROPICAL"
TEMPERATE = "TEMPERATE"
BOREAL = "BOREAL"
class BaseCity(middle.Model):
name = middle.field(type=str)
region = middle.field(type=CityRegionEnum)
class City(BaseCity):
population = middle.field(type=int)
latitude = middle.field(type=float)
longitude = middle.field(type=float)
base_city = BaseCity(name="London", region="TEMPERATE")
city = City(
name="London",
region="TEMPERATE",
population=8787892,
latitude=51.507222,
longitude=-0.1275,
)
assert isinstance(base_city, BaseCity)
assert isinstance(city, BaseCity)
assert isinstance(city, City)
assert isinstance(city.name, str)
assert isinstance(city.region, CityRegionEnum)
assert isinstance(city.population, int)
assert isinstance(city.latitude, float)
assert isinstance(city.longitude, float)
data = middle.asdict(city)
assert isinstance(data.get("name"), str)
assert isinstance(data.get("region"), str)
assert isinstance(data.get("population"), int)
assert isinstance(data.get("latitude"), float)
assert isinstance(data.get("longitude"), float)
def test_attr_class():
@attr.s(cmp=False)
class AttrModel:
name = attr.ib(type=str)
age = attr.ib(type=int)
class TestModel(middle.Model):
people = middle.field(type=List[AttrModel])
inst = TestModel(
people=[AttrModel(name="Foo", age=21),
AttrModel(name="Bar", age=42)])
assert isinstance(inst, TestModel)
assert isinstance(inst.people, list)
assert isinstance(inst.people[0], AttrModel)
assert isinstance(inst.people[1], AttrModel)
data = middle.asdict(inst)
assert isinstance(data, dict)
assert isinstance(data.get("people"), list)
assert isinstance(data.get("people")[0], dict)
assert isinstance(data.get("people")[1], dict)
def test_model_working():
class ColorEnum(IntEnum):
RED = 1
GREEN = 2
BLUE = 3
YELLOW = 4
PINK = 5
BLACK = 6
class ChildModel(middle.Model):
name = middle.field(type=str)
age = middle.field(type=int)
favourite_color = middle.field(type=ColorEnum)
class PersonModel(middle.Model):
name = middle.field(type=str)
age = middle.field(type=int)
children = middle.field(type=List[ChildModel])
class CompanyModel(middle.Model):
name = middle.field(type=str)
manager = middle.field(type=PersonModel)
employees = middle.field(type=List[PersonModel])
inst = CompanyModel({
"name":
"My Company Ltd",
"manager": {
"name": "John",
"age": 42,
"children": []
},
"employees": [
{
"name":
"Jane",
"age":
35,
"children": [
{
"name": "Clarice",
"age": 5,
"favourite_color": 4
},
{
"name": "Robert",
"age": 8,
"favourite_color": 1
},
],
},
{
"name": "Carl",
"age": 22,
"children": []
},
],
})
assert isinstance(inst, CompanyModel)
assert isinstance(inst.manager, PersonModel)
assert isinstance(inst.employees[0], PersonModel)
assert isinstance(inst.employees[1], PersonModel)
assert isinstance(inst.employees[0].children[0], ChildModel)
assert isinstance(inst.employees[0].children[1], ChildModel)
assert inst.name == "My Company Ltd"
assert inst.manager.name == "John"
assert inst.manager.age == 42
assert inst.manager.children == []
assert inst.employees[0].name == "Jane"
assert inst.employees[0].age == 35
assert inst.employees[0].children[0].name == "Clarice"
assert inst.employees[0].children[0].age == 5
assert inst.employees[0].children[0].favourite_color == ColorEnum.YELLOW
assert inst.employees[0].children[1].name == "Robert"
assert inst.employees[0].children[1].age == 8
assert inst.employees[0].children[1].favourite_color == ColorEnum.RED
assert inst.employees[1].name == "Carl"
assert inst.employees[1].age == 22
assert inst.employees[1].children == []
data = middle.asdict(inst)
assert isinstance(data, dict)
assert (data.get("employees")[0].get("children")[0].get("favourite_color")
== 4)
def test_middle():
game = GameModel(**MODEL_INSTANCE)
assert isinstance(game, GameModel)
assert isinstance(game.awesome_city, CityModel)
p = middle.asdict(game)
assert isinstance(p, dict)
def test_middle():
p = middle.asdict(MODEL_INSTANCE)
assert isinstance(p, dict)
game = Game(**p)
assert isinstance(game, Game)
assert isinstance(game.awesome_city, City)
