def setUp(self):
"""
setUp --> called before each test in the class
It will be almost the same for all the views tests
"""
super(TestViewSearch, self).setUpClass()
# create 3 products
mixer.cycle(3).blend(Product,
pname=mixer.sequence('prod{0}'),
code=mixer.sequence('{0}'),
nutriscore_score=25,
nutriscore_grade="e",
salt=mixer.RANDOM('H', 'M', 'L', 'U'),
sugar=mixer.RANDOM('H', 'M', 'L', 'U'),
fat=mixer.RANDOM('H', 'M', 'L', 'U'),
saturated_fat=mixer.RANDOM('H', 'M', 'L', 'U'),
category__cname=mixer.sequence('category{0}'),
brand__bname=mixer.sequence('brand{0}'),
store__sname=mixer.sequence('store{0}'))
# add a cat to a product
prod2 = Product.objects.get(pname='prod2')
cat1 = Category.objects.get(cname='category1')
prod2.category.add(cat1)
prod2.save()
self.search_url = reverse("products_app:search")
# init test client
self.client = Client()
# create a user and connect with this user
user = User.objects.create(username='******')
user.set_password('foobar')
user.save()
self.user = user
self.client.login(username='******', password='******')
def setUp(self):
super(TestViewSaveRemoveBookmark, self).setUpClass()
# create 2 products
mixer.cycle(3).blend(Product,
pname=mixer.sequence('prod{0}'),
code=mixer.sequence('{0}'),
nutriscore_score=25,
nutriscore_grade="e",
salt=mixer.RANDOM('H', 'M', 'L', 'U'),
sugar=mixer.RANDOM('H', 'M', 'L', 'U'),
fat=mixer.RANDOM('H', 'M', 'L', 'U'),
saturated_fat=mixer.RANDOM('H', 'M', 'L', 'U'),
category__cname=mixer.sequence('category{0}'),
brand__bname=mixer.sequence('brand{0}'),
store__sname=mixer.sequence('store{0}'))
# test client
self.client = Client()
# user creation
user = User.objects.create(username='******')
user.set_password('foobar')
user.save()
self.user = user
self.client.login(username='******', password='******')
json_data = json.dumps({'action': 'add', 'subst': '2', 'prod': '1'})
response = self.client.post(
reverse('products_app:save_remove_bookmark'),
json_data,
content_type="application/json")
def setUp(self) -> None:
self.tags = mixer.cycle(20).blend(Tag)
self.admin = mixer.blend(User, is_superuser=True)
self.user = mixer.blend(User)
self.user.profile.interests.set(self.tags[:5])
self.user.profile.save()
self.articles = mixer.cycle(100).blend(Article,
tags=mixer.sequence(*self.tags))
self.decks = mixer.cycle(30).blend(
Deck, articles=mixer.sequence(*self.articles))
def test_get_documents_monthly_with_args(self):
mixer.cycle(5).blend(DocumentsReport,
period='daily',
documents=10,
start_date=mixer.sequence('2020-10-1{0}'),
end_date=mixer.sequence('2020-10-1{0}'))
get_documents_monthly.apply(args=(['2020-10-01']))
monthly_data = DocumentsReport.objects.filter(period='monthly').first()
assert monthly_data.start_date == date(2020, 10, 1)
assert monthly_data.end_date == date(2020, 10, 31)
assert monthly_data.period == 'monthly'
assert monthly_data.documents == 50
def test_monthly_get_pautas_ga_data(self):
mixer.cycle(5).blend(AudienciasGA,
period='daily',
data=self.json_monthly,
start_date=mixer.sequence('2020-10-1{0}'),
end_date=mixer.sequence('2020-10-1{0}'))
get_ga_audiencias_monthly.apply(args=(['2020-10-01']))
monthly_data = AudienciasGA.objects.filter(period='monthly').first()
assert monthly_data.data['users'] == 50
assert monthly_data.data['newUsers'] == 50
assert monthly_data.data['sessions'] == 50
assert monthly_data.data['pageViews'] == 50
def test_load_stat(self):
c1 = mixer.blend(Country, use_in_reports=True)
c2 = mixer.blend(Country, use_in_reports=True)
(o1, o2) = mixer.cycle(2).blend(Organization,
name=mixer.sequence("org_{0}"))
s1 = mixer.blend(Survey, countries=[c1, c2], organizations=[o1, o2])
s2 = mixer.blend(Survey, countries=[c1, c2], organizations=[o1, o2])
evaluator = self.evaluator_cls(s1)
mixer.blend(SurveyStat, survey=s1, country=None)
mixer.blend(SurveyStat, survey=s1, country=c1)
mixer.blend(SurveyStat, survey=s2, country=c1)
mixer.blend(OrganizationStat,
survey=s1,
country_id=None,
organization=o1)
mixer.blend(OrganizationStat, survey=s1, country=c1, organization=o1)
mixer.blend(OrganizationStat, survey=s2, country=c1, organization=o1)
mixer.blend(OrganizationStat, survey=s2, country=c1, organization=o2)
r1 = mixer.blend(Representation, active=True)
r2 = mixer.blend(Representation, active=True)
mixer.blend(QuestionStat, survey=s1, country=None, representation=r1)
mixer.blend(QuestionStat, survey=s1, country=c1, representation=r1)
mixer.blend(QuestionStat, survey=s1, country=c1, representation=r2)
evaluator.load_stat()
assert len(evaluator.survey_stat) == 3
assert len(evaluator.organization_stat) == 4
assert len(evaluator.question_stat) == 3
def setUp(self):
super(TestViewProductDetail, self).setUpClass()
# create 2 products
mixer.cycle(2).blend(Product,
pname=mixer.sequence('prod{0}'),
code=mixer.sequence('{0}'),
nutriscore_score=25,
nutriscore_grade="e",
salt=mixer.RANDOM('H', 'M', 'L', 'U'),
sugar=mixer.RANDOM('H', 'M', 'L', 'U'),
fat=mixer.RANDOM('H', 'M', 'L', 'U'),
saturated_fat=mixer.RANDOM('H', 'M', 'L', 'U'),
category__cname=mixer.sequence('category{0}'),
brand__bname=mixer.sequence('brand{0}'),
store__sname=mixer.sequence('store{0}'))
self.client = Client()
def test_monthly_get_pautas_ga_data_without_args(self):
last_month = date.today().replace(day=1) - timedelta(days=1)
last_date = str(last_month)[:8]
mixer.cycle(5).blend(AudienciasGA,
period='daily',
data=self.json_monthly,
start_date=mixer.sequence(last_date + '1{0}'),
end_date=mixer.sequence(last_date + '1{0}'))
get_ga_audiencias_monthly.apply()
monthly_data = AudienciasGA.objects.filter(period='monthly').first()
assert monthly_data.data['users'] == 50
assert monthly_data.data['newUsers'] == 50
assert monthly_data.data['sessions'] == 50
assert monthly_data.data['pageViews'] == 50
def test_chapter_range_str_with_5_chapters_returns_1_to_5_as_str(self):
self.chapters = mixer.cycle(5).blend(
Chapter,
section=self.section,
chapter_code=mixer.sequence(1, 2, 3, 4, 5),
nomenclature_tree=self.tree,
)
self.assertEquals(self.section.chapter_range_str, "1 to 5")
def test_get_edemocracia_registers_monthly(self):
json_data = {"register_count": 10}
mixer.cycle(5).blend(EdemocraciaAnalysis, period='daily',
data=json_data, start_date=mixer.sequence(
'2020-10-1{0}'),
end_date=mixer.sequence('2020-10-1{0}'))
get_edemocracia_registers_monthly.apply(args=(['2020-10-01']))
monthly_data = EdemocraciaAnalysis.objects.filter(
period='monthly').first()
assert monthly_data.start_date == date(2020, 10, 1)
assert monthly_data.end_date == date(2020, 10, 31)
assert monthly_data.period == 'monthly'
assert monthly_data.data['register_count'] == 50
def test_centers_are_in_different_context(self, mock_render, rf):
orgs = mixer.cycle(5).blend(SROMember, status='a')
counter = 0
for org in orgs:
mixer.blend(AccreditedCenter,
short_code=mixer.sequence("active_{}".format(counter)),
sro_member=org,
active=True)
mixer.blend(AccreditedCenter,
short_code=mixer.sequence(
"inactive_{}".format(counter)),
sro_member=org,
active=False)
mixer.blend(AccreditedCenter,
short_code=mixer.sequence(
"suspended_{}".format(counter)),
sro_member=org,
temporary_suspend_date=mixer.RANDOM)
counter += 1
active_centers = AccreditedCenter.objects.filter(
active=True, temporary_suspend_date__isnull=True)
inactive_centers = AccreditedCenter.objects.filter(active=False)
suspended_centers = AccreditedCenter.objects.filter(
temporary_suspend_date__isnull=False)
request = rf.get('/reestr/centers/')
response = reestr.centers(request, direction='personal')
context = self.context(mock_render.call_args)
active_centers_cntxt = combined(context['active_centers']['left'],
context['active_centers']['right'])
inactive_centers_cntxt = combined(context['inactive_centers']['left'],
context['inactive_centers']['right'])
suspended_centers_cntxt = combined(
context['suspended_centers']['left'],
context['suspended_centers']['right'])
for center in active_centers:
assert center in active_centers_cntxt and\
center not in inactive_centers_cntxt and\
center not in suspended_centers_cntxt
for center in inactive_centers:
assert center in inactive_centers_cntxt and\
center not in active_centers_cntxt and\
center not in suspended_centers_cntxt
for center in suspended_centers:
assert center in suspended_centers_cntxt and\
center not in active_centers_cntxt and\
center not in inactive_centers_cntxt
def test_a_course_can_have_many_comments(self):
user = mixer.blend(User, username='******')
course = mixer.blend(Course, student=user)
comments = mixer.cycle(12).blend(
Comment,
author=user,
course=course,
comment=mixer.sequence(lambda c: "test_%s" % c))
assert Comment.objects.filter(course=course).count() == 12
def test_get_answers(self):
s = mixer.blend(Survey)
(o1, o2) = mixer.cycle(2).blend(Organization,
name=mixer.sequence("org_{0}"))
mixer.blend(Answer, survey=s, organization=o1, is_updated=True)
mixer.blend(Answer, survey=s, organization=o2, is_updated=False)
evaluator = self.evaluator_cls(s)
answers = evaluator.get_answers()
assert len(answers) == 1, 'Should return just one last record'
def setUp(self):
super(TestViewSearchSubstitute, self).setUpClass()
# create 4 products
mixer.cycle(4).blend(Product,
pname=mixer.sequence('prod{0}'),
code=mixer.sequence('{0}'),
nutriscore_score=25,
nutriscore_grade="e",
salt=mixer.RANDOM('H', 'M', 'L', 'U'),
sugar=mixer.RANDOM('H', 'M', 'L', 'U'),
fat=mixer.RANDOM('H', 'M', 'L', 'U'),
saturated_fat=mixer.RANDOM('H', 'M', 'L', 'U'),
category__cname=mixer.sequence('category{0}'),
brand__bname=mixer.sequence('brand{0}'),
store__sname=mixer.sequence('store{0}'))
# add a cat to a product
prod2 = Product.objects.get(pname='prod2')
cat1 = Category.objects.get(cname='category1')
prod2.category.add(cat1)
prod2.save()
# the prod3 will not have any substitute
prod3 = Product.objects.get(pname='prod3')
prod3.nutriscore_score = 24
prod3.save()
# nb_cat by product --> for the substiture research
categories_s = Category.objects.all()
for cat in categories_s:
nbr_prod = Product.objects.filter(
category__cname=cat.cname).count()
upd_cat = Category.objects.get(cname=cat.cname)
upd_cat.nb_prod = nbr_prod
upd_cat.save()
# init test client
self.client = Client()
# create a user and connect with this user
user = User.objects.create(username='******')
user.set_password('foobar')
user.save()
self.user = user
self.client.login(username='******', password='******')
def test_has_hierarchy_children(self):
self.chapters = mixer.cycle(5).blend(
Chapter,
section=self.section,
chapter_code=mixer.sequence(1, 2, 3, 4, 5),
nomenclature_tree=self.tree,
)
children = self.section.get_hierarchy_children()
child_count = self.section.get_hierarchy_children_count()
self.assertEqual(len(children), 5)
self.assertEqual(child_count, 5)
self.assertEqual(len(children), child_count)
def setUp(self):
""""
Setup method --> initialize datas to test models methods
"""
super(TestUserAppModels, self).setUpClass()
mixer.cycle(3).blend(Product,
pname=mixer.sequence('prod{0}'),
code=mixer.sequence('{0}'),
nutriscore_score=25,
nutriscore_grade="e",
salt=mixer.RANDOM('H', 'M', 'L', 'U'),
sugar=mixer.RANDOM('H', 'M', 'L', 'U'),
fat=mixer.RANDOM('H', 'M', 'L', 'U'),
saturated_fat=mixer.RANDOM('H', 'M', 'L', 'U'),
category__cname=mixer.sequence('category{0}'),
brand__bname=mixer.sequence('brand{0}'),
store__sname=mixer.sequence('store{0}'))
# add a cat to a product
prod2 = Product.objects.get(pname='prod2')
cat1 = Category.objects.get(cname='category1')
prod2.category.add(cat1)
prod2.save()
def test_get_answers(self):
(o1, o2) = mixer.cycle(2).blend(Organization,
name=mixer.sequence("org_{0}"))
mixer.blend(Answer,
survey=self.survey,
organization=o1,
is_updated=True)
mixer.blend(Answer,
survey=self.survey,
organization=o2,
is_updated=False)
answers = self.evaluator.get_answers()
assert len(answers) == 2, 'Should return all records'
def setUpClass(cls):
super(TestReports, cls).setUpClass()
c1 = mixer.blend(Country, slug='ukraine')
cls.c1 = c1
c2 = mixer.blend(Country, slug='germany')
(o1, o2) = mixer.cycle(2).blend(Organization, name=mixer.sequence("org_{0}"))
s1 = mixer.blend(Survey, countries=[c1, c2], organizations=[o1, o2], active=True)
cls.s1 = s1
mixer.blend(SurveyStat, survey=s1, country=None)
mixer.blend(SurveyStat, survey=s1, country=c1)
mixer.blend(OrganizationStat, survey=s1, country_id=None, organization=o1)
mixer.blend(OrganizationStat, survey=s1, country=c1, organization=o1)
TotalEvaluator.process_answers(s1)
def test_monthly_get_ga_data(self):
json_data = {
"date": "00000000",
"users": 10,
"newUsers": 10,
"sessions": 10,
"pageViews": 10
}
mixer.cycle(5).blend(EdemocraciaGA,
period='daily',
data=json_data,
start_date=mixer.sequence('2020-10-1{0}'),
end_date=mixer.sequence('2020-10-1{0}'))
get_ga_edemocracia_monthly.apply(args=(['2020-10-01']))
monthly_data = EdemocraciaGA.objects.filter(period='monthly').first()
assert monthly_data.data['users'] == 50
assert monthly_data.data['newUsers'] == 50
assert monthly_data.data['sessions'] == 50
assert monthly_data.data['pageViews'] == 50
def test_fill_out(self):
c1 = mixer.blend(Country, use_in_reports=True)
c2 = mixer.blend(Country, use_in_reports=True)
(o1, o2) = mixer.cycle(2).blend(Organization,
name=mixer.sequence("org_{0}"))
s1 = mixer.blend(Survey,
countries=[c1, c2],
organizations=[o1, o2],
active=True)
q1 = mixer.blend(Question, survey=s1)
q2 = mixer.blend(Question, survey=s1)
mixer.blend(Question, survey=s1)
r1 = mixer.blend(Representation, active=True, question=q1, ordering=1)
r2 = mixer.blend(Representation, active=True, question=q2, ordering=2)
evaluator = self.evaluator_cls(s1)
mixer.blend(SurveyStat, survey=s1, country=None)
mixer.blend(SurveyStat, survey=s1, country=c1)
mixer.blend(OrganizationStat,
survey=s1,
country_id=None,
organization=o1)
mixer.blend(OrganizationStat, survey=s1, country=c1, organization=o1)
mixer.blend(QuestionStat,
survey=s1,
country=None,
representation=r1,
type=r1.type)
mixer.blend(QuestionStat,
survey=s1,
country=c1,
representation=r1,
type=r1.type)
evaluator.load_stat()
assert len(evaluator.survey_stat) == 2
assert len(evaluator.organization_stat) == 2
assert len(evaluator.question_stat) == 2
evaluator.fill_out()
assert len(evaluator.survey_stat) == 3
assert len(evaluator.organization_stat) == 6
assert len(evaluator.question_stat) == 6
assert evaluator.question_stat[(s1.pk, None, r2.pk)].ordering == 2
assert evaluator.question_representation_link == {q1.pk: r1, q2.pk: r2}
assert evaluator.question_dict == {q1.pk: q1, q2.pk: q2}
for qs in evaluator.question_stat.values():
assert qs.type == qs.representation.type
def setUp(self):
super(TestViewSaveBookmark, self).setUpClass()
# create 2 products
mixer.cycle(2).blend(Product,
pname=mixer.sequence('prod{0}'),
code=mixer.sequence('{0}'),
nutriscore_score=25,
nutriscore_grade="e",
salt=mixer.RANDOM('H', 'M', 'L', 'U'),
sugar=mixer.RANDOM('H', 'M', 'L', 'U'),
fat=mixer.RANDOM('H', 'M', 'L', 'U'),
saturated_fat=mixer.RANDOM('H', 'M', 'L', 'U'),
category__cname=mixer.sequence('category{0}'),
brand__bname=mixer.sequence('brand{0}'),
store__sname=mixer.sequence('store{0}'))
# test client
self.client = Client()
# user creation
user = User.objects.create(username='******')
user.set_password('foobar')
user.save()
self.user = user
self.client.login(username='******', password='******')
def test_update_survey_stat(self):
d1 = timezone.make_aware(datetime(2017, 1, 1))
d2 = timezone.make_aware(datetime(2017, 1, 2))
(o1, o2) = mixer.cycle(2).blend(Organization,
name=mixer.sequence("org_{0}"))
a1 = mixer.blend(Answer, organization=o1)
a1.created_at = d1
a2 = mixer.blend(Answer, organization=o2)
a2.created_at = d2
self.evaluator.update_survey_stat((1, 2), a1)
self.evaluator.update_survey_stat((1, 2), a2)
assert self.evaluator.survey_stat[(1, 2)].total == 2
assert self.evaluator.survey_stat[(1, 2)].last == d2
assert self.evaluator.survey_stat[(1, None)].total == 2
assert self.evaluator.survey_stat[(1, None)].last == d2
def test_prefetch(self):
wine1 = Wine.objects.first()
wine1.title = f'{wine1.title}'
wine1.save()
with self.assertNumQueries(2):
for wine in Wine.objects.all():
self.assertIsNotNone(wine.title)
mixer.cycle(5).blend(Wine, title=mixer.sequence('Wine {0}'))
with override('en'):
for wine in Wine.objects.all():
wine.title = f'{wine.title} en'
wine.save()
with self.assertNumQueries(2):
for wine in Wine.objects.all():
self.assertIsNotNone(wine.title.en)
def setUpClass(cls):
super(SurveyStartViewTest, cls).setUpClass()
c1 = mixer.blend(Country, name='France')
cls.c1 = c1
c2 = mixer.blend(Country, name='Germany')
cls.orgs = mixer.cycle(2).blend(Organization,
name=mixer.sequence("org_{0}"))
now = timezone.now()
s1 = mixer.blend(Survey,
countries=[c1, c2],
organizations=cls.orgs,
active=True,
start=now - timezone.timedelta(days=1),
end=now + timezone.timedelta(days=1))
cls.s1 = s1
def test_model(self):
authors = mixer.cycle(2).blend('book.Author', name=mixer.sequence(lambda count: "author%s" % count))
book = mixer.blend('book.Book', name="Test", isbn="123-456789012", country="india",
number_of_pages=26, publisher="pub1", release_date="2019-05-26", authors=authors)
assert book.pk == 1
assert book.name == "Test"
assert book.isbn == "123-456789012"
assert book.country == "india"
assert book.number_of_pages == 26
assert book.publisher == "pub1"
assert book.release_date == datetime.date(2019, 5, 26)
assert book.authors.count() == 2
assert book.authors.first().name == "author0"
assert book.authors.last().name == "author1"
assert str(book) == "Test"
def test_process_answer_with_empty_data(self, organization_stat,
survey_stat):
(o1, o2) = mixer.cycle(2).blend(Organization,
name=mixer.sequence("org_{0}"))
country = mixer.blend(Country, id=1)
answer = mixer.blend(Answer,
body='',
survey=self.survey,
organization=o1)
self.evaluator.process_answer(answer)
assert organization_stat.call_count == 0
assert survey_stat.call_count == 0
answer = mixer.blend(Answer,
body='111',
survey=self.survey,
organization=o2)
self.assertRaises(MalformedQueryStringError,
self.evaluator.process_answer, answer)
assert organization_stat.call_count == 0
assert survey_stat.call_count == 0
answer = mixer.blend(Answer,
body='a=1',
survey=self.survey,
organization=o1)
self.assertRaises(KeyError, self.evaluator.process_answer, answer)
answer = mixer.blend(Answer,
body='data=1',
survey=self.survey,
organization=o2)
self.assertRaises(KeyError, self.evaluator.process_answer, answer)
answer = mixer.blend(Answer,
country=country,
body='data[111]=Yes',
survey=self.survey,
organization=o1)
self.evaluator.process_answer(answer)
survey_stat.assert_called_once_with((answer.survey_id, country.pk),
answer)
organization_stat.assert_called_once_with(
(answer.survey_id, country.pk, answer.organization_id))
def handle(self, *args, **options):
Tag.objects.all().delete()
Post.objects.all().delete()
Category.objects.all().delete()
Contact.objects.all().delete()
ContactSubdivision.objects.all().delete()
Document.objects.all().delete()
mixer.cycle(10).blend(
Document,
# title=mixer.sequence('document_naks_{0}'),
main_page_rotation=True,
)
mixer.cycle(10).blend(ContactSubdivision,
title=mixer.sequence('subdivision_{0}'))
mixer.cycle(20).blend(Contact,
description=mixer.RANDOM,
subdivision=mixer.SELECT,
phone=mixer.RANDOM,
phone_secondary=mixer.RANDOM,
email=mixer.RANDOM,
number=mixer.RANDOM)
for i in range(len(tags)):
mixer.blend(Tag, name=tags[i])
for i in range(len(categories)):
mixer.blend(Category, name=categories[i])
for i in range(len(news_titles)):
mixer.blend(
Post,
title=news_titles[i],
active=True if random.randint(0, 100) > 20 else False,
mark_as_announcement=True
if random.randint(0, 100) > 60 else False,
category=random.choice(
[category for category in Category.objects.all()]),
subtitle=mixer.RANDOM,
short_description=mixer.RANDOM,
full_description=mixer.RANDOM,
main_picture=File(open(random.choice(pictures), 'rb')),
)
print('creating posts:', news_titles[i])
def test_an_user_can_REGISTER_to_a_course(self):
user = mixer.blend(User, username='******')
course = mixer.blend('elearning.Course', author=user)
registered = mixer.blend('elearning.Register',
student=user,
course=course)
assert registered.student.username == 'nickelback'
users = mixer.cycle(10).blend(
User, username=mixer.sequence(lambda c: "nickelback_%s" % c))
#registrering 10 users into a course
for this_user in users:
registered = mixer.blend('elearning.Register',
student=this_user,
course=course)
#how many Student this Course contains
assert Register.objects.filter(course=course.id).count() == 11
def setUp(cls):
super(TestModels, cls).setUp()
cls.teacher = mixer.blend(User, is_staff=True)
cls.schoolboy = mixer.blend(User, is_staff=False)
cls.examsheet = mixer.blend(ExamSheet,
author=cls.teacher,
available=True)
cls.question = mixer.blend(Question, examsheet=cls.examsheet)
cls.answer = mixer.blend(Answer, question=cls.question)
cls.examresult = mixer.blend(ExamResult,
author=cls.schoolboy,
earned_points=5,
points_to_get=10,
exam=cls.examsheet)
cls.examsheets = mixer.cycle(4).blend(
ExamSheet,
author=cls.teacher,
title=mixer.sequence("title_{0}"),
available=True)
def test_process_answer(self):
d1 = timezone.make_aware(datetime(2017, 1, 1))
d2 = timezone.make_aware(datetime(2017, 1, 2))
mixer.blend(SurveyStat, survey_id=1, country_id=None, total=2, last=d1)
mixer.blend(SurveyStat, survey_id=1, country_id=1, total=2, last=d1)
(o1, o2) = mixer.cycle(2).blend(Organization,
name=mixer.sequence("org_{0}"))
mixer.blend(OrganizationStat,
survey_id=1,
country_id=None,
organization=o1,
total=2)
mixer.blend(OrganizationStat,
survey_id=1,
country_id=1,
organization=o1,
total=2)
self.evaluator.load_stat()
def set_up(db):
event = mixer.blend(Event, name='Ball', allow_groups=True, cost=Decimal(65))
for i in range(10):
person = mixer.blend(Person, first_name='xxx', last_name=mixer.sequence(lambda c: f'name_{c}'))
mixer.blend(Participant, event=event, person=person, text=str(i))
