def test_auto_doc_type_mapping(self):
person = Person(first_name="Simion", last_name="Baws")
person.save()
doc_type = person.get_es_doc_mapping()
self.assertEqual(doc_type.first_name, person.first_name)
self.assertEqual(doc_type.last_name, person.last_name)
self.assertEqual(
doc_type.full_name,
u"{0} {1}".format(person.first_name, person.last_name)
)
def test_unique():
person = Person.create(name='tim')
validator = ModelValidator(Person(name='tim'))
valid = validator.validate({'gender': 'M'})
assert not valid
assert validator.errors['name'] == DEFAULT_MESSAGES['unique']
validator = ModelValidator(person)
valid = validator.validate({'gender': 'M'})
assert valid
def test_has_no_changes(self):
justin = Person(first_name='Justin', last_name='Trudeau')
justin.save()
serializer = PersonSerializer(justin, data={
'first_name': 'Justin',
'last_name': 'Trudeau',
'partner': ''
})
serializer.is_valid()
self.assertFalse(serializers.has_changes(serializer))
def test_might_have_changes_returns_true(self):
justin = Person(first_name='Justin', last_name='Trudeau')
justin.save()
serializer = PersonSerializer(justin, data={
'first_name': 'Justin',
'last_name': 'Trudeau2',
'partner': ''
})
might_have_changes = serializers.might_have_changes(serializer)
self.assertTrue(might_have_changes)
def test_unique():
person = Person(name='tim')
person.save()
validator = ModelValidator(Person(name='tim'))
valid = validator.validate({'gender': 'M'})
assert not valid
assert validator.errors['name'] == 'must be a unique value'
validator = ModelValidator(person)
valid = validator.validate({'gender': 'M'})
assert valid
def test_get_diff_data_for_exisiting_object_with_no_changes(self):
justin = Person(first_name='Justin', last_name='Trudeau')
justin.save()
serializer = PersonSerializer(justin, data={
'first_name': 'Justin',
'last_name': 'Trudeau',
'partner': ''
})
serializer.is_valid()
diff = serializers.get_diff_data(serializer)
self.assertEqual(diff, None)
def test_null_issues(self):
""" Make sure nullable values are set properly when null
#42 introduced an issue where values may not have been properly
set if the value is supposed to be set to null
"""
Base = declarative_base()
class Person(Base):
__tablename__ = 'person'
id = Column(Integer, primary_key=True)
fullname = Column(String, nullable=True)
age = Column(Integer, nullable=True)
schema = SQLAlchemySchemaNode(Person)
person = Person(
id=7,
fullname="Joe Smith",
age=35,
)
# dict coming from a form submission
update_cstruct = {
'id': '7',
'fullname': '',
'age': '',
}
update_appstruct = schema.deserialize(update_cstruct)
schema.objectify(update_appstruct, context=person)
self.assertEqual(person.id, 7)
self.assertEqual(person.fullname, None)
self.assertEqual(person.age, None)
def generate_colander():
class Phone(colander.MappingSchema):
person_id = colander.SchemaNode(colander.Int())
number = colander.SchemaNode(
colander.String(),
validator=colander.Length(0, 128)
)
location = colander.SchemaNode(
colander.String(),
validator=colander.OneOf(['home', 'work']),
missing=colander.null
)
class Phones(colander.SequenceSchema):
phones = Phone(missing=[])
class Person(colander.MappingSchema):
id = colander.SchemaNode(colander.Int(),
missing=colander.drop)
name = colander.SchemaNode(
colander.String(),
validator=colander.Length(0, 128)
)
surname = colander.SchemaNode(
colander.String(),
validator=colander.Length(0, 128)
)
phones = Phones(missing=[])
return Person()
def test_request_body(self):
"The SSR request sends the props in a expected way"
responses.add(responses.POST,
'http://react-service.dev',
body='<h1>Title</h1>',
status=200)
person = Person(first_name='Tom', last_name='Waits')
self.mocked_context["person"] = person
self.mocked_context["component_data"] = {'album': 'Real gone'}
Template(
"{% load react %}"
"{% react_render component=\"Component\" prop_person=person data=component_data %}" # NOQA
).render(self.mocked_context)
request_body = {
'componentName': 'Component',
'props': {
'album': 'Real gone',
'person': {
'first_name': 'Tom',
'last_name': 'Waits'
}
}
}
self.assertTrue(
json.loads(responses.calls[0].request.body) == request_body)
def test_clean_error():
class TestValidator(ModelValidator):
def clean(self, data):
raise ValidationError('required')
validator = TestValidator(Person())
valid = validator.validate({'name': 'tim'})
assert not valid
assert validator.data['name'] == 'tim'
assert validator.errors['__base__'] == 'must be provided'
def test_unique():
person = Person.create(name='tim')
validator = ModelValidator(Person(name='tim'))
valid = validator.validate({'gender': 'M'})
assert not valid
assert validator.errors['name'] == DEFAULT_MESSAGES['unique']
validator = ModelValidator(person)
valid = validator.validate({'gender': 'M'})
assert valid
def test_clean():
class TestValidator(ModelValidator):
def clean(self, data):
super().clean(data)
data['name'] += 'awesome'
return data
validator = TestValidator(Person())
valid = validator.validate({'name': 'tim'})
assert valid
assert validator.data['name'] == 'timawesome'
def generate_colander():
class Person(colander.MappingSchema):
id = colander.SchemaNode(colander.Float(),
title='Person ID',
description='The Person identifier.',
missing=colander.drop,
widget='Empty Widget')
name = colander.SchemaNode(colander.String(),
validator=colander.Length(0, 128),
default=colander.required)
return Person()
def generate_colander():
class Friend(colander.MappingSchema):
person_id = colander.SchemaNode(colander.Int())
friend_of = colander.SchemaNode(colander.Int())
rank = colander.SchemaNode(colander.Int(),
missing=0,
default=0)
class Phone(colander.MappingSchema):
person_id = colander.SchemaNode(colander.Int())
number = colander.SchemaNode(
colander.String(),
validator=colander.Length(0, 128)
)
location = colander.SchemaNode(
colander.String(),
validator=colander.OneOf(['home', 'work']),
missing=colander.null
)
class Friends(colander.SequenceSchema):
friends = Friend(missing=[])
class Phones(colander.SequenceSchema):
phones = Phone(missing=[])
class Person(colander.MappingSchema):
id = colander.SchemaNode(
colander.Int(),
missing=colander.drop
)
name = colander.SchemaNode(
colander.String(),
validator=colander.Length(0, 128)
)
surname = colander.SchemaNode(
colander.String(),
validator=colander.Length(0, 128)
)
gender = colander.SchemaNode(
colander.String(),
validator=colander.OneOf(['M', 'F']),
missing=colander.null
)
age = colander.SchemaNode(
colander.Int(),
missing=colander.null
)
phones = Phones(missing=[])
friends = Friends(missing=[])
return Person()
def test_model_representation_data(self):
"Tests that react representation of model is transformed"
person = Person(first_name='Tom', last_name='Waits')
self.mocked_context["component_data"] = person
out = Template(
"{% load react %}"
"{% react_render component=\"Component\" data=component_data %}"
"{% react_print %}").render(self.mocked_context)
self.assertTrue('"first_name": "Tom"' in out)
self.assertTrue('"last_name": "Waits"' in out)
def test_combined_data_and_individual_props(self):
"Tests that templatetag can accept individual prop types"
person = Person(first_name='Tom', last_name='Waits')
self.mocked_context["person"] = person
self.mocked_context["component_data"] = {'name': 'Tom Waits'}
out = Template(
"{% load react %}"
"{% react_render component=\"Component\" data=component_data prop_person=person %}" # NOQA
"{% react_print %}").render(self.mocked_context)
self.assertTrue('person":' in out)
self.assertTrue('"first_name": "Tom"' in out)
self.assertTrue('"last_name": "Waits"' in out)
self.assertTrue('name": "Tom Waits"' in out)
def test_individual_prop_data(self):
"Tests that templatetag can accept individual prop types"
person = Person(first_name='Tom', last_name='Waits')
self.mocked_context["person"] = person
self.mocked_context["album"] = 'Small Change'
out = Template(
"{% load react %}"
"{% react_render component=\"Component\" prop_person=person prop_album=album %}" # NOQA
"{% react_print %}").render(self.mocked_context)
self.assertTrue('person":' in out)
self.assertFalse('prop_person":' in out)
self.assertTrue('"first_name": "Tom"' in out)
self.assertTrue('"last_name": "Waits"' in out)
self.assertTrue('album": "Small Change"' in out)
def test_dictify(self):
""" Test SQLAlchemySchemaNode.dictify(obj)
"""
schema = self._prep_schema()
address_args = dict(street='My Street', city='My City')
address = Address(**address_args)
person_args = dict(name='My Name',
surname='My Surname',
gender='M',
addresses=[address])
person = Person(**person_args)
account_args = dict(email='*****@*****.**',
enabled=True,
created=datetime.datetime.now(),
timeout=datetime.time(hour=1, minute=0),
person=person)
account = Account(**account_args)
appstruct = schema.dictify(account)
person_args['addresses'] = [address_args]
account_args['person'] = person_args
self.assertEqual(appstruct, account_args)
for account_key in account_args:
self.assertIn(account_key, appstruct)
if account_key == 'person':
for person_key in person_args:
self.assertIn(person_key, appstruct[account_key])
if person_key == 'addresses':
for address_key in address_args:
self.assertIn(
address_key,
appstruct[account_key][person_key][0])
# test that you can serialize this appstruct and you get
# the same result when you deserialize
cstruct = schema.serialize(appstruct=appstruct)
newappstruct = schema.deserialize(cstruct)
self.assertEqual(appstruct, newappstruct)
def assert_instance_works():
validator = ModelValidator(Person())
valid = validator.validate({'name': 'timster'})
assert valid
assert isinstance(validator.data, Person)
assert validator.data.name == 'timster'
def test_export_one_to_many(self):
hadrien = Person(first_name='Hadrien', last_name='Trudeau')
xavier = Person(first_name='Xavier', last_name='Trudeau')
ella_grace = Person(first_name='Ella-Grace', last_name='Trudeau')
justin = Person(first_name='Justin', last_name='Trudeau')
hadrien.save()
xavier.save()
ella_grace.save()
justin.save()
justin.children.add(hadrien)
justin.children.add(xavier)
justin.children.add(ella_grace)
justin.save()
serializer = PersonSerializer()
rep = serializer.to_representation(instance=justin)
children = rep['children']
self.assertEqual(children, [u'Hadrien', u'Xavier', u'Ella-Grace'])
def test_instance():
instance = Person()
validator = ModelValidator(instance)
valid = validator.validate({'name': 'tim'})
assert valid
assert validator.data['name'] == 'tim'
def test_required():
validator = ModelValidator(Person())
valid = validator.validate()
assert not valid
assert validator.errors['name'] == DEFAULT_MESSAGES['required']
def test_required():
validator = ModelValidator(Person())
valid = validator.validate()
assert not valid
assert validator.errors['name'] == 'must be provided'
