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_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'