class AddressResponseTests(TestCase):
def setUp(self):
self.recipe = Recipe(
FormFieldResponse,
form_field__kind='address',
form_field__details={'required': True}
)
def test_should_pass_when_required_and_only_addr2_blank(self):
field_response = self.recipe.prepare(details={
'addressLine1': 'x', 'city': 'x', 'state': 'x', 'zip': 'x'
})
self.assertEqual(field_response.clean(), None)
def test_should_not_pass_when_required_and_any_field_but_addr2_blank(self):
field_response = self.recipe.prepare(details={
'addressLine1': '', 'city': 'x', 'state': 'x', 'zip': 'x'
})
self.assertRaises(ValidationError, field_response.clean)
def test_should_pass_when_not_required_and_all_fields_blank(self):
field_response = self.recipe.prepare()
field_response.form_field.details['required'] = False
self.assertEqual(field_response.clean(), None)
class LongAnswerResponseTests(TestCase):
def setUp(self):
self.recipe = Recipe(
FormFieldResponse,
form_field__kind='long-answer',
form_field__details={'required': True}
)
def test_should_pass_when_required_and_answer_not_blank(self):
field_response = self.recipe.prepare(details={'answer': 'ok'})
self.assertEqual(field_response.clean(), None)
def test_should_not_pass_when_required_and_answer_not_provided(self):
field_response = self.recipe.prepare(details={})
self.assertRaises(ValidationError, field_response.clean)
def test_should_not_pass_when_required_and_answer_blank(self):
field_response = self.recipe.prepare(details={'answer': ''})
self.assertRaises(ValidationError, field_response.clean)
def test_should_pass_when_not_required_and_answer_not_provided(self):
field_response = self.recipe.prepare(details={})
field_response.form_field.details['required'] = False
self.assertEqual(field_response.clean(), None)
def test_should_pass_when_not_required_and_answer_blank(self):
field_response = self.recipe.prepare(details={'answer': ''})
field_response.form_field.details['required'] = False
self.assertEqual(field_response.clean(), None)
class InfoResponseTests(TestCase):
def setUp(self):
self.recipe = Recipe(FormFieldResponse, form_field__kind='info')
def test_should_never_pass(self):
for details in [{}, {'answer': 'no good'}]:
field_response = self.recipe.prepare(details=details)
self.assertRaises(ValidationError, field_response.clean)
def test_prepare_recipe_with_foreign_key(self):
person_recipe = Recipe(Person, name='John Doe')
dog_recipe = Recipe(Dog,
owner=foreign_key(person_recipe),
)
dog = dog_recipe.prepare()
self.assertIsNone(dog.id)
self.assertIsNone(dog.owner.id)
def test_prepare_recipe_with_foreign_key(self):
person_recipe = Recipe(Person, name='John Doe')
dog_recipe = Recipe(
Dog,
owner=foreign_key(person_recipe),
)
dog = dog_recipe.prepare()
self.assertIsNone(dog.id)
self.assertIsNone(dog.owner.id)
def test_prepare_recipe_without_all_model_needed_data(self):
person_recipe = Recipe(Person, name='John Doe')
person = person_recipe.prepare()
assert 'John Doe' == person.name
assert person.nickname
assert person.age
assert person.bio
assert person.birthday
assert person.appointment
assert person.blog
assert person.wanted_games_qtd
assert not person.id
def test_prepare_recipe_without_all_model_needed_data(self):
person_recipe = Recipe(Person, name='John Doe')
person = person_recipe.prepare()
self.assertEqual('John Doe', person.name)
self.assertTrue(person.nickname)
self.assertTrue(person.age)
self.assertTrue(person.bio)
self.assertTrue(person.birthday)
self.assertTrue(person.appointment)
self.assertTrue(person.blog)
self.assertTrue(person.wanted_games_qtd)
self.assertFalse(person.id)
def test_prepare_recipe_without_all_model_needed_data(self):
person_recipe = Recipe(Person, name='John Doe')
person = person_recipe.prepare()
self.assertEqual('John Doe', person.name)
self.assertTrue(person.nickname)
self.assertTrue(person.age)
self.assertTrue(person.bio)
self.assertTrue(person.birthday)
self.assertTrue(person.appointment)
self.assertTrue(person.blog)
self.assertTrue(person.wanted_games_qtd)
self.assertFalse(person.id)
def test_do_query_lookup_empty_recipes(self):
"""
It should not attempt to create other object when
using query lookup syntax
"""
dog_recipe = Recipe(Dog)
dog = dog_recipe.make(owner__name='James')
self.assertEqual(Person.objects.count(), 1)
self.assertEqual(dog.owner.name, 'James')
dog = dog_recipe.prepare(owner__name='Zezin')
self.assertEqual(Person.objects.count(), 2)
self.assertEqual(dog.owner.name, 'Zezin')
def test_do_query_lookup_empty_recipes(self):
"""
It should not attempt to create other object when
using query lookup syntax
"""
dog_recipe = Recipe(Dog)
dog = dog_recipe.make(owner__name='James')
self.assertEqual(Person.objects.count(), 1)
self.assertEqual(dog.owner.name, 'James')
dog = dog_recipe.prepare(owner__name='Zezin')
self.assertEqual(Person.objects.count(), 1)
self.assertEqual(dog.owner.name, 'Zezin')
class SingleChoiceResponseTests(TestCase):
def setUp(self):
self.recipe = Recipe(
FormFieldResponse,
form_field__kind='single-choice',
form_field__details={
'choices': [{'label': 'A'}, {'label': 'B'}, {'label': 'C'}],
'required': True
}
)
def test_should_pass_when_required_and_answer_valid_choice(self):
field_response = self.recipe.prepare(details={'answer': 'B'})
self.assertEqual(field_response.clean(), None)
def test_should_not_pass_when_required_and_answer_non_choice(self):
field_response = self.recipe.prepare(details={'answer': 'X'})
self.assertRaises(ValidationError, field_response.clean)
def test_should_not_pass_when_required_and_answer_not_provided(self):
field_response = self.recipe.prepare(details={})
self.assertRaises(ValidationError, field_response.clean)
def test_should_not_pass_when_required_and_answer_blank(self):
field_response = self.recipe.prepare(details={'answer': ''})
self.assertRaises(ValidationError, field_response.clean)
def test_should_not_pass_when_not_required_and_answer_non_choice(self):
field_response = self.recipe.prepare(details={'answer': 'X'})
field_response.form_field.details['required'] = False
self.assertRaises(ValidationError, field_response.clean)
def test_should_pass_when_not_required_and_answer_not_provided(self):
field_response = self.recipe.prepare(details={})
field_response.form_field.details['required'] = False
self.assertEqual(field_response.clean(), None)
def test_should_pass_when_not_required_and_answer_blank(self):
field_response = self.recipe.prepare(details={'answer': ''})
field_response.form_field.details['required'] = False
self.assertEqual(field_response.clean(), None)
class ImovelTest(TestCase):
def setUp(self):
self.endereco_base = 'Rua Baronesa, 175'
self.cidade_base = 'Rio de Janeiro'
self.lat_base = -22.8950148
self.lng_base = -43.3542673
self.imovel = mommy.make(Imovel)
self.basic_imovel_recipe = Recipe(Imovel, latitude=None, longitude=None)
imoveis_recipe = Recipe(Imovel,
endereco=self.endereco_base,
cidade=self.cidade_base,
latitude=self.lat_base,
longitude=self.lng_base,
disponivel=cycle([False, True])
)
# Cria 9 imóveis alterando disponíveis e indisponíveis
imoveis_recipe.make(_quantity=9)
def test_get_disponiveis_qtd(self):
"""Garante que tem 5 imóveis disponíveis apenas"""
imoveis = Imovel.get_disponiveis()
self.assertEqual(5, len(imoveis))
def test_get_disponiveis_value(self):
"""Garante que todos os imóveis retornados estão com disponível True"""
imoveis = Imovel.get_disponiveis()
self.assertEqual([True] * len(imoveis), [i.disponivel for i in imoveis])
def test_get_proximos_a_vazio(self):
imoveis = Imovel.get_proximos_a(latitude=0, longitude=0)
self.assertEqual(0, len(imoveis))
def test_get_proximos(self):
coordenadas = get_coordenates("Rua Baronesa, 300, Rio de Janeiro")
imoveis = Imovel.get_proximos_a(latitude=coordenadas[0], longitude=coordenadas[1])
self.assertGreater(len(imoveis), 0)
def test_get_proximos_mais_longe(self):
coordenadas = get_coordenates("Rua Nelson Cardoso, 300, Rio de Janeiro")
imoveis = Imovel.get_proximos_a(latitude=coordenadas[0], longitude=coordenadas[1])
self.assertEquals(len(imoveis), 0)
def test_get_proximos_mais_longe_haversine(self):
""" Esse endereço fica a 1.2km do endereço que possui imóveis
Porém ele fica dentro das coordenadas mínimas e máximas.
A validação adicional através da fórmula garante que nenhum resultado será encontrado
"""
coordenadas = get_coordenates("Rua Luiz Beltrão, 646, Rio de Janeiro")
# Garante que o endereço pesquisado está dentro do "quadrado" inicial de filtragem
bounds = get_min_max_coordenates(self.lat_base, self.lng_base)
self.assertGreaterEqual(coordenadas[0], bounds[0])
self.assertLessEqual(coordenadas[0], bounds[1])
self.assertGreater(coordenadas[1], bounds[2])
self.assertLessEqual(coordenadas[1], bounds[3])
# Procura imóveis na região do endereço, mas graças a fórmula ninguém é encontrado
imoveis = Imovel.get_proximos_a(latitude=coordenadas[0], longitude=coordenadas[1])
self.assertEquals(len(imoveis), 0)
def test_custom_save_erro(self):
imovel = self.basic_imovel_recipe.prepare()
with self.assertRaises(IntegrityError):
imovel.save()
def test_custom_save(self):
imovel = self.basic_imovel_recipe.prepare(endereco=self.endereco_base, cidade=self.cidade_base)
imovel.save()
self.assertIsNotNone(imovel.latitude)
self.assertIsNotNone(imovel.longitude)
self.assertIsNotNone(imovel.endereco_formatado)
def test_remover_anuncio(self):
self.imovel.remover_anuncio()
self.assertFalse(self.imovel.disponivel)
def test_str(self):
self.assertTrue('Imóvel em %s' % self.imovel.endereco, str(self.imovel))
class TestDefiningRecipes(TestCase):
def setUp(self):
self.recipe_attrs = {
'name': 'John Doe',
'nickname': 'joe',
'age': 18,
'bio': 'Someone in the crowd',
'birthday': now().date(),
'appointment': now(),
'blog': 'http://joe.blogspot.com',
'wanted_games_qtd': 4,
'birth_time': now()
}
self.person_recipe = Recipe(Person, **self.recipe_attrs)
def test_flat_model_make_recipe_with_the_correct_attributes(self):
"""
A 'flat model' means a model without associations, like
foreign keys, many to many and one to one
"""
person = self.person_recipe.make()
self.assertEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd,
self.recipe_attrs['wanted_games_qtd'])
self.assertNotEqual(person.id, None)
def test_flat_model_prepare_recipe_with_the_correct_attributes(self):
person = self.person_recipe.prepare()
self.assertEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd,
self.recipe_attrs['wanted_games_qtd'])
self.assertEqual(person.id, None)
def test_accepts_callable(self):
r = Recipe(DummyBlankFieldsModel,
blank_char_field=lambda: 'callable!!')
value = r.make().blank_char_field
self.assertEqual(value, 'callable!!')
def test_always_calls_when_creating(self):
with patch('test.generic.tests.test_recipes.choice') as choice_mock:
l = ['foo', 'bar', 'spam', 'eggs']
r = Recipe(DummyBlankFieldsModel,
blank_char_field=lambda: choice(l))
r.make().blank_char_field
r.make().blank_char_field
self.assertEqual(choice_mock.call_count, 2)
def test_always_calls_with_quantity(self):
with patch('test.generic.tests.test_recipes.choice') as choice_mock:
l = ['foo', 'bar', 'spam', 'eggs']
r = Recipe(DummyBlankFieldsModel,
blank_char_field=lambda: choice(l))
r.make(_quantity=3)
self.assertEqual(choice_mock.call_count, 3)
def test_make_recipes_with_args(self):
"""
Overriding some fields values at recipe execution
"""
person = self.person_recipe.make(name='Guido', age=56)
self.assertNotEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.name, 'Guido')
self.assertNotEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.age, 56)
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd,
self.recipe_attrs['wanted_games_qtd'])
self.assertNotEqual(person.id, None)
def test_prepare_recipes_with_args(self):
"""
Overriding some fields values at recipe execution
"""
person = self.person_recipe.prepare(name='Guido', age=56)
self.assertNotEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.name, 'Guido')
self.assertNotEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.age, 56)
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd,
self.recipe_attrs['wanted_games_qtd'])
self.assertEqual(person.id, None)
def test_make_recipe_without_all_model_needed_data(self):
person_recipe = Recipe(Person, name='John Doe')
person = person_recipe.make()
self.assertEqual('John Doe', person.name)
self.assertTrue(person.nickname)
self.assertTrue(person.age)
self.assertTrue(person.bio)
self.assertTrue(person.birthday)
self.assertTrue(person.appointment)
self.assertTrue(person.blog)
self.assertTrue(person.wanted_games_qtd)
self.assertTrue(person.id)
def test_prepare_recipe_without_all_model_needed_data(self):
person_recipe = Recipe(Person, name='John Doe')
person = person_recipe.prepare()
self.assertEqual('John Doe', person.name)
self.assertTrue(person.nickname)
self.assertTrue(person.age)
self.assertTrue(person.bio)
self.assertTrue(person.birthday)
self.assertTrue(person.appointment)
self.assertTrue(person.blog)
self.assertTrue(person.wanted_games_qtd)
self.assertFalse(person.id)
def test_defining_recipes_str(self):
from model_mommy.recipe import seq
p = Recipe('generic.Person', name=seq('foo'))
try:
p.make(_quantity=5)
except AttributeError as e:
self.fail('%s' % e)
class MultipleChoiceResponseTests(TestCase):
def setUp(self):
self.recipe = Recipe(
FormFieldResponse,
form_field__kind='multiple-choice',
form_field__details={
'choices': [{'label': 'A'}, {'label': 'B'}, {'label': 'C'}],
'required': True
}
)
def test_should_set_left_out_answers_to_false(self):
field_response = self.recipe.prepare(
details={'answers': [{'label': 'B', 'selected': True}]}
)
field_response.clean()
self.assertItemsEqual(field_response.details, {'answers': [
{'label': 'A', 'selected': False},
{'label': 'B', 'selected': True},
{'label': 'C', 'selected': False},
]})
def test_should_pass_when_required_and_at_least_one_answer_selected(self):
field_response = self.recipe.prepare(
details={'answers': [
{'label': 'A', 'selected': True},
{'label': 'B', 'selected': False},
{'label': 'C', 'selected': False},
]}
)
self.assertEqual(field_response.clean(), None)
def test_should_not_pass_when_required_and_any_answer_non_choice(self):
field_response = self.recipe.prepare(
details={'answers': [
{'label': 'A', 'selected': True},
{'label': 'X', 'selected': False},
{'label': 'C', 'selected': False},
]}
)
self.assertRaises(ValidationError, field_response.clean)
def test_should_not_pass_when_required_and_no_answers_provided(self):
field_response = self.recipe.prepare(details={})
self.assertRaises(ValidationError, field_response.clean)
def test_should_not_pass_when_required_and_all_answers_false(self):
field_response = self.recipe.prepare(
details={'answers': [
{'label': 'A', 'selected': False},
{'label': 'B', 'selected': False},
{'label': 'C', 'selected': False},
]}
)
self.assertRaises(ValidationError, field_response.clean)
def test_should_not_pass_when_not_required_and_any_answer_non_choice(self):
field_response = self.recipe.prepare(
details={'answers': [
{'label': 'A', 'selected': True},
{'label': 'X', 'selected': False},
{'label': 'C', 'selected': False},
]}
)
field_response.form_field.details['required'] = False
self.assertRaises(ValidationError, field_response.clean)
def test_should_pass_when_not_required_and_no_answers_provided(self):
field_response = self.recipe.prepare(details={})
field_response.form_field.details['required'] = False
self.assertEqual(field_response.clean(), None)
def test_should_pass_when_not_required_and_all_answers_false(self):
field_response = self.recipe.prepare(
details={'answers': [
{'label': 'A', 'selected': False},
{'label': 'B', 'selected': False},
{'label': 'C', 'selected': False},
]}
)
field_response.form_field.details['required'] = False
self.assertEqual(field_response.clean(), None)
class TestDefiningRecipes(TestCase):
def setUp(self):
self.recipe_attrs = {
'name': 'John Doe',
'nickname': 'joe',
'age': 18,
'bio': 'Someone in the crowd',
'birthday': now().date(),
'appointment': now(),
'blog': 'http://joe.blogspot.com',
'wanted_games_qtd': 4,
'birth_time': now()
}
self.person_recipe = Recipe(
Person,
**self.recipe_attrs
)
def test_flat_model_make_recipe_with_the_correct_attributes(self):
"""
A 'flat model' means a model without associations, like
foreign keys, many to many and one to one
"""
person = self.person_recipe.make()
self.assertEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs['wanted_games_qtd'])
self.assertNotEqual(person.id, None)
def test_flat_model_prepare_recipe_with_the_correct_attributes(self):
person = self.person_recipe.prepare()
self.assertEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs['wanted_games_qtd'])
self.assertEqual(person.id, None)
def test_accepts_callable(self):
r = Recipe(DummyBlankFieldsModel,
blank_char_field = lambda: 'callable!!'
)
value = r.make().blank_char_field
self.assertEqual(value, 'callable!!')
def test_always_calls_when_creating(self):
with patch('test.generic.tests.test_recipes.choice') as choice_mock:
l = ['foo', 'bar', 'spam', 'eggs']
r = Recipe(DummyBlankFieldsModel,
blank_char_field = lambda: choice(l)
)
r.make().blank_char_field
r.make().blank_char_field
self.assertEqual(choice_mock.call_count, 2)
def test_always_calls_with_quantity(self):
with patch('test.generic.tests.test_recipes.choice') as choice_mock:
l = ['foo', 'bar', 'spam', 'eggs']
r = Recipe(DummyBlankFieldsModel,
blank_char_field = lambda: choice(l)
)
r.make(_quantity=3)
self.assertEqual(choice_mock.call_count, 3)
def test_make_recipes_with_args(self):
"""
Overriding some fields values at recipe execution
"""
person = self.person_recipe.make(name='Guido', age=56)
self.assertNotEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.name, 'Guido')
self.assertNotEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.age, 56)
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs['wanted_games_qtd'])
self.assertNotEqual(person.id, None)
def test_prepare_recipes_with_args(self):
"""
Overriding some fields values at recipe execution
"""
person = self.person_recipe.prepare(name='Guido', age=56)
self.assertNotEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.name, 'Guido')
self.assertNotEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.age, 56)
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs['wanted_games_qtd'])
self.assertEqual(person.id, None)
def test_make_recipe_without_all_model_needed_data(self):
person_recipe = Recipe(Person, name='John Doe')
person = person_recipe.make()
self.assertEqual('John Doe', person.name)
self.assertTrue(person.nickname)
self.assertTrue(person.age)
self.assertTrue(person.bio)
self.assertTrue(person.birthday)
self.assertTrue(person.appointment)
self.assertTrue(person.blog)
self.assertTrue(person.wanted_games_qtd)
self.assertTrue(person.id)
def test_prepare_recipe_without_all_model_needed_data(self):
person_recipe = Recipe(Person, name='John Doe')
person = person_recipe.prepare()
self.assertEqual('John Doe', person.name)
self.assertTrue(person.nickname)
self.assertTrue(person.age)
self.assertTrue(person.bio)
self.assertTrue(person.birthday)
self.assertTrue(person.appointment)
self.assertTrue(person.blog)
self.assertTrue(person.wanted_games_qtd)
self.assertFalse(person.id)
class TestDefiningRecipes(TestCase):
def setUp(self):
self.recipe_attrs = {
'name': 'John Doe',
'nickname': 'joe',
'age': 18,
'bio': 'Someone in the crowd',
'birthday': now().date(),
'appointment': now(),
'blog': 'http://joe.blogspot.com',
'wanted_games_qtd': 4,
'birth_time': now()
}
self.person_recipe = Recipe(
Person,
**self.recipe_attrs
)
def test_flat_model_make_recipe_with_the_correct_attributes(self):
"""
A 'flat model' means a model without associations, like
foreign keys, many to many and one to one
"""
person = self.person_recipe.make()
self.assertEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs['wanted_games_qtd'])
self.assertNotEqual(person.id, None)
def test_flat_model_prepare_recipe_with_the_correct_attributes(self):
person = self.person_recipe.prepare()
self.assertEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs['wanted_games_qtd'])
self.assertEqual(person.id, None)
def test_accepts_callable(self):
r = Recipe(DummyBlankFieldsModel,
blank_char_field = lambda: 'callable!!'
)
value = r.make().blank_char_field
self.assertEqual(value, 'callable!!')
def test_make_recipes_with_args(self):
"""
Overriding some fields values at recipe execution
"""
person = self.person_recipe.make(name='Guido', age=56)
self.assertNotEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.name, 'Guido')
self.assertNotEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.age, 56)
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs['wanted_games_qtd'])
self.assertNotEqual(person.id, None)
def test_prepare_recipes_with_args(self):
"""
Overriding some fields values at recipe execution
"""
person = self.person_recipe.prepare(name='Guido', age=56)
self.assertNotEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.name, 'Guido')
self.assertNotEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.age, 56)
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs['wanted_games_qtd'])
self.assertEqual(person.id, None)
class TestDefiningRecipes(TestCase):
def setUp(self):
self.recipe_attrs = {
'name': 'John Doe',
'nickname': 'joe',
'age': 18,
'bio': 'Someone in the crowd',
'birthday': now().date(),
'appointment': now(),
'blog': 'http://joe.blogspot.com',
'wanted_games_qtd': 4,
'birth_time': now()
}
self.person_recipe = Recipe(Person, **self.recipe_attrs)
def test_flat_model_make_recipe_with_the_correct_attributes(self):
"""
A 'flat model' means a model without associations, like
foreign keys, many to many and one to one
"""
person = self.person_recipe.make()
self.assertEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd,
self.recipe_attrs['wanted_games_qtd'])
self.assertNotEqual(person.id, None)
def test_flat_model_prepare_recipe_with_the_correct_attributes(self):
person = self.person_recipe.prepare()
self.assertEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd,
self.recipe_attrs['wanted_games_qtd'])
self.assertEqual(person.id, None)
def test_accepts_callable(self):
r = Recipe(DummyBlankFieldsModel,
blank_char_field=lambda: 'callable!!')
value = r.make().blank_char_field
self.assertEqual(value, 'callable!!')
def test_make_recipes_with_args(self):
"""
Overriding some fields values at recipe execution
"""
person = self.person_recipe.make(name='Guido', age=56)
self.assertNotEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.name, 'Guido')
self.assertNotEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.age, 56)
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd,
self.recipe_attrs['wanted_games_qtd'])
self.assertNotEqual(person.id, None)
def test_prepare_recipes_with_args(self):
"""
Overriding some fields values at recipe execution
"""
person = self.person_recipe.prepare(name='Guido', age=56)
self.assertNotEqual(person.name, self.recipe_attrs['name'])
self.assertEqual(person.name, 'Guido')
self.assertNotEqual(person.age, self.recipe_attrs['age'])
self.assertEqual(person.age, 56)
self.assertEqual(person.nickname, self.recipe_attrs['nickname'])
self.assertEqual(person.bio, self.recipe_attrs['bio'])
self.assertEqual(person.birthday, self.recipe_attrs['birthday'])
self.assertEqual(person.appointment, self.recipe_attrs['appointment'])
self.assertEqual(person.blog, self.recipe_attrs['blog'])
self.assertEqual(person.wanted_games_qtd,
self.recipe_attrs['wanted_games_qtd'])
self.assertEqual(person.id, None)
def test_make_recipe_without_all_model_needed_data(self):
person_recipe = Recipe(Person, name='John Doe')
person = person_recipe.make()
self.assertEqual('John Doe', person.name)
self.assertTrue(person.nickname)
self.assertTrue(person.age)
self.assertTrue(person.bio)
self.assertTrue(person.birthday)
self.assertTrue(person.appointment)
self.assertTrue(person.blog)
self.assertTrue(person.wanted_games_qtd)
self.assertTrue(person.id)
def test_prepare_recipe_without_all_model_needed_data(self):
person_recipe = Recipe(Person, name='John Doe')
person = person_recipe.prepare()
self.assertEqual('John Doe', person.name)
self.assertTrue(person.nickname)
self.assertTrue(person.age)
self.assertTrue(person.bio)
self.assertTrue(person.birthday)
self.assertTrue(person.appointment)
self.assertTrue(person.blog)
self.assertTrue(person.wanted_games_qtd)
self.assertFalse(person.id)
class TestDefiningRecipes(TestCase):
def setUp(self):
self.recipe_attrs = {
"name": "John Doe",
"nickname": "joe",
"age": 18,
"bio": "Someone in the crowd",
"birthday": now().date(),
"appointment": now(),
"blog": "http://joe.blogspot.com",
"wanted_games_qtd": 4,
"birth_time": now(),
}
self.person_recipe = Recipe(Person, **self.recipe_attrs)
def test_flat_model_make_recipe_with_the_correct_attributes(self):
"""
A 'flat model' means a model without associations, like
foreign keys, many to many and one to one
"""
person = self.person_recipe.make()
self.assertEqual(person.name, self.recipe_attrs["name"])
self.assertEqual(person.nickname, self.recipe_attrs["nickname"])
self.assertEqual(person.age, self.recipe_attrs["age"])
self.assertEqual(person.bio, self.recipe_attrs["bio"])
self.assertEqual(person.birthday, self.recipe_attrs["birthday"])
self.assertEqual(person.appointment, self.recipe_attrs["appointment"])
self.assertEqual(person.blog, self.recipe_attrs["blog"])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs["wanted_games_qtd"])
self.assertNotEqual(person.id, None)
def test_flat_model_prepare_recipe_with_the_correct_attributes(self):
person = self.person_recipe.prepare()
self.assertEqual(person.name, self.recipe_attrs["name"])
self.assertEqual(person.nickname, self.recipe_attrs["nickname"])
self.assertEqual(person.age, self.recipe_attrs["age"])
self.assertEqual(person.bio, self.recipe_attrs["bio"])
self.assertEqual(person.birthday, self.recipe_attrs["birthday"])
self.assertEqual(person.appointment, self.recipe_attrs["appointment"])
self.assertEqual(person.blog, self.recipe_attrs["blog"])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs["wanted_games_qtd"])
self.assertEqual(person.id, None)
def test_accepts_callable(self):
r = Recipe(DummyBlankFieldsModel, blank_char_field=lambda: "callable!!")
value = r.make().blank_char_field
self.assertEqual(value, "callable!!")
def test_always_calls_when_creating(self):
with patch("test.generic.tests.test_recipes.choice") as choice_mock:
choice.return_value = "foo"
l = ["foo", "bar", "spam", "eggs"]
r = Recipe(DummyBlankFieldsModel, blank_char_field=lambda: choice(l))
r.make().blank_char_field
r.make().blank_char_field
self.assertEqual(choice_mock.call_count, 2)
def test_always_calls_with_quantity(self):
with patch("test.generic.tests.test_recipes.choice") as choice_mock:
choice.return_value = "foo"
l = ["foo", "bar", "spam", "eggs"]
r = Recipe(DummyBlankFieldsModel, blank_char_field=lambda: choice(l))
r.make(_quantity=3)
self.assertEqual(choice_mock.call_count, 3)
def test_make_recipes_with_args(self):
"""
Overriding some fields values at recipe execution
"""
person = self.person_recipe.make(name="Guido", age=56)
self.assertNotEqual(person.name, self.recipe_attrs["name"])
self.assertEqual(person.name, "Guido")
self.assertNotEqual(person.age, self.recipe_attrs["age"])
self.assertEqual(person.age, 56)
self.assertEqual(person.nickname, self.recipe_attrs["nickname"])
self.assertEqual(person.bio, self.recipe_attrs["bio"])
self.assertEqual(person.birthday, self.recipe_attrs["birthday"])
self.assertEqual(person.appointment, self.recipe_attrs["appointment"])
self.assertEqual(person.blog, self.recipe_attrs["blog"])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs["wanted_games_qtd"])
self.assertNotEqual(person.id, None)
def test_prepare_recipes_with_args(self):
"""
Overriding some fields values at recipe execution
"""
person = self.person_recipe.prepare(name="Guido", age=56)
self.assertNotEqual(person.name, self.recipe_attrs["name"])
self.assertEqual(person.name, "Guido")
self.assertNotEqual(person.age, self.recipe_attrs["age"])
self.assertEqual(person.age, 56)
self.assertEqual(person.nickname, self.recipe_attrs["nickname"])
self.assertEqual(person.bio, self.recipe_attrs["bio"])
self.assertEqual(person.birthday, self.recipe_attrs["birthday"])
self.assertEqual(person.appointment, self.recipe_attrs["appointment"])
self.assertEqual(person.blog, self.recipe_attrs["blog"])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs["wanted_games_qtd"])
self.assertEqual(person.id, None)
def test_make_recipe_without_all_model_needed_data(self):
person_recipe = Recipe(Person, name="John Doe")
person = person_recipe.make()
self.assertEqual("John Doe", person.name)
self.assertTrue(person.nickname)
self.assertTrue(person.age)
self.assertTrue(person.bio)
self.assertTrue(person.birthday)
self.assertTrue(person.appointment)
self.assertTrue(person.blog)
self.assertTrue(person.wanted_games_qtd)
self.assertTrue(person.id)
def test_prepare_recipe_without_all_model_needed_data(self):
person_recipe = Recipe(Person, name="John Doe")
person = person_recipe.prepare()
self.assertEqual("John Doe", person.name)
self.assertTrue(person.nickname)
self.assertTrue(person.age)
self.assertTrue(person.bio)
self.assertTrue(person.birthday)
self.assertTrue(person.appointment)
self.assertTrue(person.blog)
self.assertTrue(person.wanted_games_qtd)
self.assertFalse(person.id)
def test_defining_recipes_str(self):
from model_mommy.recipe import seq
p = Recipe("generic.Person", name=seq("foo"))
try:
p.make(_quantity=5)
except AttributeError as e:
self.fail("%s" % e)
class TestDefiningRecipes(TestCase):
def setUp(self):
self.recipe_attrs = {
"name": "John Doe",
"nickname": "joe",
"age": 18,
"bio": "Someone in the crowd",
"birthday": now().date(),
"appointment": now(),
"blog": "http://joe.blogspot.com",
"wanted_games_qtd": 4,
"birth_time": now(),
}
self.person_recipe = Recipe(Person, **self.recipe_attrs)
def test_flat_model_make_recipe_with_the_correct_attributes(self):
"""
A 'flat model' means a model without associations, like
foreign keys, many to many and one to one
"""
person = self.person_recipe.make()
self.assertEqual(person.name, self.recipe_attrs["name"])
self.assertEqual(person.nickname, self.recipe_attrs["nickname"])
self.assertEqual(person.age, self.recipe_attrs["age"])
self.assertEqual(person.bio, self.recipe_attrs["bio"])
self.assertEqual(person.birthday, self.recipe_attrs["birthday"])
self.assertEqual(person.appointment, self.recipe_attrs["appointment"])
self.assertEqual(person.blog, self.recipe_attrs["blog"])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs["wanted_games_qtd"])
self.assertNotEqual(person.id, None)
def test_flat_model_prepare_recipe_with_the_correct_attributes(self):
person = self.person_recipe.prepare()
self.assertEqual(person.name, self.recipe_attrs["name"])
self.assertEqual(person.nickname, self.recipe_attrs["nickname"])
self.assertEqual(person.age, self.recipe_attrs["age"])
self.assertEqual(person.bio, self.recipe_attrs["bio"])
self.assertEqual(person.birthday, self.recipe_attrs["birthday"])
self.assertEqual(person.appointment, self.recipe_attrs["appointment"])
self.assertEqual(person.blog, self.recipe_attrs["blog"])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs["wanted_games_qtd"])
self.assertEqual(person.id, None)
def test_accepts_callable(self):
r = Recipe(DummyBlankFieldsModel, blank_char_field=lambda: "callable!!")
value = r.make().blank_char_field
self.assertEqual(value, "callable!!")
def test_make_recipes_with_args(self):
"""
Overriding some fields values at recipe execution
"""
person = self.person_recipe.make(name="Guido", age=56)
self.assertNotEqual(person.name, self.recipe_attrs["name"])
self.assertEqual(person.name, "Guido")
self.assertNotEqual(person.age, self.recipe_attrs["age"])
self.assertEqual(person.age, 56)
self.assertEqual(person.nickname, self.recipe_attrs["nickname"])
self.assertEqual(person.bio, self.recipe_attrs["bio"])
self.assertEqual(person.birthday, self.recipe_attrs["birthday"])
self.assertEqual(person.appointment, self.recipe_attrs["appointment"])
self.assertEqual(person.blog, self.recipe_attrs["blog"])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs["wanted_games_qtd"])
self.assertNotEqual(person.id, None)
def test_prepare_recipes_with_args(self):
"""
Overriding some fields values at recipe execution
"""
person = self.person_recipe.prepare(name="Guido", age=56)
self.assertNotEqual(person.name, self.recipe_attrs["name"])
self.assertEqual(person.name, "Guido")
self.assertNotEqual(person.age, self.recipe_attrs["age"])
self.assertEqual(person.age, 56)
self.assertEqual(person.nickname, self.recipe_attrs["nickname"])
self.assertEqual(person.bio, self.recipe_attrs["bio"])
self.assertEqual(person.birthday, self.recipe_attrs["birthday"])
self.assertEqual(person.appointment, self.recipe_attrs["appointment"])
self.assertEqual(person.blog, self.recipe_attrs["blog"])
self.assertEqual(person.wanted_games_qtd, self.recipe_attrs["wanted_games_qtd"])
self.assertEqual(person.id, None)
def test_make_recipe_without_all_model_needed_data(self):
person_recipe = Recipe(Person, name="John Doe")
person = person_recipe.make()
self.assertEqual("John Doe", person.name)
self.assertTrue(person.nickname)
self.assertTrue(person.age)
self.assertTrue(person.bio)
self.assertTrue(person.birthday)
self.assertTrue(person.appointment)
self.assertTrue(person.blog)
self.assertTrue(person.wanted_games_qtd)
self.assertTrue(person.id)
def test_prepare_recipe_without_all_model_needed_data(self):
person_recipe = Recipe(Person, name="John Doe")
person = person_recipe.prepare()
self.assertEqual("John Doe", person.name)
self.assertTrue(person.nickname)
self.assertTrue(person.age)
self.assertTrue(person.bio)
self.assertTrue(person.birthday)
self.assertTrue(person.appointment)
self.assertTrue(person.blog)
self.assertTrue(person.wanted_games_qtd)
self.assertFalse(person.id)
