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_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_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)
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, e:
self.fail('%s' %e)
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 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_only_iterators_not_iteratables_are_iterated(self):
"""Ensure we only iterate explicit iterators.
Consider "iterable" vs "iterator":
Something like a string is "iterable", but not an "iterator". We don't
want to iterate "iterables", only explicit "iterators".
"""
r = Recipe(DummyBlankFieldsModel, blank_text_field="not an iterator, so don't iterate!")
self.assertEqual(r.make().blank_text_field, "not an iterator, so don't iterate!")
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)
class TestPostModel(TestCase):
def setUp(self):
self.recipe = Recipe(Post, slug=None)
def test_str(self):
post = self.recipe.make(title='foobar')
self.assertEqual(post.__str__(), 'foobar')
def test_get_absolute_url(self):
post = self.recipe.make(title='foobar')
self.assertEqual(post.get_absolute_url(), '/foobar/')
def test_queryset(self):
# cria 2 posts
self.recipe.make(status=cycle([Post.FINISHED, Post.DRAFT]), _quantity=2)
# Aprova os finalizados
Post.objects.filter(status=Post.FINISHED).update(approved=True)
# cria mais 2 posts para termos finalizados não aprovados
self.recipe.make(status=cycle([Post.FINISHED, Post.DRAFT]), _quantity=2)
self.assertEqual(Post.objects.finished().count(), 2)
self.assertEqual(Post.objects.draft().count(), 2)
self.assertEqual(Post.objects.approved().count(), 1)
self.assertEqual(Post.objects.live().count(), 1)
class Fixtures:
def create_employer(self):
emp = models.Employer.objects.create(name="ACME", id=1, nochallenge=True, active2015=True, active2016=True)
emp.save()
def leg_setup(self):
self.survey_recipe = Recipe(models.Commutersurvey)
self.all_modes = models.Mode.objects.all()
self.leg_recipe = Recipe(
models.Leg,
checkin = self.survey_recipe.make(),
mode = cycle(self.all_modes)
)
def generate_leg_set(self, checkin):
# generates a set of legs to associate with a given checkin
# set is complete in the sense of having 1+ leg per direction/day pair
self.leg_recipe.make(day='w', direction='fw', checkin=checkin, _quantity=randint(1,3))
self.leg_recipe.make(day='w', direction='tw', checkin=checkin, _quantity=randint(1,3))
self.leg_recipe.make(day='n', direction='fw', checkin=checkin, _quantity=randint(1,3))
self.leg_recipe.make(day='n', direction='tw', checkin=checkin, _quantity=randint(1,3))
def create_legs(self):
self.leg_setup()
checkin = self.survey_recipe.make()
self.generate_leg_set(checkin)
checkin.save()
return (self.leg_recipe, checkin)
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')
def description_updatable_models():
cost_or_pricing_data = daims_maps["cost_or_pricing_data_map"].keys()
multiple_or_single_award_i = daims_maps["multiple_or_single_award_i_map"].keys()
cost_accounting_standards = daims_maps["cost_accounting_standards_map"].keys()
fed_biz_opps = daims_maps["fed_biz_opps_map"].keys()
action_type = ["A", "B", "C", "D"]
transaction_contract_recipe = Recipe(
TransactionFPDS,
cost_or_pricing_data=cycle(cost_or_pricing_data),
multiple_or_single_award_i=cycle(multiple_or_single_award_i),
cost_accounting_standards=cycle(cost_accounting_standards),
fed_biz_opps=cycle(fed_biz_opps),
transaction__action_type=cycle(action_type)
)
transaction_assistance_recipe = Recipe(
TransactionFABS,
transaction__action_type=cycle(action_type)
)
transaction_contract_recipe.make(_quantity=10)
transaction_assistance_recipe.make(_quantity=10)
def aggregate_models():
"""Set up data for testing aggregate functions."""
award_uri = [None, 'yo', 'yo', 'yo']
award_fain = [None, None, '123']
award_piid = ['abc', 'def', None]
award_types = ['U', 'B', '05', 'B']
start_dates = [
datetime.date(2016, 7, 13),
datetime.date(2017, 1, 1),
datetime.date(
2018,
6,
1, ),
datetime.date(
2018,
1,
1, ),
]
end_dates = [
datetime.date(2018, 12, 31), datetime.date(2020, 1, 1),
datetime.date(2050, 7, 14), datetime.date(2050, 7, 14)
]
obligated_amts = [1000.01, 2000, None, 4000.02]
# create awards
award_recipe = Recipe(
Award,
piid=cycle(award_piid),
fain=cycle(award_fain),
uri=cycle(award_uri),
type=cycle(award_types),
period_of_performance_start_date=cycle(start_dates),
period_of_performance_current_end_date=cycle(end_dates),
total_obligation=cycle(obligated_amts), )
award_recipe.make(_quantity=4)
class IndexTest(TestCase):
def setUp(self):
last_hour = datetime.now() - timedelta(hours=1)
# Next hour has 1 minute more because the delay between
# the creation of the event and the test execution
next_hour = datetime.now() + timedelta(minutes=61)
self.event_last_hour = Recipe(Event, ends=last_hour, published=True)
self.event_next_hour = Recipe(Event, ends=next_hour, published=True)
self.event_unpublished = Recipe(Event, ends=next_hour, published=False)
def test_index_response(self):
response = client.get(reverse('index'))
self.assertEqual(response.status_code, 200)
def test_index_event_list(self):
self.event_last_hour.make(_quantity=1)
self.event_next_hour.make(_quantity=1)
self.event_unpublished.make(_quantity=1)
response = client.get(reverse('index'))
self.assertEqual(response.context_data.get('event_list').count(), 1)
def test_accepts_generators(self):
r = Recipe(DummyBlankFieldsModel,
blank_char_field=itertools.cycle(['a', 'b']))
self.assertEqual('a', r.make().blank_char_field)
self.assertEqual('b', r.make().blank_char_field)
self.assertEqual('a', r.make().blank_char_field)
class BadgeAssertionTestModel(TestCase):
def setUp(self):
djconfig.reload_maybe(
) # https://github.com/nitely/django-djconfig/issues/31#issuecomment-451587942
# needed because BadgeAssertions use a default that might not exist yet
self.sem = mommy.make('courses.semester',
pk=djconfig.config.hs_active_semester)
self.teacher = Recipe(User, is_staff=True).make(
) # need a teacher or student creation will fail.
self.student = mommy.make(User)
self.assertion = mommy.make(BadgeAssertion, semester=self.sem)
self.badge = Recipe(Badge, xp=20).make()
self.badge_assertion_recipe = Recipe(BadgeAssertion,
user=self.student,
badge=self.badge,
semester=self.sem)
def test_badge_assertion_creation(self):
self.assertIsInstance(self.assertion, BadgeAssertion)
self.assertEqual(str(self.assertion), self.assertion.badge.name)
def test_badge_assertion_url(self):
self.assertEquals(
self.client.get(self.assertion.get_absolute_url(),
follow=True).status_code, 200)
def test_badge_assertion_count(self):
num = 5
for _ in range(num):
badge_assertion = BadgeAssertion.objects.create_assertion(
self.student, self.badge, issued_by=self.teacher)
# Why doesn't below work?
# badge_assertion = self.badge_assertion_recipe.make()
count = badge_assertion.count()
# print(num, count)
self.assertEquals(num, count)
def test_badge_assertion_count_bootstrap_badge(self):
"""Returns empty string if count < 2, else returns proper count"""
badge_assertion = mommy.make(BadgeAssertion, semester=self.sem)
self.assertEquals(badge_assertion.count_bootstrap_badge(), "")
num = 4
for _ in range(num):
badge_assertion = BadgeAssertion.objects.create_assertion(
self.student, self.badge, issued_by=self.teacher)
# Why doesn't below work?
# badge_assertion = self.badge_assertion_recipe.make()
count = badge_assertion.count_bootstrap_badge()
# print(num, count)
self.assertEquals(num, count)
def test_badge_assertion_get_duplicate_assertions(self):
num = 5
values = []
for _ in range(num):
badge_assertion = self.badge_assertion_recipe.make()
values.append(repr(badge_assertion))
qs = badge_assertion.get_duplicate_assertions()
self.assertQuerysetEqual(
list(qs),
values,
)
def test_badge_assertion_manager_create_assertion(self):
new_assertion = BadgeAssertion.objects.create_assertion(
self.student, mommy.make(Badge), self.teacher)
self.assertIsInstance(new_assertion, BadgeAssertion)
def test_badge_assertion_manager_xp_to_date(self):
xp = BadgeAssertion.objects.calculate_xp_to_date(
self.student, timezone.now())
self.assertEqual(xp, 0)
# give them a badge assertion and make sure the XP works
BadgeAssertion.objects.create_assertion(self.student, self.badge,
self.teacher)
xp = BadgeAssertion.objects.calculate_xp_to_date(
self.student, timezone.now())
self.assertEqual(xp, self.badge.xp)
def test_badge_assertion_manager_get_by_type_for_user(self):
badge_list_by_type = BadgeAssertion.objects.get_by_type_for_user(
self.student)
self.assertIsInstance(badge_list_by_type, list)
# TODO need to test this properly
def test_badge_assertion_manager_check_for_new_assertions(self):
BadgeAssertion.objects.check_for_new_assertions(self.student)
# TODO need to test this properly
def test_fraction_of_active_users_granted_this(self):
num_students_with_badge = 3
students_with_badge = mommy.make(User,
_quantity=num_students_with_badge)
self.assertEqual(len(students_with_badge), num_students_with_badge)
total_students = User.objects.filter(is_active=True).count()
badge = mommy.make(Badge)
for student in students_with_badge:
mommy.make(BadgeAssertion, user=student, badge=badge)
fraction = badge.fraction_of_active_users_granted_this()
self.assertEqual(fraction, num_students_with_badge / total_students)
percentile = badge.percent_of_active_users_granted_this()
self.assertEqual(percentile,
num_students_with_badge / total_students * 100)
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)
def setUp(self):
super(ItemManagerTest, self).setUp()
self.basic_workspace()
item = Recipe('item.Item', matter=self.matter)
revision = Recipe('attachment.Revision')
task = Recipe('task.Task')
"""
Item: Generic
"""
# item, revisions: 0
self.item1 = item.make()
# item (completed), revisions: 0
self.item2 = item.make(is_complete=True)
# item, revisions: 0, responsible: user
self.item3 = item.make(responsible_party=self.user)
# item (completed), revisions: 0, responsible: user
self.item4 = item.make(is_complete=True, responsible_party=self.user)
# item, revisions: 0, responsible: other
self.item5 = item.make(responsible_party=self.lawyer)
# item (completed), revisions: 0, responsible: other
self.item6 = item.make(is_complete=True, responsible_party=self.lawyer)
"""
Item: Requested
"""
# item (requested), revisions: 0, responsible: user
self.item7 = item.make(is_requested=True, responsible_party=self.user)
# item (completed, requested), revisions: 0, responsible: user
self.item8 = item.make(is_complete=True, is_requested=True, responsible_party=self.user)
# item (requested), revisions: 0, responsible: other
self.item9 = item.make(is_requested=True, responsible_party=self.lawyer)
# item (completed, requested), revisions: 0, responsible: other
self.item10 = item.make(is_complete=True, is_requested=True, responsible_party=self.lawyer)
"""
Item: Needs Review
"""
# item (in review), revision: stale, reviewer: user
self.item11 = item.make()
self.item11revs = revision.make(item=self.item11, _quantity=2)
self.item11revs[0].reviewers.add(self.user)
# item (in review, completed), revision: stale, reviewer: user
self.item12 = item.make(is_complete=True)
self.item12revs = revision.make(item=self.item12, _quantity=2)
self.item12revs[0].reviewers.add(self.user)
# item (in review), revision: stale, reviewer: other
self.item13 = item.make()
self.item13revs = revision.make(item=self.item13, _quantity=2)
self.item13revs[0].reviewers.add(self.lawyer)
# item (in review, completed), revision: stale, reviewer: other
self.item14 = item.make(is_complete=True)
self.item14revs = revision.make(item=self.item14, _quantity=2)
self.item14revs[0].reviewers.add(self.lawyer)
# item (reviewed), revision: stale, reviewer: user
self.item15 = item.make()
self.item15revs = revision.make(item=self.item15, _quantity=2)
self.item15revs[0].reviewers.add(self.user)
self.item15revs[0].reviewdocument_set.filter(reviewers__in=[self.user]).update(is_complete=True)
# item (reviewed, completed), revision: stale, reviewer: user
self.item16 = item.make(is_complete=True)
self.item16revs = revision.make(item=self.item16, _quantity=2)
self.item16revs[0].reviewers.add(self.user)
self.item16revs[0].reviewdocument_set.filter(reviewers__in=[self.user]).update(is_complete=True)
# item (reviewed), revision: stale, reviewer: other
self.item17 = item.make()
self.item17revs = revision.make(item=self.item17, _quantity=2)
self.item17revs[0].reviewers.add(self.lawyer)
self.item17revs[0].reviewdocument_set.filter(reviewers__in=[self.lawyer]).update(is_complete=True)
# item (reviewed, completed), revision: stale, reviewer: other
self.item18 = item.make(is_complete=True)
self.item18revs = revision.make(item=self.item18, _quantity=2)
self.item18revs[0].reviewers.add(self.lawyer)
self.item18revs[0].reviewdocument_set.filter(reviewers__in=[self.lawyer]).update(is_complete=True)
# item (in review), revision: current, reviewer: user
self.item19 = item.make()
self.item19revs = revision.make(item=self.item19, _quantity=2)
self.item19revs[1].reviewers.add(self.user)
# item (in review, completed), revision: current, reviewer: user
self.item20 = item.make(is_complete=True)
self.item20revs = revision.make(item=self.item20, _quantity=2)
self.item20revs[1].reviewers.add(self.user)
# item (in review), revision: current, reviewer: other
self.item21 = item.make()
self.item21revs = revision.make(item=self.item21, _quantity=2)
self.item21revs[1].reviewers.add(self.lawyer)
# item (in review, completed), revision: current, reviewer: other
self.item22 = item.make(is_complete=True)
self.item22revs = revision.make(item=self.item22, _quantity=2)
self.item22revs[1].reviewers.add(self.lawyer)
# item (reviewed), revision: current, reviewer: user
self.item23 = item.make()
self.item23revs = revision.make(item=self.item23, _quantity=2)
self.item23revs[1].reviewers.add(self.user)
self.item23revs[1].reviewdocument_set.filter(reviewers__in=[self.user]).update(is_complete=True)
# item (reviewed, completed), revision: current, reviewer: user
self.item24 = item.make(is_complete=True)
self.item24revs = revision.make(item=self.item24, _quantity=2)
self.item24revs[1].reviewers.add(self.user)
self.item24revs[1].reviewdocument_set.filter(reviewers__in=[self.user]).update(is_complete=True)
# item (reviewed), revision: current, reviewer: other
self.item25 = item.make()
self.item25revs = revision.make(item=self.item25, _quantity=2)
self.item25revs[1].reviewers.add(self.lawyer)
self.item25revs[1].reviewdocument_set.filter(reviewers__in=[self.lawyer]).update(is_complete=True)
# item (reviewed, completed), revision: current, reviewer: other
self.item26 = item.make(is_complete=True)
self.item26revs = revision.make(item=self.item26, _quantity=2)
self.item26revs[1].reviewers.add(self.lawyer)
self.item26revs[1].reviewdocument_set.filter(reviewers__in=[self.lawyer]).update(is_complete=True)
"""
Item: Needs Signing
"""
# item (needs signing), revision: stale, signatory: user
self.item27 = item.make()
self.item27revs = revision.make(item=self.item27, _quantity=2)
self.item27revs[0].signers.add(self.user)
# item (needs signing, completed), revision: stale, signatory: user
self.item28 = item.make(is_complete=True)
self.item28revs = revision.make(item=self.item28, _quantity=2)
self.item28revs[0].signers.add(self.user)
# item (needs signing), revision: stale, signatory: other
self.item29 = item.make()
self.item29revs = revision.make(item=self.item29, _quantity=2)
self.item29revs[0].signers.add(self.lawyer)
# item (needs signing, completed), revision: stale, signatory: other
self.item30 = item.make(is_complete=True)
self.item30revs = revision.make(item=self.item30, _quantity=2)
self.item30revs[0].signers.add(self.lawyer)
# item (signed), revision: stale, signatory: user
self.item31 = item.make()
self.item31revs = revision.make(item=self.item31, _quantity=2)
self.item31revs[0].signers.add(self.user)
self.item31signs = self.get_signed_request(self.item31revs[0], self.user)
# item (signed, completed), revision: stale, signatory: user
self.item32 = item.make(is_complete=True)
self.item32revs = revision.make(item=self.item32, _quantity=2)
self.item32revs[0].signers.add(self.user)
self.item32signs = self.get_signed_request(self.item32revs[0], self.user)
# item (signed), revision: stale, signatory: other
self.item33 = item.make()
self.item33revs = revision.make(item=self.item33, _quantity=2)
self.item33revs[0].signers.add(self.lawyer)
self.item33signs = self.get_signed_request(self.item33revs[0], self.lawyer)
# item (signed, completed), revision: stale, signatory: other
self.item34 = item.make(is_complete=True)
self.item34revs = revision.make(item=self.item34, _quantity=2)
self.item34revs[0].signers.add(self.lawyer)
self.item34signs = self.get_signed_request(self.item34revs[0], self.lawyer)
# item (all signed), revision: stale, signatory: user
self.item35 = item.make()
self.item35revs = revision.make(item=self.item35, _quantity=2)
self.item35revs[0].signers.add(self.user)
self.item35signs = self.get_signed_request(self.item35revs[0], self.user)
self.item35revs[0].primary_signdocument.complete()
# item (all signed, completed), revision: stale, signatory: user
self.item36 = item.make(is_complete=True)
self.item36revs = revision.make(item=self.item36, _quantity=2)
self.item36revs[0].signers.add(self.user)
self.item36signs = self.get_signed_request(self.item36revs[0], self.user)
self.item36revs[0].primary_signdocument.complete()
# item (all signed), revision: stale, signatory: other
self.item37 = item.make()
self.item37revs = revision.make(item=self.item37, _quantity=2)
self.item37revs[0].signers.add(self.lawyer)
self.item37signs = self.get_signed_request(self.item37revs[0], self.lawyer)
self.item37revs[0].primary_signdocument.complete()
# item (all signed, completed), revision: stale, signatory: other
self.item38 = item.make(is_complete=True)
self.item38revs = revision.make(item=self.item38, _quantity=2)
self.item38revs[0].signers.add(self.lawyer)
self.item38signs = self.get_signed_request(self.item38revs[0], self.lawyer)
self.item38revs[0].primary_signdocument.complete()
# item (needs signing), revision: current, signatory: user
self.item39 = item.make()
self.item39revs = revision.make(item=self.item39, _quantity=2)
self.item39revs[1].signers.add(self.user)
# item (needs signing, completed), revision: current, signatory: user
self.item40 = item.make(is_complete=True)
self.item40revs = revision.make(item=self.item40, _quantity=2)
self.item40revs[1].signers.add(self.user)
# item (needs signing), revision: current, signatory: other
self.item41 = item.make()
self.item41revs = revision.make(item=self.item41, _quantity=2)
self.item41revs[1].signers.add(self.lawyer)
# item (needs signing, completed), revision: current, signatory: other
self.item42 = item.make(is_complete=True)
self.item42revs = revision.make(item=self.item42, _quantity=2)
self.item42revs[1].signers.add(self.lawyer)
# item (signed), revision: current, signatory: user
self.item43 = item.make()
self.item43revs = revision.make(item=self.item43, _quantity=2)
self.item43revs[1].signers.add(self.user)
self.item43signs = self.get_signed_request(self.item43revs[1], self.user)
# item (signed, completed), revision: current, signatory: user
self.item44 = item.make(is_complete=True)
self.item44revs = revision.make(item=self.item44, _quantity=2)
self.item44revs[1].signers.add(self.user)
self.item44signs = self.get_signed_request(self.item44revs[1], self.user)
# item (signed), revision: current, signatory: other
self.item45 = item.make()
self.item45revs = revision.make(item=self.item45, _quantity=2)
self.item45revs[1].signers.add(self.lawyer)
self.item45signs = self.get_signed_request(self.item45revs[1], self.lawyer)
# item (signed, completed), revision: current, signatory: other
self.item46 = item.make(is_complete=True)
self.item46revs = revision.make(item=self.item46, _quantity=2)
self.item46revs[1].signers.add(self.lawyer)
self.item46signs = self.get_signed_request(self.item46revs[1], self.lawyer)
# item (all signed), revision: current, signatory: user
self.item47 = item.make()
self.item47revs = revision.make(item=self.item47, _quantity=2)
self.item47revs[1].signers.add(self.user)
self.item47signs = self.get_signed_request(self.item47revs[1], self.user)
self.item47revs[1].primary_signdocument.complete()
# item (all signed, completed), revision: current, signatory: user
self.item48 = item.make(is_complete=True)
self.item48revs = revision.make(item=self.item48, _quantity=2)
self.item48revs[1].signers.add(self.user)
self.item48signs = self.get_signed_request(self.item48revs[1], self.user)
self.item48revs[1].primary_signdocument.complete()
# item (all signed), revision: current, signatory: other
self.item49 = item.make()
self.item49revs = revision.make(item=self.item49, _quantity=2)
self.item49revs[1].signers.add(self.lawyer)
self.item49signs = self.get_signed_request(self.item49revs[1], self.lawyer)
self.item49revs[1].primary_signdocument.complete()
# item (all signed, completed), revision: current, signatory: other
self.item50 = item.make(is_complete=True)
self.item50revs = revision.make(item=self.item50, _quantity=2)
self.item50revs[1].signers.add(self.lawyer)
self.item50signs = self.get_signed_request(self.item50revs[1], self.lawyer)
self.item50revs[1].primary_signdocument.complete()
"""
Item: Mixed
"""
# item (requested, in review), revision: current, responsible: user, reviewer: user
self.item51 = item.make()
self.item51revs = revision.make(item=self.item51, _quantity=2)
self.item51revs[1].reviewers.add(self.user)
self.item51.is_requested = True
self.item51.responsible_party = self.user
self.item51.save(update_fields=['is_requested', 'responsible_party'])
# item (requested, needs signing), revision: current, responsible: user, signatory: user
self.item52 = item.make()
self.item52revs = revision.make(item=self.item52, _quantity=2)
self.item52revs[1].signers.add(self.user)
self.item52.is_requested = True
self.item52.responsible_party = self.user
self.item52.save(update_fields=['is_requested', 'responsible_party'])
# item (in review, needs signing), revision: current, reviewer: user, signatory: user
self.item53 = item.make()
self.item53revs = revision.make(item=self.item53, _quantity=2)
self.item53revs[1].reviewers.add(self.user)
self.item53revs[1].signers.add(self.user)
"""
Tasks
"""
# task, responsible: user
self.item54 = item.make()
self.task54 = task.make(item=self.item54, assigned_to=[self.user])
# task (completed), responsible: user
self.item55 = item.make()
self.task55 = task.make(item=self.item55, assigned_to=[self.user], is_complete=True)
# task, responsible: other
self.item56 = item.make()
self.task56 = task.make(item=self.item56, assigned_to=[self.lawyer])
# task (completed), responsible: other
self.item57 = item.make()
self.task57 = task.make(item=self.item57, assigned_to=[self.lawyer], is_complete=True)
class TestExtraMoney(TestCase):
"""Test TerminalCondition.extra_money()"""
def setUp(self):
administrative_unit = mommy.make(
"aklub.AdministrativeUnit",
name="test",
)
self.bank_account = mommy.make(
"aklub.BankAccount",
administrative_unit=administrative_unit,
)
self.event = mommy.make(
"events.event",
administrative_units=[
administrative_unit,
],
)
self.donor_payment_channel = Recipe(
"aklub.DonorPaymentChannel",
campaign__name="Foo campaign",
user__first_name="Foo user",
money_account=self.bank_account,
event=self.event,
)
def test_extra_payment(self):
"""Test DonorPaymentChannel with extra payment"""
for model in Profile.__subclasses__():
model_name = model._meta.model_name
profile = mommy.make(
model_name,
username="******".format(model_name),
)
donor_payment_channel = self.donor_payment_channel.make(
regular_amount=100,
regular_payments="regular",
regular_frequency="monthly",
payment_set=[
mommy.make(
"Payment",
date=datetime.date(year=2016, month=5, day=5),
amount=250,
),
],
user=profile,
money_account=self.bank_account,
)
donor_payment_channel.save()
self.assertEqual(donor_payment_channel.extra_money, 150)
self.assertEqual(donor_payment_channel.extra_payments(), "150 Kč")
def test_payment_too_old(self):
"""Test that if the payment is older than 27 days, it is not counted in"""
for model in Profile.__subclasses__():
model_name = model._meta.model_name
profile = mommy.make(
model_name,
username="******".format(model_name),
)
donor_payment_channel = self.donor_payment_channel.make(
regular_amount=100,
regular_payments="regular",
regular_frequency="monthly",
payment_set=[
mommy.make(
"Payment",
date=datetime.date(year=2016, month=5, day=4),
amount=250,
),
],
user=profile,
money_account=self.bank_account,
)
donor_payment_channel.save()
self.assertEqual(donor_payment_channel.extra_money, None)
self.assertEqual(donor_payment_channel.extra_payments(), ICON_FALSE)
def test_no_extra_payment(self):
"""Test DonorPaymentChannel with extra payment"""
for model in Profile.__subclasses__():
model_name = model._meta.model_name
profile = mommy.make(
model_name,
username="******".format(model_name),
)
donor_payment_channel = self.donor_payment_channel.make(
regular_amount=100,
regular_payments="regular",
regular_frequency="monthly",
user=profile,
money_account=self.bank_account,
)
donor_payment_channel.save()
self.assertEqual(donor_payment_channel.extra_money, None)
self.assertEqual(donor_payment_channel.extra_payments(), ICON_FALSE)
def test_no_frequency(self):
"""Test DonorPaymentChannel with no regular frequency"""
for model in Profile.__subclasses__():
model_name = model._meta.model_name
profile = mommy.make(
model_name,
username="******".format(model_name),
)
donor_payment_channel = self.donor_payment_channel.make(
regular_amount=100,
regular_payments="regular",
regular_frequency=None,
user=profile,
money_account=self.bank_account,
)
donor_payment_channel.save()
self.assertEqual(donor_payment_channel.extra_money, None)
self.assertEqual(donor_payment_channel.extra_payments(), ICON_FALSE)
def test_not_regular(self):
"""Test when DonorPaymentChannel is not regular"""
for model in Profile.__subclasses__():
model_name = model._meta.model_name
profile = mommy.make(
model_name,
username="******".format(model_name),
)
donor_payment_channel = self.donor_payment_channel.make(
regular_payments="onetime",
user=profile,
money_account=self.bank_account,
)
self.assertEqual(donor_payment_channel.extra_money, None)
self.assertEqual(donor_payment_channel.extra_payments(), ICON_FALSE)
class TestNoUpgrade(TestCase):
""" Test TerminalCondition.no_upgrade() """
def setUp(self):
self.userincampaign = Recipe(
"aklub.UserInCampaign",
campaign__name="Foo campaign",
userprofile__first_name="Foo userprofile",
)
def test_not_regular(self):
""" Test UserInCampaign with regular_payments=False returns False """
user_in_campaign = self.userincampaign.make(
regular_payments="onetime", )
self.assertEqual(
user_in_campaign.no_upgrade,
False,
)
def test_not_regular_for_one_year(self):
""" Test UserInCampaign that is not regular for at leas one year """
user_in_campaign = self.userincampaign.make(
regular_payments="regular", )
self.assertEqual(
user_in_campaign.no_upgrade,
False,
)
def test_no_last_year_payments(self):
""" Test UserInCampaign that has zero payments from last year """
user_in_campaign = self.userincampaign.make(
regular_payments="regular",
payment_set=[
mommy.make("Payment",
date=datetime.date(year=2010, month=4, day=1)),
],
)
user_in_campaign.save()
self.assertEqual(
user_in_campaign.no_upgrade,
False,
)
def test_missing_payments(self):
""" Test UserInCampaign that has different amount on payments before one year """
user_in_campaign = self.userincampaign.make(
regular_payments="regular",
payment_set=[
mommy.make("Payment",
date=datetime.date(year=2010, month=4, day=1),
amount=100),
mommy.make("Payment",
date=datetime.date(year=2009, month=3, day=1),
amount=200),
],
)
user_in_campaign.save()
self.assertEqual(
user_in_campaign.no_upgrade,
False,
)
def test_regular(self):
""" Test UserInCampaign that has regular payments """
user_in_campaign = self.userincampaign.make(
regular_payments="regular",
payment_set=[
mommy.make("Payment",
date=datetime.date(year=2010, month=4, day=1),
amount=100),
mommy.make("Payment",
date=datetime.date(year=2009, month=3, day=1),
amount=100),
],
)
user_in_campaign.save()
self.assertEqual(
user_in_campaign.no_upgrade,
True,
)
def test_empty_iterator_exception(self):
r = Recipe(DummyBlankFieldsModel,
blank_char_field=iter(['a', 'b']))
self.assertEqual('a', r.make().blank_char_field)
self.assertEqual('b', r.make().blank_char_field)
self.assertRaises(RecipeIteratorEmpty, r.make)
class TestExtraMoney(TestCase):
""" Test TerminalCondition.extra_money() """
def setUp(self):
self.userincampaign = Recipe(
"aklub.UserInCampaign",
campaign__name="Foo campaign",
userprofile__first_name="Foo userprofile",
)
def test_extra_payment(self):
""" Test UserInCampaign with extra payment """
user_in_campaign = self.userincampaign.make(
regular_amount=100,
regular_payments="regular",
regular_frequency="monthly",
payment_set=[
mommy.make("Payment",
date=datetime.date(year=2016, month=5, day=5),
amount=250),
],
)
user_in_campaign.save()
self.assertEqual(user_in_campaign.extra_money, 150)
self.assertEqual(user_in_campaign.extra_payments(), "150 Kč")
def test_payment_too_old(self):
""" Test that if the payment is older than 27 days, it is not counted in """
user_in_campaign = self.userincampaign.make(
regular_amount=100,
regular_payments="regular",
regular_frequency="monthly",
payment_set=[
mommy.make("Payment",
date=datetime.date(year=2016, month=5, day=4),
amount=250),
],
)
user_in_campaign.save()
self.assertEqual(user_in_campaign.extra_money, None)
self.assertEqual(user_in_campaign.extra_payments(), ICON_FALSE)
def test_no_extra_payment(self):
""" Test UserInCampaign with extra payment """
user_in_campaign = self.userincampaign.make(
regular_amount=100,
regular_payments="regular",
regular_frequency="monthly",
)
user_in_campaign.save()
self.assertEqual(user_in_campaign.extra_money, None)
self.assertEqual(user_in_campaign.extra_payments(), ICON_FALSE)
def test_no_frequency(self):
""" Test UserInCampaign with no regular frequency """
user_in_campaign = self.userincampaign.make(
regular_amount=100,
regular_payments="regular",
regular_frequency=None,
)
user_in_campaign.save()
self.assertEqual(user_in_campaign.extra_money, None)
self.assertEqual(user_in_campaign.extra_payments(), ICON_FALSE)
def test_not_regular(self):
""" Test when UserInCampaign is not regular """
user_in_campaign = self.userincampaign.make(
regular_payments="onetime", )
self.assertEqual(user_in_campaign.extra_money, None)
self.assertEqual(user_in_campaign.extra_payments(), ICON_FALSE)
class BadgeAssertionTestModel(TestCase):
def setUp(self):
djconfig.reload_maybe(
) # https://github.com/nitely/django-djconfig/issues/31#issuecomment-451587942
User = get_user_model()
self.teacher = Recipe(User, is_staff=True).make(
) # need a teacher or student creation will fail.
self.student = mommy.make(User)
self.assertion = mommy.make(BadgeAssertion)
self.badge = Recipe(Badge, xp=20).make()
self.badge_assertion_recipe = Recipe(BadgeAssertion,
user=self.student,
badge=self.badge)
def test_badge_assertion_creation(self):
self.assertIsInstance(self.assertion, BadgeAssertion)
self.assertEqual(str(self.assertion), self.assertion.badge.name)
def test_badge_assertion_url(self):
self.assertEquals(
self.client.get(self.assertion.get_absolute_url(),
follow=True).status_code, 200)
def test_badge_assertion_count(self):
num = randint(1, 9)
for _ in range(num):
badge_assertion = BadgeAssertion.objects.create_assertion(
self.student, self.badge)
# Why doesn't below work?
#badge_assertion = self.badge_assertion_recipe.make()
count = badge_assertion.count()
# print(num, count)
self.assertEquals(num, count)
def test_badge_assertion_count_bootstrap_badge(self):
"""Returns empty string if count < 2, else returns proper count"""
badge_assertion = mommy.make(BadgeAssertion)
self.assertEquals(badge_assertion.count_bootstrap_badge(), "")
num = 2
for _ in range(num):
badge_assertion = BadgeAssertion.objects.create_assertion(
self.student, self.badge)
# Why doesn't below work?
#badge_assertion = self.badge_assertion_recipe.make()
count = badge_assertion.count_bootstrap_badge()
# print(num, count)
self.assertEquals(num, count)
def test_badge_assertion_get_duplicate_assertions(self):
num = randint(1, 9)
values = []
for _ in range(num):
badge_assertion = self.badge_assertion_recipe.make()
values.append(repr(badge_assertion))
qs = badge_assertion.get_duplicate_assertions()
self.assertQuerysetEqual(
list(qs),
values,
)
def test_badge_assertion_manager_create_assertion(self):
new_assertion = BadgeAssertion.objects.create_assertion(
self.student, mommy.make(Badge))
self.assertIsInstance(new_assertion, BadgeAssertion)
def test_badge_assertion_manager_xp_to_date(self):
xp = BadgeAssertion.objects.calculate_xp_to_date(
self.student, timezone.now())
self.assertEqual(xp, 0)
# give them a badge assertion and make sure the XP works
BadgeAssertion.objects.create_assertion(self.student, self.badge)
xp = BadgeAssertion.objects.calculate_xp_to_date(
self.student, timezone.now())
self.assertEqual(xp, self.badge.xp)
def test_badge_assertion_manager_get_by_type_for_user(self):
badge_list_by_type = BadgeAssertion.objects.get_by_type_for_user(
self.student)
self.assertIsInstance(badge_list_by_type, list)
# TODO need to test this properly
def test_badge_assertion_manager_check_for_new_assertions(self):
BadgeAssertion.objects.check_for_new_assertions(self.student)
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)
def test_empty_iterator_exception(self):
r = Recipe(DummyBlankFieldsModel, blank_char_field=iter(['a', 'b']))
self.assertEqual('a', r.make().blank_char_field)
self.assertEqual('b', r.make().blank_char_field)
self.assertRaises(RecipeIteratorEmpty, r.make)
def test_accepts_callable(self):
r = Recipe(DummyBlankFieldsModel,
blank_char_field=lambda: 'callable!!')
value = r.make().blank_char_field
self.assertEqual(value, 'callable!!')
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 create_products(self):
self.quantity = 2
recipe = Recipe(Product, title=seq('test'), price=1, count=1)
recipe.make(_quantity=self.quantity)
def test_accepts_iterators(self):
r = Recipe(DummyBlankFieldsModel,
blank_char_field=iter(['a', 'b', 'c']))
self.assertEqual('a', r.make().blank_char_field)
self.assertEqual('b', r.make().blank_char_field)
self.assertEqual('c', r.make().blank_char_field)
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)
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_accepts_iterators(self):
r = Recipe(DummyBlankFieldsModel, blank_char_field=iter(["a", "b", "c"]))
self.assertEqual("a", r.make().blank_char_field)
self.assertEqual("b", r.make().blank_char_field)
self.assertEqual("c", r.make().blank_char_field)
class TestForm():
def setup_method(self, test_method):
criar_dependencia_recipe_imovel(self)
self.recipe_bairro_imovel_sj = Recipe(
BairroComImoveis,
cidade=foreign_key(self.cidade),
bairro=foreign_key(self.bairro),
regiao=foreign_key(self.regiao),
tipo_imovel=Imovel.TIPO_IMOVEL.apartamento)
self.cidade_macae = Recipe(Cidade, nome="Macae")
self.bairro_aeroporto = Recipe(Bairro, nome="Aeroporto")
self.recipe_bairro_imovel_macae = Recipe(
BairroComImoveis,
cidade=foreign_key(self.cidade_macae),
bairro=foreign_key(self.bairro_aeroporto),
regiao=foreign_key(self.regiao),
tipo_imovel=Imovel.TIPO_IMOVEL.apartamento)
def test_form_bairro_sao_jose_dos_campos(self):
bairro_imovel_sj = self.recipe_bairro_imovel_sj.make(contador_venda=1)
bairro_imovel_macae = self.recipe_bairro_imovel_macae.make()
form = FiltroPorValorForm(tipo_imovel=Imovel.TIPO_IMOVEL.apartamento,
tipo_interesse="comprar",
cidade="Sao Jose dos Campos")
assert len(form.fields['bairros'].choices) == 1
assert (bairro_imovel_sj.bairro.id,
bairro_imovel_sj) in form.fields['bairros'].choices
assert (bairro_imovel_macae.bairro.id,
bairro_imovel_macae) not in form.fields['bairros'].choices
def test_form_bairro_macae(self):
bairro_imovel_sj = self.recipe_bairro_imovel_sj.make()
bairro_imovel_macae = self.recipe_bairro_imovel_macae.make(
contador_venda=1)
form = FiltroPorValorForm(tipo_imovel=Imovel.TIPO_IMOVEL.apartamento,
tipo_interesse="comprar",
cidade="Macae")
assert len(form.fields['bairros'].choices) == 1
assert (bairro_imovel_macae.bairro.id,
bairro_imovel_macae) in form.fields['bairros'].choices
assert (bairro_imovel_sj.bairro.id,
bairro_imovel_sj) not in form.fields['bairros'].choices
def test_form_condominio_macae(self):
condominio = self.condominio.make()
form = FiltroPorValorForm(tipo_imovel=Imovel.TIPO_IMOVEL.apartamento,
tipo_interesse="comprar",
cidade="Macae")
assert len(form.fields['condominio'].choices) == 1
assert ("", "---------------") in form.fields['condominio'].choices
assert (condominio.id,
condominio.nome) not in form.fields['condominio'].choices
def test_form_condominio_sj(self):
condominio = self.condominio.make()
form = FiltroPorValorForm(tipo_imovel=Imovel.TIPO_IMOVEL.apartamento,
tipo_interesse="comprar",
cidade="Sao Jose dos Campos")
assert len(form.fields['condominio'].choices) == 2
assert ("", "---------------") in form.fields['condominio'].choices
assert (condominio.id,
condominio.nome) in form.fields['condominio'].choices
class Modelcoverage(TestCase):
# def create_account (self, first_name="Gen", last_name="Richards", email="*****@*****.**", username="******" ):
# return User.objects.create(first_name=first_name, last_name=last_name, email=email, username=username)
def create_category (self, name="Shopping"):
return Category.objects.create(name=name)
def test_create_category(self):
w = self.create_category()
self.assertTrue(isinstance(w, Category))
self.assertEqual(w.__str__(), w.name)
def create_country (self, name="Australia", code='Aust'):
return Country.objects.create(name=name, code=code)
def test_create_country(self):
w = self.create_country()
self.assertTrue(isinstance(w, Country))
self.assertEqual(w.__str__(), '%s (%s)' % (w.name, w.code))
def setUp (self):
"""Setting up all the tests"""
self.attraction_category = Recipe (
Category,
name="attraction",
)
self.gen_user = Recipe (
User,
first_name = "Gen",
last_name = "Rich",
email = "*****@*****.**",
username = "******")
self.australia_country = Recipe (
'IFB299app.Country',
name="Australia",
code='Aust'
)
self.queensland_region = Recipe(
Region,
name = "queensland",
latitude = "27.404",
longitude = "153.0987",
country_id = foreign_key(self.australia_country)
)
self.brisbane_city = Recipe (
City,
name = "Brisbane",
country_id = foreign_key(self.australia_country),
region_id = foreign_key(self.queensland_region),
latitude = "-27.1234",
longitude = "153.245",
)
self.southbank_location = Recipe (
Location,
name = "Southbank Parklands",
slug = "Southbank_Parklands",
category_id = foreign_key (self.attraction_category),
city_id = foreign_key (self.brisbane_city),
region_id = foreign_key (self.queensland_region),
country_id = foreign_key (self.australia_country))
self.music_event = Recipe (
Event,
name = "Xavier Rudd" ,
description = "jskfjlsdj",
start_date = "1999-05-25 08:30",
end_date = "1999-05-25 10:30",
location_id = foreign_key(self.southbank_location)
)
self.liked_feedback = Recipe (
FeedbackRecommendations,
placeID = "CH2356576",
name = "Southbank",
response = "True",
user = foreign_key (self.gen_user),
)
def test_create_account(self):
w = self.gen_user.make()
self.assertTrue(isinstance(w, User))
self.assertEqual(w.__str__(), w.username)
def test_check_Region(self):
w = self.queensland_region.make()
self.assertTrue(isinstance(w, Region))
self.assertEqual(w.__str__(), w.name)
def test_check_city(self):
w = self.brisbane_city.make()
self.assertTrue(isinstance(w, City))
self.assertEqual(w.__str__(), w.name)
def test_check_location (self):
w = self.southbank_location.make()
self.assertTrue(isinstance(w, Location))
self.assertEqual(w.__str__(), w.name)
def test_check_event (self):
w = self.music_event.make()
self.assertTrue(isinstance(w, Event))
self.assertEqual(w.__str__(), w.name)
def test_check_feedback(self):
w = self.liked_feedback.make()
self.assertTrue(isinstance(w, FeedbackRecommendations))
self.assertTrue(w.__str__(), w.placeID)
