def test_it__jsondict_from_model():
from alchemyjsonschema import AlsoChildrenWalker, SchemaFactory
from .models import Group, User
schema_factory = SchemaFactory(AlsoChildrenWalker)
target = _makeOne(schema_factory, Group)
group = Group(name="ravenclaw",
color="blue",
created_at=_datetime(2000, 1, 1, 10, 0, 0, 0))
group.users = [
User(name="foo", created_at=_datetime(2000, 1, 1, 10, 0, 0, 0))
]
jsondict = target.jsondict_from_object(group, verbose=True)
import json
assert json.dumps(jsondict)
assert jsondict == {
'color':
'blue',
'name':
'ravenclaw',
'users': [{
'name': 'foo',
'pk': None,
'created_at': '2000-01-01T10:00:00+00:00'
}],
'pk':
None,
'created_at':
'2000-01-01T10:00:00+00:00'
}
def test_it__object_from_dict():
from alchemyjsonschema import AlsoChildrenWalker, SchemaFactory
from .models import Group, User
schema_factory = SchemaFactory(AlsoChildrenWalker)
target = _makeOne(schema_factory, Group)
group_dict = {
'color':
'blue',
'users': [{
'created_at': _datetime(2000, 1, 1, 10, 0, 0, 0),
'pk': None,
'name': 'foo'
}],
'created_at':
_datetime(2000, 1, 1, 10, 0, 0, 0),
'pk':
None,
'name':
'ravenclaw'
}
group = target.object_from_dict(group_dict, strict=False)
assert isinstance(group, Group)
assert group.color == "blue"
assert group.name == "ravenclaw"
assert group.pk is None
assert group.created_at == _datetime(2000, 1, 1, 10, 0, 0, 0)
assert (len(group.users) == 1) and (isinstance(group.users[0], User))
assert group.users[0].name == "foo"
assert group.users[0].pk is None
assert group.users[0].created_at == _datetime(2000, 1, 1, 10, 0, 0, 0)
def test_it__dict_from_model_object():
from alchemyjsonschema import AlsoChildrenWalker, SchemaFactory
from .models import Group, User
schema_factory = SchemaFactory(AlsoChildrenWalker)
target = _makeOne(schema_factory, Group)
group = Group(name="ravenclaw",
color="blue",
created_at=_datetime(2000, 1, 1, 10, 0, 0, 0))
group.users = [
User(name="foo", created_at=_datetime(2000, 1, 1, 10, 0, 0, 0))
]
group_dict = target.dict_from_object(group)
assert group_dict == {
'color':
'blue',
'users': [{
'created_at': _datetime(2000, 1, 1, 10, 0, 0, 0),
'pk': None,
'name': 'foo'
}],
'created_at':
_datetime(2000, 1, 1, 10, 0, 0, 0),
'pk':
None,
'name':
'ravenclaw'
}
def test_it__jsondict_from_model():
from alchemyjsonschema import StructuralWalker, SchemaFactory
from .models import Group, User
schema_factory = SchemaFactory(StructuralWalker)
target = _makeOne(schema_factory, Group)
group = Group(name="ravenclaw",
color="blue",
created_at=_datetime(2000, 1, 1, 10, 0, 0, 0))
group.users = [
User(name="foo", created_at=_datetime(2000, 1, 1, 10, 0, 0, 0))
]
jsondict = target.jsondict_from_object(group, verbose=True)
import json
assert json.dumps(jsondict)
assert jsondict == {
"color":
"blue",
"name":
"ravenclaw",
"users": [{
"name": "foo",
"pk": None,
"created_at": "2000-01-01T10:00:00+00:00"
}],
"pk":
None,
"created_at":
"2000-01-01T10:00:00+00:00",
}
def test_it__dict_from_model_object():
from alchemyjsonschema import StructuralWalker, SchemaFactory
from .models import Group, User
schema_factory = SchemaFactory(StructuralWalker)
target = _makeOne(schema_factory, Group)
group = Group(name="ravenclaw",
color="blue",
created_at=_datetime(2000, 1, 1, 10, 0, 0, 0))
group.users = [
User(name="foo", created_at=_datetime(2000, 1, 1, 10, 0, 0, 0))
]
group_dict = target.dict_from_object(group)
assert group_dict == {
"color":
"blue",
"users": [{
"created_at": _datetime(2000, 1, 1, 10, 0, 0, 0),
"pk": None,
"name": "foo",
}],
"created_at":
_datetime(2000, 1, 1, 10, 0, 0, 0),
"pk":
None,
"name":
"ravenclaw",
}
def test_it__object_from_dict():
from alchemyjsonschema import StructuralWalker, SchemaFactory
from .models import Group, User
schema_factory = SchemaFactory(StructuralWalker)
target = _makeOne(schema_factory, Group)
group_dict = {
"color":
"blue",
"users": [{
"created_at": _datetime(2000, 1, 1, 10, 0, 0, 0),
"pk": None,
"name": "foo",
}],
"created_at":
_datetime(2000, 1, 1, 10, 0, 0, 0),
"pk":
None,
"name":
"ravenclaw",
}
group = target.object_from_dict(group_dict, strict=False)
assert isinstance(group, Group)
assert group.color == "blue"
assert group.name == "ravenclaw"
assert group.pk is None
assert group.created_at == _datetime(2000, 1, 1, 10, 0, 0, 0)
assert (len(group.users) == 1) and (isinstance(group.users[0], User))
assert group.users[0].name == "foo"
assert group.users[0].pk is None
assert group.users[0].created_at == _datetime(2000, 1, 1, 10, 0, 0, 0)
def test_it_complex2():
from alchemyjsonschema import SchemaFactory, AlsoChildrenWalker
from alchemyjsonschema.dictify import ModelLookup
import alchemyjsonschema.tests.models as models
from datetime import datetime
factory = SchemaFactory(AlsoChildrenWalker)
group_schema = factory(models.Group)
created_at = datetime(2000, 1, 1)
created_at2 = datetime(2001, 1, 1)
user_dict = dict(name="foo", created_at=created_at) # pk is not found
group_dict = dict(name="ravenclaw",
color="blue",
created_at=created_at2,
users=[user_dict])
modellookup = ModelLookup(models)
result = _callFUT(group_dict, group_schema, modellookup, strict=False)
assert isinstance(result, models.Group)
assert result.pk is None
assert result.name == "ravenclaw"
assert result.color == "blue"
assert result.created_at == datetime(2001, 1, 1)
assert isinstance(result.users[0], models.User)
assert result.users[0].name == "foo"
assert result.users[0].created_at == created_at
assert modellookup.name_stack == []
def test_it_nested():
from alchemyjsonschema.tests import models
from alchemyjsonschema import SchemaFactory, AlsoChildrenWalker
from alchemyjsonschema.dictify import ModelLookup
factory = SchemaFactory(AlsoChildrenWalker)
a_schema = factory(models.A0)
modellookup = ModelLookup(models)
params = {
"name":
"a0",
"children": [{
"name":
"a00",
"children": [{
"name": "a000"
}, {
"name": "a001"
}, {
"name": "a002"
}]
}, {
"name": "a10",
"children": [{
"name": "a010"
}]
}]
}
result = _callFUT(params, a_schema, modellookup, strict=False)
assert len(result.children) == 2
assert len(result.children[0].children) == 3
assert len(result.children[1].children) == 1
def build_transformer(self, walker, decision, layout):
walker_factory = detect_walker_factory(walker)
relation_decision = detect_decision(decision)
schema_factory = SchemaFactory(walker_factory,
relation_decision=relation_decision)
transformer_factory = detect_transformer(layout)
return transformer_factory(schema_factory).transform
def test_it_complex__partial4():
from alchemyjsonschema import SchemaFactory, StructuralWalker
from alchemyjsonschema.dictify import ModelLookup
import alchemyjsonschema.tests.models as models
from datetime import datetime
factory = SchemaFactory(StructuralWalker)
group_schema = factory(models.Group)
created_at2 = datetime(2001, 1, 1)
group_dict = dict(name="ravenclaw",
color="blue",
created_at=created_at2,
users=[])
modellookup = ModelLookup(models)
result = _callFUT(group_dict, group_schema, modellookup, strict=False)
assert isinstance(result, models.Group)
assert result.pk is None
assert result.name == "ravenclaw"
assert result.color == "blue"
assert result.created_at == datetime(2001, 1, 1)
assert modellookup.name_stack == []
def test_it_complex__relation_decision():
from alchemyjsonschema import SchemaFactory, StructuralWalker, RelationDesicion
from alchemyjsonschema.dictify import ModelLookup
import alchemyjsonschema.tests.models as models
from datetime import datetime
factory = SchemaFactory(StructuralWalker,
relation_decision=RelationDesicion())
user_schema = factory(models.User)
created_at = datetime(2000, 1, 1)
created_at2 = datetime(2001, 1, 1)
group_dict = dict(name="ravenclaw", color="blue", created_at=created_at2)
user_dict = dict(name="foo", created_at=created_at,
group=group_dict) # pk is not found
modellookup = ModelLookup(models)
result = _callFUT(user_dict, user_schema, modellookup, strict=False)
assert isinstance(result, models.User)
assert result.pk is None
assert result.name == "foo"
assert result.created_at == datetime(2000, 1, 1)
assert result.group_id is None
assert isinstance(result.group, models.Group)
assert result.group.name == "ravenclaw"
assert result.group.color == "blue"
assert result.group.created_at == created_at2
assert modellookup.name_stack == []
def test_it_complex__fullset_decision():
from alchemyjsonschema import (
SchemaFactory,
StructuralWalker,
UseForeignKeyIfPossibleDecision,
)
from alchemyjsonschema.dictify import ModelLookup
import alchemyjsonschema.tests.models as models
from datetime import datetime
factory = SchemaFactory(
StructuralWalker, relation_decision=UseForeignKeyIfPossibleDecision())
user_schema = factory(models.User)
created_at = datetime(2000, 1, 1)
user_dict = dict(name="foo", created_at=created_at,
group_id=1) # pk is not found
modellookup = ModelLookup(models)
result = _callFUT(user_dict, user_schema, modellookup, strict=False)
assert isinstance(result, models.User)
assert result.pk is None
assert result.name == "foo"
assert result.created_at == datetime(2000, 1, 1)
assert result.group_id is 1
assert modellookup.name_stack == []
def json_schema(self):
"""
Provide the SQLAlchemy model as a separate object, so that it isn't cluttered with unnecessary attributes.
:return: The json schema for this model
"""
if self._json_schema is None:
factory = SchemaFactory(self.walker)
self._json_schema = factory.__call__(self.sa_model, excludes=self.excludes)
# TODO change to custom route with valid json-reference as per
# http://tools.ietf.org/html/draft-zyp-json-schema-04#section-6.2
self._json_schema['$schema'] = "http://json-schema.org/draft-04/schema#"
self._json_schema['private_routes'] = self.private_routes
self._json_schema['public_routes'] = self.public_routes
print self._json_schema
return self._json_schema
def test_no_required():
from alchemyjsonschema import StructuralWalker, SchemaFactory
from alchemyjsonschema.dictify import ModelLookup
from alchemyjsonschema.tests import models
schema_factory = SchemaFactory(StructuralWalker)
schema = schema_factory(models.MyModel, excludes=["id"])
modellookup = ModelLookup(models)
params = {"name": "foo", "value": 1}
_callFUT(params, schema, modellookup)
def test_it_reverse_update():
from alchemyjsonschema.tests import models as m
from alchemyjsonschema import SchemaFactory, StructuralWalker
from alchemyjsonschema.dictify import ModelLookup
factory = SchemaFactory(StructuralWalker)
a_schema = factory(m.A1)
modellookup = ModelLookup(m)
a0 = m.A0(pk=1, name="a0", children=[m.A1(pk=1, name="a00"), m.A1(pk=2, name=("a01"))])
assert a0.name == "a0"
params = {"pk": 1, "name": "a00", "parent": {"name": "updated", "pk": 1}}
_callFUT(a0.children[0], params, a_schema, modellookup)
assert a0.name == "updated"
def test_it__prepare_partial():
from alchemyjsonschema import SchemaFactory, StructuralWalker
from alchemyjsonschema.tests.models import Group
factory = SchemaFactory(StructuralWalker)
group_schema = factory(Group)
group_dict = {'name': 'ravenclaw', 'color': 'blue', 'pk': 1}
result = _callFUT3(group_dict, group_schema)
assert result == {
'name': 'ravenclaw',
'pk': 1,
'color': 'blue',
'users': []
}
def test_it__strict_true__then__required_are_notfound__error_raised():
from alchemyjsonschema import SchemaFactory, ForeignKeyWalker, InvalidStatus
from alchemyjsonschema.dictify import ModelLookup
import alchemyjsonschema.tests.models as models
from datetime import datetime
import pytest
factory = SchemaFactory(ForeignKeyWalker)
user_schema = factory(models.User)
created_at = datetime(2000, 1, 1)
user_dict = dict(name="foo", created_at=created_at) # pk is not found
modellookup = ModelLookup(models)
with pytest.raises(InvalidStatus):
_callFUT(user_dict, user_schema, modellookup, strict=True)
def test_it_update_parent__onlyone():
from alchemyjsonschema.tests import models as m
from alchemyjsonschema import SchemaFactory, NoForeignKeyWalker
from alchemyjsonschema.dictify import ModelLookup
factory = SchemaFactory(NoForeignKeyWalker)
a_schema = factory(m.A0)
modellookup = ModelLookup(m)
a0 = m.A0(pk=1, name="a0", children=[m.A1(pk=1, name="a00"), m.A1(pk=2, name=("a01"))])
assert a0.name == "a0"
params = {"pk": 1, "name": "updated"}
_callFUT(a0, params, a_schema, modellookup)
assert a0.name == "updated"
assert len(a0.children) == 2
