def test_regio_instellingen_bad(self):
# bad cases
self.e2e_login_and_pass_otp(self.account_rcl112_18)
self.e2e_wissel_naar_functie(self.functie_rcl112_18)
url = self.url_regio_instellingen % (self.comp_18.pk, 112)
# na fase F zijn de instellingen niet meer in te zien
zet_competitie_fase(self.comp_18, 'K') # fase G is niet te zetten
resp = self.client.get(url)
self.assert404(resp) # 404 = Not found
resp = self.client.post(url)
self.assert404(resp) # 404 = Not found
# niet bestaande regio
url = self.url_regio_instellingen % (self.comp_18.pk, 100)
resp = self.client.get(url)
self.assert404(resp) # 404 = Not found
resp = self.client.post(url)
self.assert404(resp) # 404 = Not found
# niet de regio van de RCL
url = self.url_regio_instellingen % (self.comp_18.pk, 110)
resp = self.client.get(url)
self.assert403(resp)
resp = self.client.post(url)
self.assert403(resp)
# logout
url = self.url_regio_instellingen % (self.comp_18.pk, 112)
self.client.logout()
resp = self.client.get(url)
self.assert403(resp)
def test_afmelden(self):
# login als HWL
self.e2e_login_and_pass_otp(self.account_hwl)
self.e2e_wissel_naar_functie(self.functie_hwl)
self.e2e_check_rol('HWL')
# stel een paar bogen in
self._zet_sporter_voorkeuren(100004)
self._zet_sporter_voorkeuren(100003)
self._zet_ag(100004, 18)
self._zet_ag(100003, 25)
zet_competitie_fase(self.comp_18, 'B')
url = self.url_aanmelden % self.comp_18.pk
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_template_used(resp,
('compinschrijven/hwl-leden-aanmelden.dtl',
'plein/site_layout.dtl'))
# nu de POST om een paar leden aan te melden
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(), 0)
with self.assert_max_queries(20):
resp = self.client.post(
url,
{
'lid_100004_boogtype_1': 'on', # 1=R
'lid_100003_boogtype_3': 'on', # 3=BB
'wil_in_team': 'ja',
'opmerking': 'door de hwl'
})
self.assert_is_redirect_not_plein(resp) # check success
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(),
2) # 2 schutters, 1 competitie
# schrijf de schutters weer uit
pk = RegioCompetitieSchutterBoog.objects.all()[0].pk
url = self.url_ingeschreven % 0
with self.assert_max_queries(20):
resp = self.client.post(url, {'pk_%s' % pk: 'on'})
self.assert_is_redirect(resp, self.url_overzicht)
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(),
1) # 1 schutter
# schrijf een schutter uit van een andere vereniging
inschrijving = RegioCompetitieSchutterBoog.objects.all()[0]
inschrijving.bij_vereniging = self.nhbver2
inschrijving.save()
with self.assert_max_queries(20):
resp = self.client.post(url, {'pk_%s' % inschrijving.pk: 'on'})
self.assert403(resp)
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(),
1) # 1 schutter
def test_regios_afsluiten(self):
f1 = io.StringIO()
f2 = io.StringIO()
with self.assert_max_queries(20):
management.call_command('regios_afsluiten', '18', '101', '10x', stderr=f1, stdout=f2)
self.assertTrue('[ERROR] Valide regio nummers: 101 tot 116' in f1.getvalue())
f1 = io.StringIO()
f2 = io.StringIO()
with self.assert_max_queries(20):
management.call_command('regios_afsluiten', '18', '116', '115', stderr=f1, stdout=f2)
self.assertTrue('[ERROR] Valide regio nummers: 101 tot 116, oplopend' in f1.getvalue())
f1 = io.StringIO()
f2 = io.StringIO()
with self.assert_max_queries(20):
management.call_command('regios_afsluiten', '99', '115', '116', stderr=f1, stdout=f2)
self.assertTrue('[ERROR] Kan competitie met afstand 99 niet vinden' in f1.getvalue())
f1 = io.StringIO()
f2 = io.StringIO()
with self.assert_max_queries(20):
management.call_command('regios_afsluiten', '18', '101', '102', stderr=f1, stdout=f2)
self.assertTrue('[ERROR] Competitie in fase A is niet ondersteund' in f1.getvalue())
zet_competitie_fase(self.comp, 'F')
# geen aangemaakte regios
f1 = io.StringIO()
f2 = io.StringIO()
with self.assert_max_queries(20):
management.call_command('regios_afsluiten', '18', '101', '102', stderr=f1, stdout=f2)
self.assertTrue('' == f1.getvalue())
self.assertTrue('' == f2.getvalue())
f1 = io.StringIO()
f2 = io.StringIO()
with self.assert_max_queries(20):
management.call_command('regios_afsluiten', '18', '111', '111', stderr=f1, stdout=f2)
self.assertTrue('[INFO] Deelcompetitie Test - Regio 111 wordt afgesloten' in f2.getvalue())
# nog een keer (terwijl al afgesloten)
f1 = io.StringIO()
f2 = io.StringIO()
with self.assert_max_queries(20):
management.call_command('regios_afsluiten', '18', '111', '111', stderr=f1, stdout=f2)
self.assertTrue(f1.getvalue() == '')
def test_inschrijven_team_udvl(self):
url = self.url_aanmelden % self.comp_18.pk
zet_competitie_fase(self.comp_18, 'B')
# zet de udvl tussen de dvl van de twee schutters in
# sporter_100003.sinds_datum = datetime.date(year=jaar-4, month=11, day=12)
# sporter_100004.sinds_datum = datetime.date(year=jaar-3, month=11, day=12)
self.comp_18.uiterste_datum_lid = datetime.date(
year=self.sporter_100004.sinds_datum.year, month=1, day=1)
self.comp_18.save()
# login als HWL
self.e2e_login_and_pass_otp(self.account_hwl)
self.e2e_wissel_naar_functie(self.functie_hwl)
self.e2e_check_rol('HWL')
# stel een paar bogen in
self._zet_sporter_voorkeuren(100004)
self._zet_sporter_voorkeuren(100003)
self._zet_ag(100004, 18)
self._zet_ag(100003, 25)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_template_used(resp,
('compinschrijven/hwl-leden-aanmelden.dtl',
'plein/site_layout.dtl'))
# nu de POST om een paar leden aan te melden
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(), 0)
with self.assert_max_queries(22):
resp = self.client.post(
url,
{
'lid_100004_boogtype_1': 'on', # 1=R
'lid_100003_boogtype_3': 'on', # 3=BB
'wil_in_team': 'ja',
'opmerking': 'door de hwl'
})
self.assert_is_redirect_not_plein(resp) # check success
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(),
2) # 2 schutters, 1 competitie
for obj in RegioCompetitieSchutterBoog.objects.all():
self.assertEqual(obj.inschrijf_notitie, 'door de hwl')
if obj.sporterboog.sporter.lid_nr == 100003:
self.assertTrue(obj.inschrijf_voorkeur_team)
else:
# 100004 heeft dvl > udvl, dus mag niet mee doen
self.assertFalse(obj.inschrijf_voorkeur_team)
def test_doorzetten_bk(self):
self.e2e_login_and_pass_otp(self.testdata.account_bb)
self.e2e_wissel_naar_functie(self.functie_bko_18)
url = self.url_doorzetten_bk % self.comp_18.pk
# fase M: pagina zonder knop 'doorzetten'
zet_competitie_fase(self.comp_18, 'M')
self.comp_18.bepaal_fase()
self.assertEqual(self.comp_18.fase, 'M')
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
self.assert_template_used(resp, ('competitie/bko-doorzetten-naar-bk.dtl', 'plein/site_layout.dtl'))
# alle rayonkampioenschappen afsluiten
for obj in DeelCompetitie.objects.filter(competitie=self.comp_18,
is_afgesloten=False,
laag=LAAG_RK):
obj.is_afgesloten = True
obj.save()
# for
# fase N: pagina met knop 'doorzetten'
zet_competitie_fase(self.comp_18, 'N')
self.comp_18.bepaal_fase()
self.assertEqual(self.comp_18.fase, 'N')
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
self.assert_template_used(resp, ('competitie/bko-doorzetten-naar-bk.dtl', 'plein/site_layout.dtl'))
# nu echt doorzetten
with self.assert_max_queries(20):
resp = self.client.post(url)
self.assert_is_redirect(resp, '/bondscompetities/') # redirect = Success
self.assertTrue(str(self.deelcomp_bond_18) != '')
deelcomp_bk_18 = DeelCompetitie.objects.get(competitie=self.comp_18,
laag=LAAG_BK)
objs = KampioenschapSchutterBoog.objects.filter(deelcompetitie=deelcomp_bk_18)
self.assertEqual(objs.count(), 0) # worden nog niet gemaakt, dus 0
team_klasse = CompetitieKlasse.objects.filter(indiv=None)[0]
deeln_bk = KampioenschapSchutterBoog(deelcompetitie=deelcomp_bk_18,
sporterboog=self.sporterboog,
klasse=team_klasse)
self.assertTrue(str(deeln_bk) != '')
def test_fix_bad_ag(self):
f1 = io.StringIO()
f2 = io.StringIO()
with self.assert_max_queries(20):
management.call_command('fix_bad_ag', '18', stderr=f1, stdout=f2)
self.assertTrue('[ERROR] Competitie is in de verkeerde fase' in f1.getvalue())
zet_competitie_fase(self.comp, 'B')
f1 = io.StringIO()
f2 = io.StringIO()
with self.assert_max_queries(20):
management.call_command('fix_bad_ag', '18', stderr=f1, stdout=f2)
Score(
sporterboog=self.sporterboog_r,
type=SCORE_TYPE_INDIV_AG,
afstand_meter=18,
waarde=8000).save()
f1 = io.StringIO()
f2 = io.StringIO()
with self.assert_max_queries(20):
management.call_command('fix_bad_ag', '18', stderr=f1, stdout=f2)
self.assertTrue(f1.getvalue() == '')
self.assertTrue('Gebruik --commit om wijzigingen door te voeren' in f2.getvalue())
f1 = io.StringIO()
f2 = io.StringIO()
with self.assert_max_queries(20):
management.call_command('fix_bad_ag', '18', '--commit', stderr=f1, stdout=f2)
# print("f1: %s" % f1.getvalue())
# print("f2: %s" % f2.getvalue())
self.assertTrue(f1.getvalue() == '')
for comp in Competitie.objects.all():
comp.is_afgesloten = True
comp.save(update_fields=['is_afgesloten'])
f1 = io.StringIO()
f2 = io.StringIO()
with self.assert_max_queries(20):
management.call_command('fix_bad_ag', '18', stderr=f1, stdout=f2)
self.assertTrue('[ERROR] Geen actieve competitie gevonden' in f1.getvalue())
def test_doorzetten_bad(self):
# moet BKO zijn
self.e2e_login_and_pass_otp(self.testdata.account_bb)
self.e2e_wisselnaarrol_bb()
with self.assert_max_queries(20):
resp = self.client.get(self.url_doorzetten_rk % 999999)
self.assert403(resp)
with self.assert_max_queries(20):
resp = self.client.get(self.url_doorzetten_bk % 999999)
self.assert403(resp)
# niet bestaande comp_pk
self.e2e_wissel_naar_functie(self.functie_bko_18)
with self.assert_max_queries(20):
resp = self.client.get(self.url_doorzetten_rk % 999999)
self.assert404(resp) # 404 = Not found/allowed
with self.assert_max_queries(20):
resp = self.client.post(self.url_doorzetten_rk % 999999)
self.assert404(resp) # 404 = Not found/allowed
with self.assert_max_queries(20):
resp = self.client.get(self.url_doorzetten_bk % 999999)
self.assert404(resp) # 404 = Not found/allowed
with self.assert_max_queries(20):
resp = self.client.post(self.url_doorzetten_bk % 999999)
self.assert404(resp) # 404 = Not found/allowed
# juiste comp_pk maar verkeerde fase
zet_competitie_fase(self.comp_18, 'C')
with self.assert_max_queries(20):
resp = self.client.get(self.url_doorzetten_rk % self.comp_18.pk)
self.assert404(resp) # 404 = Not found/allowed
with self.assert_max_queries(20):
resp = self.client.post(self.url_doorzetten_rk % self.comp_18.pk)
self.assert404(resp) # 404 = Not found/allowed
with self.assert_max_queries(20):
resp = self.client.get(self.url_doorzetten_bk % self.comp_18.pk)
self.assert404(resp) # 404 = Not found/allowed
with self.assert_max_queries(20):
resp = self.client.post(self.url_doorzetten_bk % self.comp_18.pk)
self.assert404(resp) # 404 = Not found/allowed
def test_doorzetten_rk(self):
self.e2e_login_and_pass_otp(self.testdata.account_bb)
self.e2e_wissel_naar_functie(self.functie_bko_18)
url = self.url_doorzetten_rk % self.comp_18.pk
# fase F: pagina zonder knop 'doorzetten'
zet_competitie_fase(self.comp_18, 'F')
self.comp_18.bepaal_fase()
self.assertEqual(self.comp_18.fase, 'F')
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
self.assert_template_used(resp, ('competitie/bko-doorzetten-naar-rk.dtl', 'plein/site_layout.dtl'))
# sluit alle deelcompetitie regio
for obj in DeelCompetitie.objects.filter(competitie=self.comp_18,
is_afgesloten=False,
laag=LAAG_REGIO):
obj.is_afgesloten = True
obj.save()
# for
# fase G: pagina met knop 'doorzetten'
zet_competitie_fase(self.comp_18, 'G')
self.comp_18.bepaal_fase()
self.assertEqual(self.comp_18.fase, 'G')
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
self.assert_template_used(resp, ('competitie/bko-doorzetten-naar-rk.dtl', 'plein/site_layout.dtl'))
# nu echt doorzetten
self._regioschutters_inschrijven()
self.assertEqual(3, RegioCompetitieSchutterBoog.objects.count())
self.assertEqual(0, KampioenschapSchutterBoog.objects.count())
with self.assert_max_queries(20):
resp = self.client.post(url)
self.assert_is_redirect(resp, '/bondscompetities/') # redirect = Success
# laat de mutatie verwerken
management.call_command('regiocomp_mutaties', '1', '--quick', stderr=io.StringIO(), stdout=io.StringIO())
self.assertEqual(3, KampioenschapSchutterBoog.objects.count())
def test_aanmelden_team(self):
url = self.url_aanmelden % self.comp_18.pk
zet_competitie_fase(self.comp_18, 'B')
# anon
self.e2e_logout()
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert403(resp)
# login als HWL
self.e2e_login_and_pass_otp(self.account_hwl)
self.e2e_wissel_naar_functie(self.functie_hwl)
self.e2e_check_rol('HWL')
# stel een paar bogen in
self._zet_sporter_voorkeuren(100004)
self._zet_sporter_voorkeuren(100003)
self._zet_ag(100004, 18)
self._zet_ag(100003, 25)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_template_used(resp,
('compinschrijven/hwl-leden-aanmelden.dtl',
'plein/site_layout.dtl'))
# nu de POST om een paar leden aan te melden
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(), 0)
with self.assert_max_queries(20):
resp = self.client.post(
url,
{
'lid_100004_boogtype_1': 'on', # 1=R
'lid_100003_boogtype_3': 'on', # 3=BB
'wil_in_team': 'ja',
'opmerking': 'door de hwl'
})
self.assert_is_redirect_not_plein(resp) # check success
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(),
2) # 2 schutters, 1 competitie
for obj in RegioCompetitieSchutterBoog.objects.all():
self.assertEqual(obj.inschrijf_notitie, 'door de hwl')
self.assertTrue(obj.inschrijf_voorkeur_team)
def setUpTestData(cls):
cls.testdata = testdata.TestData()
cls.testdata.maak_accounts()
cls.testdata.maak_clubs_en_sporters()
cls.testdata.maak_bondscompetities()
for regio_nr in range(cls.regio_nr_begin, cls.regio_nr_einde + 1):
ver_nr = cls.testdata.regio_ver_nrs[regio_nr]
cls.testdata.maak_rk_deelnemers(18, ver_nr, regio_nr)
cls.ver_nrs.append(ver_nr)
# for
cls.testdata.maak_label_regiokampioenen(18, cls.regio_nr_begin,
cls.regio_nr_einde)
# zet de competitie in fase J
zet_competitie_fase(cls.testdata.comp18, 'J')
def test_wijzig_status_hwl(self):
# HWL
self.e2e_login_and_pass_otp(self.account_bko_18)
self.e2e_wissel_naar_functie(self.functie_hwl)
zet_competitie_fase(self.comp_18, 'J')
deelnemer = KampioenschapSchutterBoog(
deelcompetitie=self.deelcomp_rayon1_18,
sporterboog=self.sporterboog,
bij_vereniging=self.sporterboog.sporter.bij_vereniging,
klasse=self.klasse_r)
deelnemer.save()
# probeer als HWL van een andere vereniging de status van deze sporter aan te passen
url = self.url_wijzig_status % deelnemer.pk
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
with self.assert_max_queries(20):
resp = self.client.post(url, {})
self.assertEqual(resp.status_code, 302) # 302 = redirect
sporter = self.sporterboog.sporter
sporter.bij_vereniging = self.ver_1100
sporter.save()
deelnemer = KampioenschapSchutterBoog(
deelcompetitie=self.deelcomp_rayon1_18,
sporterboog=self.sporterboog,
bij_vereniging=self.ver_1100,
klasse=self.klasse_r)
deelnemer.save()
# probeer als HWL van een andere vereniging de status van deze sporter aan te passen
url = self.url_wijzig_status % deelnemer.pk
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert403(resp)
with self.assert_max_queries(20):
resp = self.client.post(url, {})
self.assert403(resp)
def test_ag_controle(self):
self.e2e_login_and_pass_otp(self.account_rcl112_18)
self.e2e_wissel_naar_functie(self.functie_rcl112_18)
url = self.url_ag_controle % (self.comp_18.pk, 112)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
self.assert_template_used(
resp, ('compregio/rcl-ag-controle.dtl', 'plein/site_layout.dtl'))
# maak een inschrijving met handmatig AG
RegioCompetitieSchutterBoog(
sporterboog=self.sporterboog,
bij_vereniging=self.sporterboog.sporter.bij_vereniging,
deelcompetitie=self.deelcomp_regio112_18,
klasse=self.klasse_recurve_onbekend,
inschrijf_voorkeur_team=True,
ag_voor_team_mag_aangepast_worden=True,
ag_voor_team=5.0).save()
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
# verkeerde fase
zet_competitie_fase(self.comp_18, 'K')
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert404(resp)
# bad pk
with self.assert_max_queries(20):
resp = self.client.get(self.url_ag_controle % (999999, 999999))
self.assert404(resp)
# verkeerde regio
with self.assert_max_queries(20):
resp = self.client.get(self.url_ag_controle %
(self.comp_18.pk, 110))
self.assert403(resp)
def _create_competitie(self):
# BB worden
self.e2e_login_and_pass_otp(self.testdata.account_bb)
self.e2e_wisselnaarrol_bb()
self.e2e_check_rol('BB')
self.assertEqual(CompetitieKlasse.objects.count(), 0)
competities_aanmaken()
self.comp_18 = Competitie.objects.get(afstand='18')
self.comp_25 = Competitie.objects.get(afstand='25')
self.deelcomp_regio = DeelCompetitie.objects.get(laag=LAAG_REGIO,
nhb_regio=self.regio_111,
competitie__afstand=18)
self.deelcomp_regio.inschrijf_methode = INSCHRIJF_METHODE_1
self.deelcomp_regio.save()
zet_competitie_fase(self.comp_18, 'B')
def test_bad_hwl(self):
comp = Competitie.objects.get(afstand=18) # let op: 25 werkt niet
self.e2e_login_and_pass_otp(self.testdata.account_bb) # geen account_hwl
self.e2e_wisselnaarrol_bb()
self._doe_inschrijven(comp) # wisselt naar HWL functie
self.e2e_wissel_naar_functie(self.functie_hwl)
# landelijk
zet_competitie_fase(comp, 'C')
comp.bepaal_fase()
self.assertEqual(comp.fase, 'C')
# als HWL is deze pagina niet beschikbaar
url = self.url_behoefte1 % (999999, 101)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert403(resp)
def test_administratieve_regio(self):
# corner case: SEC van vereniging in administratieve regio
# regio 100 is administratief
regio100 = NhbRegio.objects.get(regio_nr=100)
self.assertTrue(regio100.is_administratief)
# account_sec is SEC bij self.nhbver1
self.nhbver1.regio = regio100
self.nhbver1.save()
# login als SEC
self.e2e_login_and_pass_otp(self.account_sec)
self.e2e_wissel_naar_functie(self.functie_sec)
self.e2e_check_rol('SEC')
url = self.url_inschrijven % self.comp_18.pk
zet_competitie_fase(self.comp_18, 'B')
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert403(resp) # SEC mag dit niet
# wissel door naar HWL
self.e2e_wissel_naar_functie(self.functie_hwl)
self.e2e_check_rol('HWL')
# pagina is wel op te halen, maar bevat geen leden die zich in kunnen schrijven
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
# probeer iemand in te schrijven
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(), 0)
with self.assert_max_queries(20):
resp = self.client.post(
url,
{
'lid_100002_boogtype_1': 'on', # 1=R
'lid_100003_boogtype_3': 'on'
}) # 3=BB
self.assert404(resp) # 404 = Not found
def test_inschrijven(self):
# login als SEC
self.e2e_login_and_pass_otp(self.account_sec)
self.e2e_wissel_naar_functie(self.functie_sec)
self.e2e_check_rol('SEC')
url = self.url_inschrijven % self.comp_18.pk
zet_competitie_fase(self.comp_18, 'B')
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert403(resp) # SEC mag dit niet
# wissel door naar HWL
self.e2e_wissel_naar_functie(self.functie_hwl)
self.e2e_check_rol('HWL')
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
def test_wl(self):
self.e2e_login_and_pass_otp(self.account_hwl)
self.e2e_wissel_naar_functie(self.functie_hwl)
self.e2e_check_rol('HWL')
zet_competitie_fase(self.comp_18, 'B')
self.deelcomp18_regio111.einde_teams_aanmaken = self.deelcomp18_regio111.competitie.einde_aanmeldingen
self.deelcomp18_regio111.save()
self._create_deelnemers()
self.e2e_wissel_naar_functie(self.functie_wl)
self.e2e_check_rol('WL')
with self.assert_max_queries(20):
resp = self.client.get(self.url_regio_teams %
self.deelcomp18_regio111.pk)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(
resp, ('compregio/hwl-teams.dtl', 'plein/site_layout.dtl'))
def _competitie_instellingen(self):
self.e2e_login_and_pass_otp(self.testdata.account_bb) # geen account_hwl
self.e2e_wisselnaarrol_bb()
# klassengrenzen vaststellen
url_klassengrenzen = '/bondscompetities/%s/klassengrenzen/vaststellen/'
with self.assert_max_queries(86):
resp = self.client.post(url_klassengrenzen % self.comp_18.pk)
self.assert_is_redirect_not_plein(resp) # check for success
with self.assert_max_queries(86):
resp = self.client.post(url_klassengrenzen % self.comp_25.pk)
self.assert_is_redirect_not_plein(resp) # check for success
# nu in fase A2
# zet de inschrijfmethode van regio 101 op 'methode 1', oftewel met keuze wedstrijden
self.deelcomp.inschrijf_methode = INSCHRIJF_METHODE_1
self.deelcomp.save(update_fields=['inschrijf_methode'])
# zet de datum voor inschrijven op vandaag
for comp in Competitie.objects.filter(is_afgesloten=False):
zet_competitie_fase(comp, 'B')
def test_bad_wijzig_status(self):
self.client.logout()
url = self.url_wijzig_status % 999999
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert403(resp)
# RKO
self.e2e_login_and_pass_otp(self.account_rko1_18)
self.e2e_wissel_naar_functie(self.functie_rko1_18)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert404(resp) # 404 = Not allowed
with self.assert_max_queries(20):
resp = self.client.post(url)
self.assert404(resp) # 404 = Not allowed
# verkeerde RKO
self.e2e_login_and_pass_otp(self.account_rko2_18)
self.e2e_wissel_naar_functie(self.functie_rko2_18)
zet_competitie_fase(self.comp_18, 'J')
deelnemer = KampioenschapSchutterBoog(
deelcompetitie=self.deelcomp_rayon1_18,
sporterboog=self.sporterboog,
bij_vereniging=self.sporterboog.sporter.bij_vereniging,
klasse=self.klasse_r)
deelnemer.save()
url = self.url_wijzig_status % deelnemer.pk
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert403(resp)
with self.assert_max_queries(20):
resp = self.client.post(url)
self.assert403(resp)
def test_inschrijven_methode1(self):
self.deelcomp_regio.inschrijf_methode = INSCHRIJF_METHODE_1
self.deelcomp_regio.toegestane_dagdelen = '' # alles toegestaan
self.deelcomp_regio.save()
wedstrijd_pks = self._maak_wedstrijden()
# login als HWL
self.e2e_login_and_pass_otp(self.account_hwl)
self.e2e_wissel_naar_functie(self.functie_hwl)
self.e2e_check_rol('HWL')
# stel een paar bogen in
self._zet_sporter_voorkeuren(100002)
self._zet_sporter_voorkeuren(100003)
url = self.url_aanmelden % self.comp_18.pk
zet_competitie_fase(self.comp_18, 'B')
with self.assert_max_queries(21):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_template_used(resp,
('compinschrijven/hwl-leden-aanmelden.dtl',
'plein/site_layout.dtl'))
with self.assert_max_queries(20):
resp = self.client.post(
url, {
'wedstrijd_%s' % wedstrijd_pks[0]: 'on',
'lid_100003_boogtype_3': 'on'
})
self.assert_is_redirect_not_plein(resp) # check success
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(),
1) # 1 schutter, 1 competitie
deelnemer = RegioCompetitieSchutterBoog.objects.get(
sporterboog__sporter__lid_nr=100003)
self.assertEqual(deelnemer.inschrijf_gekozen_wedstrijden.count(), 1)
def test_administratief(self):
# log in als HWL
self.e2e_login_and_pass_otp(self.account_hwl)
self.e2e_wissel_naar_functie(self.functie_hwl)
self.e2e_check_rol('HWL')
# maak dit een administratieve regio waarvan de leden geen wedstrijden mogen schieten
regio = self.nhbver1.regio
regio.is_administratief = True
regio.save()
url = self.url_aanmelden % self.comp_18.pk
zet_competitie_fase(self.comp_18, 'B')
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
with self.assert_max_queries(20):
resp = self.client.post(url)
self.assert404(resp, 'Geen wedstrijden in deze regio')
def test_doorzetten_rk_geen_lid(self):
# variant van doorzetten_rk met een lid dat niet meer bij een vereniging aangesloten is
self.e2e_login_and_pass_otp(self.testdata.account_bb)
self.e2e_wissel_naar_functie(self.functie_bko_18)
# fase F: pagina zonder knop 'doorzetten'
zet_competitie_fase(self.comp_18, 'F')
# sluit alle deelcompetitie regio
for obj in DeelCompetitie.objects.filter(competitie=self.comp_18,
is_afgesloten=False,
laag=LAAG_REGIO):
obj.is_afgesloten = True
obj.save()
# for
# fase G: pagina met knop 'doorzetten'
zet_competitie_fase(self.comp_18, 'G')
# nu echt doorzetten
self._regioschutters_inschrijven()
self.assertEqual(3, RegioCompetitieSchutterBoog.objects.count())
self.assertEqual(0, KampioenschapSchutterBoog.objects.count())
self.lid_sporter_2.bij_vereniging = None
self.lid_sporter_2.save()
url = self.url_doorzetten_rk % self.comp_18.pk
with self.assert_max_queries(20):
resp = self.client.post(url)
self.assert_is_redirect(resp, '/bondscompetities/') # redirect = Success
# laat de mutatie verwerken
management.call_command('regiocomp_mutaties', '1', '--quick', stderr=io.StringIO(), stdout=io.StringIO())
# het lid zonder vereniging komt NIET in de RK selectie
self.assertEqual(2, KampioenschapSchutterBoog.objects.count())
def maak_competities_en_zet_fase_b(startjaar=None):
""" Competities 18m en 25m aanmaken, AG vaststellen, klassengrenzen vaststelen, instellen op fase B """
# dit voorkomt kennis en afhandelen van achtergrondtaken in alle applicatie test suites
# competitie aanmaken
competities_aanmaken(startjaar)
comp_18 = Competitie.objects.get(afstand='18')
comp_25 = Competitie.objects.get(afstand='25')
# aanvangsgemiddelden vaststellen
aanvangsgemiddelden_vaststellen_voor_afstand(18)
aanvangsgemiddelden_vaststellen_voor_afstand(25)
# klassengrenzen vaststellen
competitie_klassengrenzen_vaststellen(comp_18)
competitie_klassengrenzen_vaststellen(comp_25)
zet_competitie_fase(comp_18, 'B')
zet_competitie_fase(comp_25, 'B')
return comp_18, comp_25
def test_geen_voorkeur_competities(self):
# toon geen regiocompetities als de schutter geen interesse heeft
# log in as BB en maak de competitie aan
self.e2e_login_and_pass_otp(self.testdata.account_admin)
self.e2e_wisselnaarrol_bb()
self._competitie_aanmaken()
self.client.logout()
# zonder login --> terug naar het plein
with self.assert_max_queries(20):
resp = self.client.get(self.url_profiel)
self.assert403(resp)
# log in as schutter
self.e2e_login(self.account_normaal)
self._prep_voorkeuren()
# competitie wordt niet getoond in vroege fases
zet_competitie_fase(self.comp_18, 'A2')
with self.assert_max_queries(21):
resp = self.client.get(self.url_profiel)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
zet_competitie_fase(self.comp_18, 'B')
# met standaard voorkeuren worden de regiocompetities getoond
voorkeuren, _ = SporterVoorkeuren.objects.get_or_create(sporter=self.sporter1)
self.assertTrue(voorkeuren.voorkeur_meedoen_competitie)
with self.assert_max_queries(21):
resp = self.client.get(self.url_profiel)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
self.assert_template_used(resp, ('sporter/profiel.dtl', 'plein/site_layout.dtl'))
self.assertContains(resp, 'De volgende competities worden georganiseerd')
# uitgezet worden de regiocompetities niet getoond
voorkeuren.voorkeur_meedoen_competitie = False
voorkeuren.save()
with self.assert_max_queries(21):
resp = self.client.get(self.url_profiel)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
self.assert_template_used(resp, ('sporter/profiel.dtl', 'plein/site_layout.dtl'))
self.assertNotContains(resp, 'De volgende competities worden georganiseerd')
# schrijf de schutter in voor de 18m Recurve
sporterboog = SporterBoog.objects.get(boogtype__afkorting='R')
deelcomp = DeelCompetitie.objects.get(competitie__afstand='18', nhb_regio=self.nhbver.regio)
res = score_indiv_ag_opslaan(sporterboog, 18, 8.18, None, 'Test')
self.assertTrue(res)
url = self.url_aanmelden % (deelcomp.pk, sporterboog.pk)
with self.assert_max_queries(20):
resp = self.client.post(url, {'opmerking': 'test van de 18m'})
self.assert_is_redirect(resp, self.url_profiel)
# voorkeur net uitgezet, maar nog wel ingeschreven
with self.assert_max_queries(21):
resp = self.client.get(self.url_profiel)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
self.assert_template_used(resp, ('sporter/profiel.dtl', 'plein/site_layout.dtl'))
def test_compleet(self):
url_kies = '/bondscompetities/'
# log in as schutter
self.e2e_login(self.account_normaal)
self._prep_voorkeuren()
with self.assert_max_queries(20):
resp = self.client.get(self.url_profiel)
self.assertNotContains(resp, 'De volgende competities worden georganiseerd')
# competitie aanmaken
comp_18, comp_25 = maak_competities_en_zet_fase_b()
# log in as schutter
self.e2e_login(self.account_normaal)
self._prep_voorkeuren()
# controleer dat inschrijven mogelijk is
with self.assert_max_queries(20):
resp = self.client.get(self.url_profiel)
self.assertContains(resp, 'De volgende competities worden georganiseerd')
self.assertContains(resp, 'De inschrijving is open tot ')
self.assertContains(resp, 'De volgende competities passen bij de bogen waar jij mee schiet:')
urls = self.extract_all_urls(resp, skip_menu=True)
# print('urls:', urls)
urls = [url for url in urls if '/bondscompetities/deelnemen/aanmelden/' in url]
self.assertEqual(len(urls), 2)
# schrijf de schutter in voor de 18m Recurve
sporterboog = SporterBoog.objects.get(boogtype__afkorting='R')
deelcomp = DeelCompetitie.objects.get(competitie__afstand='18', nhb_regio=self.nhbver.regio)
res = score_indiv_ag_opslaan(sporterboog, 18, 8.18, None, 'Test')
self.assertTrue(res)
url = self.url_aanmelden % (deelcomp.pk, sporterboog.pk)
with self.assert_max_queries(20):
resp = self.client.post(url, {'opmerking': 'test van de 18m'})
self.assert_is_redirect(resp, self.url_profiel)
deelcomp = DeelCompetitie.objects.get(competitie__afstand='25', nhb_regio=self.nhbver.regio)
# zet de 25m door naar fase C
zet_competitie_fase(comp_25, 'C')
# controleer dat inschrijven nog mogelijk is voor 25m en uitschrijven voor 18m
with self.assert_max_queries(20):
resp = self.client.get(self.url_profiel)
self.assertContains(resp, 'De volgende competities worden georganiseerd')
self.assertContains(resp, 'De inschrijving is open tot ') # 18m
self.assertContains(resp, 'Aanmelden kan nog tot 1 februari 20') # 25m
urls = self.extract_all_urls(resp, skip_menu=True)
urls2 = [url for url in urls if '/bondscompetities/deelnemen/aanmelden/' in url]
self.assertEqual(len(urls2), 1)
urls2 = [url for url in urls if '/bondscompetities/deelnemen/afmelden/' in url]
self.assertEqual(len(urls2), 1)
# afmelden moet nog kunnen als de wedstrijdboog weer uitgezet is
sporterboog_bb = SporterBoog.objects.get(boogtype__afkorting='R')
sporterboog_bb.voor_wedstrijd = False
sporterboog_bb.save()
with self.assert_max_queries(23):
resp = self.client.get(self.url_profiel)
urls = self.extract_all_urls(resp, skip_menu=True)
# print('urls:', urls)
urls2 = [url for url in urls if '/bondscompetities/deelnemen/aanmelden/' in url]
self.assertEqual(len(urls2), 0)
urls2 = [url for url in urls if '/bondscompetities/deelnemen/afmelden/' in url]
self.assertEqual(len(urls2), 1)
sporterboog_bb.voor_wedstrijd = True
sporterboog_bb.save()
# zet de barebow boog 'aan' en schrijf in voor 25m BB
sporterboog_bb = SporterBoog.objects.get(boogtype__afkorting='BB')
sporterboog_bb.voor_wedstrijd = True
sporterboog_bb.save()
url = self.url_aanmelden % (deelcomp.pk, sporterboog_bb.pk)
with self.assert_max_queries(20):
resp = self.client.post(url, {'wil_in_team': 'on'})
self.assert_is_redirect(resp, self.url_profiel)
sporterboog_bb.voor_wedstrijd = False
sporterboog_bb.save()
# zet de 18m ook door naar fase F
zet_competitie_fase(comp_18, 'F')
# haal de profiel pagina op
with self.assert_max_queries(25):
resp = self.client.get(self.url_profiel)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
self.assert_template_used(resp, ('sporter/profiel.dtl', 'plein/site_layout.dtl'))
self.assertContains(resp, 'De inschrijving is gesloten') # 18m
self.assertContains(resp, 'Aanmelden kan nog tot 1 februari 20') # 25m
# zet aanvangsgemiddelden voor 18m en 25m
Score.objects.all().delete() # nieuw vastgestelde AG is van vandaag
obj = SporterBoog.objects.get(boogtype__afkorting='R')
score_indiv_ag_opslaan(obj, 18, 9.018, None, 'Test opmerking A')
score_indiv_ag_opslaan(obj, 25, 2.5, None, 'Test opmerking B')
with self.assert_max_queries(25):
resp = self.client.get(self.url_profiel)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
self.assertContains(resp, "2,500")
self.assertContains(resp, "9,018")
self.assertContains(resp, "Test opmerking A")
self.assertContains(resp, "Test opmerking B")
# variant met Score zonder ScoreHist
ScoreHist.objects.all().delete()
with self.assert_max_queries(25):
resp = self.client.get(self.url_profiel)
self.assertEqual(resp.status_code, 200) # 200 = OK
self.assert_html_ok(resp)
self.e2e_assert_other_http_commands_not_supported(self.url_profiel)
# zet de 18m door naar RK fase
# zet de 25m door naar BK fase
zet_competitie_fase(comp_18, 'K')
zet_competitie_fase(comp_25, 'P')
with self.assert_max_queries(23):
resp = self.client.get(self.url_profiel)
self.assertContains(resp, 'Rayonkampioenschappen') # 18m
self.assertContains(resp, 'Bondskampioenschappen') # 25m
def test_rayon_teams(self):
url = self.url_uitslagen_rayon_teams % (self.testdata.comp18.pk, 'R')
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(resp, ('compuitslagen/uitslagen-rayon-teams.dtl', 'plein/site_layout.dtl'))
url = self.url_uitslagen_rayon_teams % (999999, 'R')
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert404(resp, 'Competitie niet gevonden')
url = self.url_uitslagen_rayon_teams % (self.testdata.comp18.pk, 'X')
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert404(resp, 'Team type niet bekend')
url = self.url_uitslagen_rayon_teams_n % (self.testdata.comp18.pk, 'R', 1)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(resp, ('compuitslagen/uitslagen-rayon-teams.dtl', 'plein/site_layout.dtl'))
url = self.url_uitslagen_rayon_teams_n % (self.testdata.comp18.pk, 'R', 'X')
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert404(resp, 'Verkeerd rayonnummer')
url = self.url_uitslagen_rayon_teams_n % (self.testdata.comp18.pk, 'R', 999999)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert404(resp, 'Competitie niet gevonden')
# maak een paar teams aan
self.testdata.maak_inschrijvingen_rk_teamcompetitie(25, self.ver_nr, ook_incomplete_teams=False)
self.testdata.geef_rk_team_tijdelijke_sporters_genoeg_scores(25, self.ver_nr)
url = self.url_uitslagen_rayon_teams_n % (self.testdata.comp25.pk, 'R', 1)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(resp, ('compuitslagen/uitslagen-rayon-teams.dtl', 'plein/site_layout.dtl'))
# als BKO doorzetten naar RK fase (G --> J) en bepaal de klassengrenzen (fase J --> K)
self.e2e_login_and_pass_otp(self.testdata.account_bb)
self.e2e_wissel_naar_functie(self.testdata.comp25_functie_bko)
zet_competitie_fase(self.testdata.comp25, 'G')
url = self.url_doorzetten_rk % self.testdata.comp25.pk
resp = self.client.post(url)
self.assert_is_redirect_not_plein(resp)
self._verwerk_mutaties()
comp = Competitie.objects.get(pk=self.testdata.comp25.pk)
comp.bepaal_fase()
self.assertEqual(comp.fase, 'J')
url = self.url_teams_klassengrenzen_vaststellen % self.testdata.comp25.pk
resp = self.client.post(url)
self.assert_is_redirect_not_plein(resp)
url = self.url_uitslagen_rayon_teams_n % (self.testdata.comp25.pk, 'R', 1)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(resp, ('compuitslagen/uitslagen-rayon-teams.dtl', 'plein/site_layout.dtl'))
def test_inschrijven_methode1(self):
regio_101 = NhbRegio.objects.get(pk=101)
self.nhbver.regio = regio_101
self.nhbver.save()
# log in as BB en maak de competitie aan
self.e2e_login_and_pass_otp(self.testdata.account_admin)
self.e2e_wisselnaarrol_bb()
self._competitie_aanmaken()
deelcomp = DeelCompetitie.objects.get(competitie__afstand='18', nhb_regio=regio_101)
deelcomp.inschrijf_methode = INSCHRIJF_METHODE_1
deelcomp.save()
# maak een aantal wedstrijden aan, als RCL van Regio 101
functie_rcl101 = Functie.objects.get(rol='RCL', comp_type='18', nhb_regio=regio_101)
self.e2e_wissel_naar_functie(functie_rcl101)
url = self.url_planning_regio % deelcomp.pk
# TODO: commentaar hieronder zegt GET doet iets aanmaken. Moet niet!
# haal de (lege) planning op. Dit maakt ook meteen de enige ronde aan
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
# haal de planning op (maakt opnieuw een ronde aan)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200) # 200 = OK
ronde_pk = DeelcompetitieRonde.objects.filter(deelcompetitie=deelcomp)[0].pk
# haal de ronde planning op
url_ronde = self.url_planning_regio_ronde_methode1 % ronde_pk
with self.assert_max_queries(20):
resp = self.client.get(url_ronde)
self.assertEqual(resp.status_code, 200) # 200 = OK
# maak een wedstrijd aan
self.assertEqual(CompetitieWedstrijd.objects.count(), 0)
with self.assert_max_queries(20):
resp = self.client.post(url_ronde)
self.assert_is_redirect_not_plein(resp)
wedstrijd_pk = CompetitieWedstrijd.objects.all()[0].pk
# wijzig de instellingen van deze wedstrijd
url_wed = self.url_wijzig_wedstrijd % wedstrijd_pk
with self.assert_max_queries(20):
resp = self.client.post(url_wed, {'nhbver_pk': self.nhbver.pk,
'wanneer': '2020-12-11', 'aanvang': '12:34'})
self.assert_is_redirect(resp, url_ronde)
# maak nog een paar wedstrijden aan (voor later gebruik)
for lp in range(7):
with self.assert_max_queries(20):
resp = self.client.post(url_ronde)
self.assert_is_redirect_not_plein(resp)
# for
# log in as schutter
self.client.logout()
self.e2e_login(self.account_normaal)
self._prep_voorkeuren(100001)
# schrijf in voor de 18m Recurve, met AG
sporterboog = SporterBoog.objects.get(boogtype__afkorting='R')
# haal de bevestig pagina op met het formulier
url = self.url_bevestig_aanmelden % (deelcomp.pk, sporterboog.pk)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(resp, ('compinschrijven/sporter-bevestig-aanmelden.dtl', 'plein/site_layout.dtl'))
self.assertContains(resp, 'eigen blazoen')
self.assertContains(resp, 'Kies wanneer je wilt schieten')
self.assertContains(resp, '11 december 2020 om 12:34')
# special: zet het vastgestelde AG op 0.000
score_indiv_ag_opslaan(sporterboog, 18, 0.0, None, 'Test')
# doe de inschrijving
url = self.url_aanmelden % (deelcomp.pk, sporterboog.pk)
with self.assert_max_queries(20):
resp = self.client.post(url, {'wedstrijd_%s' % wedstrijd_pk: 'on',
'wedstrijd_99999': 'on'}) # is ignored
self.assert_is_redirect(resp, self.url_profiel)
aanmelding = RegioCompetitieSchutterBoog.objects.get(sporterboog=sporterboog)
self.assertEqual(aanmelding.ag_voor_indiv, 0.0)
self.assertEqual(aanmelding.ag_voor_team, 0.0)
self.assertTrue(aanmelding.ag_voor_team_mag_aangepast_worden)
# doe nog een inschrijving
self.e2e_login(self.account_twee)
self._prep_voorkeuren(100002)
sporterboog2 = SporterBoog.objects.get(sporter__lid_nr=100002, boogtype__afkorting='R')
# doe de inschrijving
url = self.url_aanmelden % (deelcomp.pk, sporterboog2.pk)
with self.assert_max_queries(20):
resp = self.client.post(url, {'wedstrijd_%s' % wedstrijd_pk: 'on'})
self.assert_is_redirect(resp, self.url_profiel)
aanmelding2 = RegioCompetitieSchutterBoog.objects.get(sporterboog=sporterboog2)
# terug naar de eerste sporter
self.e2e_login(self.account_normaal)
# probeer de schietmomenten van een andere schutter aan te passen
url = self.url_zeven_wedstrijden % aanmelding2.pk
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert403(resp)
with self.assert_max_queries(20):
resp = self.client.post(url)
self.assert403(resp)
# pas de schietmomenten aan
url = self.url_zeven_wedstrijden % aanmelding.pk
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(resp, ('compregio/keuze-zeven-wedstrijden-methode1.dtl', 'plein/site_layout.dtl'))
# wedstrijd behouden
with self.assert_max_queries(20):
resp = self.client.post(url, {'wedstrijd_%s' % wedstrijd_pk: 'on'})
self.assert_is_redirect(resp, self.url_profiel)
# wedstrijd verwijderen
with self.assert_max_queries(20):
resp = self.client.post(url)
self.assert_is_redirect(resp, self.url_profiel)
# wedstrijd toevoegen
with self.assert_max_queries(20):
resp = self.client.post(url, {'wedstrijd_%s' % wedstrijd_pk: 'on'})
self.assert_is_redirect(resp, self.url_profiel)
# te veel wedstrijden toevoegen
args = dict()
for obj in CompetitieWedstrijd.objects.all():
args['wedstrijd_%s' % obj.pk] = 'on'
# for
with self.assert_max_queries(20):
resp = self.client.post(url, args)
self.assert_is_redirect(resp, self.url_profiel)
# bad deelnemer_pk
with self.assert_max_queries(20):
resp = self.client.post(self.url_zeven_wedstrijden % 999999)
self.assert404(resp)
# special: probeer inschrijving met competitie in verkeerde fase
zet_competitie_fase(deelcomp.competitie, 'K')
url = self.url_aanmelden % (deelcomp.pk, sporterboog.pk)
with self.assert_max_queries(20):
resp = self.client.post(url, {'wedstrijd_%s' % wedstrijd_pk: 'on'})
self.assert404(resp)
def test_inschrijven(self):
# log in as BB en maak de competitie aan
self.e2e_login_and_pass_otp(self.testdata.account_admin)
self.e2e_wisselnaarrol_bb()
self._competitie_aanmaken()
# log in as schutter
self.client.logout()
self.e2e_login(self.account_normaal)
self._prep_voorkeuren(100001)
# schrijf in voor de 18m Recurve, met AG
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(), 0)
sporterboog = SporterBoog.objects.get(boogtype__afkorting='R')
deelcomp = DeelCompetitie.objects.get(competitie__afstand='18', nhb_regio=self.nhbver.regio)
res = score_indiv_ag_opslaan(sporterboog, 18, 8.18, None, 'Test')
self.assertTrue(res)
# haal de bevestig pagina op met het formulier
url = self.url_bevestig_aanmelden % (deelcomp.pk, sporterboog.pk)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(resp, ('compinschrijven/sporter-bevestig-aanmelden.dtl', 'plein/site_layout.dtl'))
self.assertContains(resp, 'eigen blazoen')
with self.assert_max_queries(20):
resp = self.client.post(self.url_aanmelden % (deelcomp.pk, sporterboog.pk))
self.assert_is_redirect(resp, self.url_profiel)
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(), 1)
inschrijving = RegioCompetitieSchutterBoog.objects.all()[0]
self.assertEqual(str(inschrijving.ag_voor_indiv), "8.180")
self.assertEqual(str(inschrijving.ag_voor_team), "8.180")
self.assertFalse(inschrijving.ag_voor_team_mag_aangepast_worden)
self.assertEqual(inschrijving.deelcompetitie, deelcomp)
self.assertEqual(inschrijving.sporterboog, sporterboog)
self.assertEqual(inschrijving.bij_vereniging, sporterboog.sporter.bij_vereniging)
self.assertFalse(inschrijving.inschrijf_voorkeur_team)
self.assertEqual(inschrijving.inschrijf_notitie, '')
self.assertEqual(inschrijving.inschrijf_voorkeur_dagdeel, 'GN')
self.assertTrue(str(RegioCompetitieSchutterBoog) != '') # coverage only
self.assertEqual(inschrijving.klasse.competitie.afstand, '18') # juiste competitie?
self.assertEqual(inschrijving.klasse.indiv.boogtype.afkorting, 'R') # klasse compatibel met boogtype?
# geen bevestig formulier indien al ingeschreven
url = self.url_bevestig_aanmelden % (deelcomp.pk, sporterboog.pk)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assert404(resp) # 404 = Not found
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(), 1)
# 18m IB voor extra coverage
sporterboog = SporterBoog.objects.get(boogtype__afkorting='IB')
url = self.url_bevestig_aanmelden % (deelcomp.pk, sporterboog.pk)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(resp, ('compinschrijven/sporter-bevestig-aanmelden.dtl', 'plein/site_layout.dtl'))
self.assertNotContains(resp, 'eigen blazoen')
# uitzondering: AG score zonder hist
res = score_indiv_ag_opslaan(sporterboog, 18, 7.18, None, 'Test 2')
self.assertTrue(res)
scores = Score.objects.filter(sporterboog=sporterboog,
type=SCORE_TYPE_INDIV_AG,
afstand_meter=deelcomp.competitie.afstand)
ScoreHist.objects.filter(score=scores[0]).delete()
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(resp, ('compinschrijven/sporter-bevestig-aanmelden.dtl', 'plein/site_layout.dtl'))
# schakel over naar de 25m1pijl, barebow
sporterboog = SporterBoog.objects.get(boogtype__afkorting='BB')
deelcomp = DeelCompetitie.objects.get(competitie__afstand='25', nhb_regio=self.nhbver.regio)
# haal de bevestig pagina op met het formulier
url = self.url_bevestig_aanmelden % (deelcomp.pk, sporterboog.pk)
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(resp, ('compinschrijven/sporter-bevestig-aanmelden.dtl', 'plein/site_layout.dtl'))
self.assertNotContains(resp, 'eigen blazoen')
# schrijf in voor de 25m BB, zonder AG
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(), 1)
with self.assert_max_queries(20):
resp = self.client.post(self.url_aanmelden % (deelcomp.pk, sporterboog.pk))
self.assert_is_redirect(resp, self.url_profiel)
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(), 2)
inschrijving_25 = RegioCompetitieSchutterBoog.objects.exclude(pk=inschrijving.pk)[0]
self.assertEqual(inschrijving_25.klasse.competitie.afstand, '25') # juiste competitie?
self.assertEqual(inschrijving_25.klasse.indiv.boogtype.afkorting, 'BB') # klasse compatibel met boogtype?
# probeer dubbel in te schrijven
with self.assert_max_queries(20):
resp = self.client.post(self.url_aanmelden % (deelcomp.pk, sporterboog.pk))
self.assert404(resp) # 404 = Not found
self.assertEqual(RegioCompetitieSchutterBoog.objects.count(), 2)
# competitie in verkeerde fase
comp = deelcomp.competitie # Competitie.objects.get(pk=deelcomp.competitie.pk)
zet_competitie_fase(comp, 'K')
with self.assert_max_queries(20):
resp = self.client.get(self.url_bevestig_aanmelden % (deelcomp.pk, sporterboog.pk))
self.assert404(resp) # 404 = Not found
def test_klassengrenzen_tonen(self):
# competitie opstarten
self.e2e_login_and_pass_otp(self.testdata.account_bb)
self.e2e_wisselnaarrol_bb()
self.e2e_check_rol('BB')
# maak de competities aan
competities_aanmaken()
comp_18 = Competitie.objects.filter(afstand=18).all()[0]
comp_25 = Competitie.objects.filter(afstand=25).all()[0]
with self.assert_max_queries(20):
resp = self.client.get(self.url_klassengrenzen_tonen % comp_18.pk)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(
resp,
('competitie/klassengrenzen-tonen.dtl', 'plein/site_layout.dtl'))
self.assertContains(resp, ' zijn nog niet vastgesteld')
self.assertContains(resp, 'De klassengrenzen voor de ')
# klassengrenzen vaststellen (18m en 25m)
# s1 = timezone.now()
with self.assert_max_queries(86):
resp = self.client.post(self.url_klassengrenzen_vaststellen %
comp_18.pk)
# s2 = timezone.now()
# print('duration:', s2-s1)
self.assert_is_redirect_not_plein(resp) # redirect = success
with self.assert_max_queries(86):
resp = self.client.post(self.url_klassengrenzen_vaststellen %
comp_25.pk)
self.assert_is_redirect_not_plein(resp) # redirect = success
# kies pagina ophalen als BB, dan worden alle competities getoond
zet_competitie_fase(comp_18, 'B')
with self.assert_max_queries(20):
resp = self.client.get(self.url_kies)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(
resp, ('competitie/kies.dtl', 'plein/site_layout.dtl'))
self.e2e_logout()
# kies pagina ophalen als bezoeker
with self.assert_max_queries(20):
resp = self.client.get(self.url_kies)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(
resp, ('competitie/kies.dtl', 'plein/site_layout.dtl'))
# nog een keer
with self.assert_max_queries(20):
resp = self.client.get(self.url_klassengrenzen_tonen % comp_25.pk)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(
resp,
('competitie/klassengrenzen-tonen.dtl', 'plein/site_layout.dtl'))
self.assertNotContains(resp, ' zijn nog niet vastgesteld')
self.assertNotContains(resp, 'De klassengrenzen voor de ')
with self.assert_max_queries(20):
resp = self.client.get(self.url_klassengrenzen_tonen % comp_18.pk)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(
resp,
('competitie/klassengrenzen-tonen.dtl', 'plein/site_layout.dtl'))
self.assertNotContains(resp, ' zijn nog niet vastgesteld')
self.assertNotContains(resp, 'De klassengrenzen voor de ')
def test_rk_teams_koppelen(self):
# login als HWL van vereniging 1000 in regio 111
self.e2e_login_and_pass_otp(self.account_hwl)
self.e2e_wissel_naar_functie(self.functie_hwl)
self.e2e_check_rol('HWL')
self._create_deelnemers()
deelcomp_rk3 = (DeelCompetitie.objects.get(competitie=self.comp_18,
laag=LAAG_RK,
nhb_rayon__rayon_nr=3)
) # regio 111 is in rayon 3
# zet competitie in fase E (nodig om een team aan te maken)
zet_competitie_fase(self.comp_18, 'E')
with self.settings(COMPETITIES_OPEN_RK_TEAMS_DAYS_AFTER=0):
# maak een team aan
self.assertEqual(KampioenschapTeam.objects.count(), 0)
with self.assert_max_queries(20):
url = self.url_rk_teams_wijzig % (deelcomp_rk3.pk, 0
) # 0 = nieuw team
resp = self.client.post(url, {'team_type': 'R'})
self.assert_is_redirect_not_plein(
resp) # is redirect naar 'koppelen'
self.assertEqual(KampioenschapTeam.objects.count(), 1)
team = KampioenschapTeam.objects.all()[0]
url = self.url_rk_teams_koppelen % team.pk
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(
resp,
('comprayon/hwl-teams-koppelen.dtl', 'plein/site_layout.dtl'))
with self.assert_max_queries(20):
resp = self.client.post(url, {
'deelnemer_999999': 1,
'deelnemer_xyz': 1
})
self.assert_is_redirect_not_plein(resp)
# bad team pk
resp = self.client.get(self.url_rk_teams_koppelen % 999999)
self.assert404(resp, 'Team niet gevonden')
resp = self.client.post(self.url_rk_teams_koppelen % 999999)
self.assert404(resp, 'Team niet gevonden')
# herhaal voor 25m1p
deelcomp_rk3 = (DeelCompetitie.objects.get(competitie=self.comp_25,
laag=LAAG_RK,
nhb_rayon__rayon_nr=3)
) # regio 111 is in rayon 3
# zet competitie in fase E (nodig om een team aan te maken)
zet_competitie_fase(self.comp_25, 'E')
# maak een team aan
team.delete()
self.assertEqual(KampioenschapTeam.objects.count(), 0)
with self.assert_max_queries(20):
url = self.url_rk_teams_wijzig % (deelcomp_rk3.pk, 0
) # 0 = nieuw team
resp = self.client.post(url, {'team_type': 'R'})
self.assert_is_redirect_not_plein(
resp) # is redirect naar 'koppelen'
self.assertEqual(KampioenschapTeam.objects.count(), 1)
team = KampioenschapTeam.objects.all()[0]
url = self.url_rk_teams_koppelen % team.pk
with self.assert_max_queries(20):
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
self.assert_html_ok(resp)
self.assert_template_used(
resp,
('comprayon/hwl-teams-koppelen.dtl', 'plein/site_layout.dtl'))
