def test_autocomplete_sostentitore_aspirante(self):
direttore, sede, appartenenza = crea_persona_sede_appartenenza()
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
aspirante1.save()
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.codice_fiscale[:3]))
self.assertContains(response, aspirante1.nome_completo)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.nome_completo))
self.assertNotContains(response, aspirante1.nome_completo)
# Creiamo aspirante
aspirante2 = crea_persona()
aspirante2.email_contatto = email_fittizzia()
aspirante2.codice_fiscale = codice_fiscale()
a = Aspirante(persona=aspirante2)
a.locazione = sede.locazione
a.save()
aspirante2.save()
# Se è solo aspirante viene selezionato
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.codice_fiscale[:3]))
self.assertContains(response, aspirante1.nome_completo)
Appartenenza.objects.create(
persona=aspirante2,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
)
# Con un appartenenza come volontario non è più selezionabile
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertNotContains(response, aspirante2.nome_completo)
# Dimettiamolo
aspirante2.espelli()
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertContains(response, aspirante2.nome_completo)
# Reintegriamolo
Appartenenza.objects.create(
persona=aspirante2,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio=poco_fa(),
)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertNotContains(response, aspirante2.nome_completo)
def test_autocomplete_sostentitore_aspirante(self):
direttore, sede, appartenenza = crea_persona_sede_appartenenza()
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
aspirante1.save()
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.codice_fiscale[:3]))
self.assertContains(response, aspirante1.nome_completo)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.nome_completo))
self.assertNotContains(response, aspirante1.nome_completo)
# Creiamo aspirante
aspirante2 = crea_persona()
aspirante2.email_contatto = email_fittizzia()
aspirante2.codice_fiscale = codice_fiscale()
a = Aspirante(persona=aspirante2)
a.locazione = sede.locazione
a.save()
aspirante2.save()
# Se è solo aspirante viene selezionato
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.codice_fiscale[:3]))
self.assertContains(response, aspirante1.nome_completo)
Appartenenza.objects.create(
persona=aspirante2,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
)
# Con un appartenenza come volontario non è più selezionabile
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertNotContains(response, aspirante2.nome_completo)
# Dimettiamolo
aspirante2.espelli()
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertContains(response, aspirante2.nome_completo)
# Reintegriamolo
Appartenenza.objects.create(
persona=aspirante2,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio=poco_fa(),
)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertNotContains(response, aspirante2.nome_completo)
def test_invito_aspirante(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.assertFalse(aspirante1.autorizzazioni_in_attesa().exists())
p = InvitoCorsoBase(persona=aspirante1, corso=corso, invitante=presidente)
p.save()
p.richiedi()
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertTrue(email.subject.find("Richiesta di iscrizione a Corso Base da {}".format(presidente.nome_completo)) > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(aspirante1.email_contatto, email.to)
self.assertEqual(aspirante1.autorizzazioni_in_attesa().count(), 1)
aspirante1.autorizzazioni_in_attesa()[0].concedi()
self.assertEqual(len(mail.outbox), 3)
email_aspirante = False
email_presidente = False
for email in mail.outbox[1:]:
if aspirante1.email_contatto in email.to:
email_aspirante = True
self.assertTrue(email.subject.find('Iscrizione a Corso Base') > -1)
elif presidente.email_contatto in email.to:
email_presidente = True
self.assertTrue(email.subject.find('Richiesta di iscrizione a Corso Base APPROVATA') > -1)
else:
raise AssertionError('Email a destinatario sconosciuto {}'.format(email.to))
self.assertTrue(email_aspirante)
self.assertTrue(email_presidente)
self.assertFalse(aspirante1.autorizzazioni_in_attesa().exists())
self.assertFalse(corso.inviti.exists())
self.assertEqual(corso.partecipazioni.count(), 1)
def test_invito_aspirante(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.assertFalse(aspirante1.autorizzazioni_in_attesa().exists())
p = InvitoCorsoBase(persona=aspirante1, corso=corso, invitante=presidente)
p.save()
p.richiedi()
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertTrue(email.subject.find("Richiesta di iscrizione a Corso Base da {}".format(presidente.nome_completo)) > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(aspirante1.email_contatto, email.to)
self.assertEqual(aspirante1.autorizzazioni_in_attesa().count(), 1)
aspirante1.autorizzazioni_in_attesa()[0].concedi()
self.assertEqual(len(mail.outbox), 3)
email_aspirante = False
email_presidente = False
for email in mail.outbox[1:]:
if aspirante1.email_contatto in email.to:
email_aspirante = True
self.assertTrue(email.subject.find('Iscrizione a Corso Base') > -1)
elif presidente.email_contatto in email.to:
email_presidente = True
self.assertTrue(email.subject.find('Richiesta di iscrizione a Corso Base APPROVATA') > -1)
else:
raise AssertionError('Email a destinatario sconosciuto {}'.format(email.to))
self.assertTrue(email_aspirante)
self.assertTrue(email_presidente)
self.assertFalse(aspirante1.autorizzazioni_in_attesa().exists())
self.assertFalse(corso.inviti.exists())
self.assertEqual(corso.partecipazioni.count(), 1)
def test_aspirante_confermato(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
sede = crea_sede(presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione1 = PartecipazioneCorsoBase.objects.create(persona=aspirante1, corso=corso)
partecipazione1.richiedi()
for autorizzazione in partecipazione1.autorizzazioni:
autorizzazione.concedi(firmatario=presidente, modulo=None)
partecipazione1.refresh_from_db()
dati = {
'ammissione': PartecipazioneCorsoBase.AMMESSO,
'motivo_non_ammissione': None,
'esito_parte_1': PartecipazioneCorsoBase.POSITIVO,
'argomento_parte_1': 'blah',
'esito_parte_2': PartecipazioneCorsoBase.POSITIVO,
'argomento_parte_2': 'bla',
'extra_1': False,
'extra_2': False,
'destinazione': sede.pk,
}
modulo = FormVerbaleCorso(
data=dati, generazione_verbale=True, instance=partecipazione1,
)
modulo.fields['destinazione'].queryset = corso.possibili_destinazioni()
modulo.fields['destinazione'].initial = corso.sede
self.assertTrue(modulo.is_valid())
modulo.save()
corso.termina(presidente)
self.assertFalse(Aspirante.objects.all().exists())
aspirante1 = Persona.objects.get(pk=aspirante1.pk)
with self.assertRaises(ObjectDoesNotExist):
self.assertFalse(aspirante1.aspirante)
def test_aspirante_confermato(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
sede = crea_sede(presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione1 = PartecipazioneCorsoBase.objects.create(persona=aspirante1, corso=corso)
partecipazione1.richiedi()
for autorizzazione in partecipazione1.autorizzazioni:
autorizzazione.concedi(firmatario=presidente, modulo=None)
partecipazione1.refresh_from_db()
dati = {
'ammissione': PartecipazioneCorsoBase.AMMESSO,
'motivo_non_ammissione': None,
'esito_parte_1': PartecipazioneCorsoBase.POSITIVO,
'argomento_parte_1': 'blah',
'esito_parte_2': PartecipazioneCorsoBase.POSITIVO,
'argomento_parte_2': 'bla',
'extra_1': False,
'extra_2': False,
'destinazione': sede.pk,
}
modulo = ModuloVerbaleAspiranteCorsoBase(
data=dati, generazione_verbale=True, instance=partecipazione1,
)
modulo.fields['destinazione'].queryset = corso.possibili_destinazioni()
modulo.fields['destinazione'].initial = corso.sede
self.assertTrue(modulo.is_valid())
modulo.save()
corso.termina(presidente)
self.assertFalse(Aspirante.objects.all().exists())
aspirante1 = Persona.objects.get(pk=aspirante1.pk)
with self.assertRaises(ObjectDoesNotExist):
self.assertFalse(aspirante1.aspirante)
def create_persona(with_utenza=True):
persona = crea_persona()
persona.email_contatto = email_fittizzia()
persona.codice_fiscale = codice_fiscale()
persona.save()
if with_utenza:
utenza = crea_utenza(persona, persona.email_contatto)
return persona, utenza
else:
return persona
def test_aggiungi_aspirante_multiplo(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.client.login(username=presidente.email_contatto, password='******')
# Iscrizione aspirante
iscritto = {
'persone': [aspirante1.pk]
}
response = self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritto)
self.assertEqual(corso.partecipazioni.count(), 0)
self.assertEqual(corso.inviti.count(), 1)
self.assertContains(response, aspirante1.nome_completo)
self.assertContains(response, 'In attesa')
# Correttezza email di invito
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertTrue(
email.subject.find("Richiesta di iscrizione a Corso Base da {}".format(presidente.nome_completo)) > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(aspirante1.email_contatto, email.to)
iscritto = {
'persone': [aspirante1.pk]
}
response = self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritto)
self.assertContains(response, 'Già invitato')
def test_aggiungi_aspirante_multiplo(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.client.login(username=presidente.email_contatto, password='******')
# Iscrizione aspirante
iscritto = {
'persone': [aspirante1.pk]
}
response = self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritto)
self.assertEqual(corso.partecipazioni.count(), 0)
self.assertEqual(corso.inviti.count(), 1)
self.assertContains(response, aspirante1.nome_completo)
self.assertContains(response, 'In attesa')
# Correttezza email di invito
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertTrue(
email.subject.find("Richiesta di iscrizione a Corso Base da {}".format(presidente.nome_completo)) > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(aspirante1.email_contatto, email.to)
iscritto = {
'persone': [aspirante1.pk]
}
response = self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritto)
self.assertContains(response, 'Già invitato')
def test_invito_aspirante_automatico(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.assertFalse(aspirante1.autorizzazioni_in_attesa().exists())
partecipazione = InvitoCorsoBase(persona=aspirante1, corso=corso, invitante=presidente)
partecipazione.save()
partecipazione.richiedi()
self.assertFalse(InvitoCorsoBase.con_esito_no().exists())
autorizzazione = presidente.autorizzazioni_richieste.first()
autorizzazione.scadenza = timezone.now() - timedelta(days=10)
autorizzazione.save()
self.assertFalse(autorizzazione.concessa)
Autorizzazione.gestisci_automatiche()
self.assertEqual(len(mail.outbox), 2)
messaggio = mail.outbox[1]
self.assertTrue(messaggio.subject.find('Richiesta di iscrizione a Corso Base RESPINTA') > -1)
self.assertFalse(messaggio.subject.find('Richiesta di iscrizione a Corso Base APPROVATA') > -1)
self.assertTrue(messaggio.body.find('una tua richiesta è rimasta in attesa per 30 giorni e come da policy') == -1)
self.assertEqual(autorizzazione.concessa, None)
self.assertTrue(InvitoCorsoBase.con_esito_no().exists())
def test_invito_aspirante_automatico(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.assertFalse(aspirante1.autorizzazioni_in_attesa().exists())
partecipazione = InvitoCorsoBase(persona=aspirante1, corso=corso, invitante=presidente)
partecipazione.save()
partecipazione.richiedi()
self.assertFalse(InvitoCorsoBase.con_esito_no().exists())
autorizzazione = presidente.autorizzazioni_richieste.first()
autorizzazione.scadenza = timezone.now() - timedelta(days=10)
autorizzazione.save()
self.assertFalse(autorizzazione.concessa)
Autorizzazione.gestisci_automatiche()
self.assertEqual(len(mail.outbox), 2)
messaggio = mail.outbox[1]
self.assertTrue(messaggio.subject.find('Richiesta di iscrizione a Corso Base RESPINTA') > -1)
self.assertFalse(messaggio.subject.find('Richiesta di iscrizione a Corso Base APPROVATA') > -1)
self.assertTrue(messaggio.body.find('una tua richiesta è rimasta in attesa per 30 giorni e come da policy') == -1)
self.assertEqual(autorizzazione.concessa, None)
self.assertTrue(InvitoCorsoBase.con_esito_no().exists())
def test_richieste_processabili(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
sede = crea_sede(presidente)
crea_appartenenza(sede=sede, persona=presidente)
sede2 = crea_sede(presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
est = Estensione.objects.create(
destinazione=sede2,
persona=presidente,
richiedente=presidente,
motivo='test'
)
est.richiedi()
oggi = poco_fa()
corso1 = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione1 = PartecipazioneCorsoBase.objects.create(persona=aspirante1, corso=corso1)
partecipazione1.richiedi()
corso2 = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi - timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione2 = PartecipazioneCorsoBase.objects.create(persona=aspirante1, corso=corso2)
partecipazione2.richiedi()
corso3 = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi - timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione3 = PartecipazioneCorsoBase.objects.create(persona=aspirante1, corso=corso3)
partecipazione3.richiedi()
ctype = ContentType.objects.get_for_model(CorsoBase)
Delega.objects.create(
persona=presidente, tipo=DIRETTORE_CORSO, stato=Delega.ATTIVA, firmatario=presidente, inizio=poco_fa(),
oggetto_id=corso1.pk, oggetto_tipo=ctype
)
Delega.objects.create(
persona=presidente, tipo=DIRETTORE_CORSO, stato=Delega.ATTIVA, firmatario=presidente, inizio=poco_fa(),
oggetto_id=corso2.pk, oggetto_tipo=ctype
)
Delega.objects.create(
persona=presidente, tipo=DIRETTORE_CORSO, stato=Delega.ATTIVA, firmatario=presidente, inizio=poco_fa(),
oggetto_id=corso3.pk, oggetto_tipo=ctype
)
url_presenti = []
url_assenti = []
richieste_non_processabili = partecipazione1.autorizzazioni.all()
for richiesta in richieste_non_processabili:
self.assertFalse(PartecipazioneCorsoBase.controlla_richiesta_processabile(richiesta))
url_assenti.append(reverse('autorizzazioni:concedi', args=(richiesta.pk,)))
url_assenti.append(reverse('autorizzazioni:nega', args=(richiesta.pk,)))
non_processabili = PartecipazioneCorsoBase.richieste_non_processabili(Autorizzazione.objects.all())
self.assertEqual(list(non_processabili), [richiesta.pk for richiesta in richieste_non_processabili])
richieste_processabili = partecipazione2.autorizzazioni.all() | partecipazione3.autorizzazioni.all()
for richiesta in richieste_processabili:
self.assertTrue(PartecipazioneCorsoBase.controlla_richiesta_processabile(richiesta))
url_presenti.append(reverse('autorizzazioni:concedi', args=(richiesta.pk,)))
url_presenti.append(reverse('autorizzazioni:nega', args=(richiesta.pk,)))
# Mettendo nel mezzo anche autorizzazioni diverse si verifica che il meccanismo non interferisca
richieste_estensioni = est.autorizzazioni.all()
for richiesta in richieste_estensioni:
pass
url_presenti.append(reverse('autorizzazioni:concedi', args=(richiesta.pk,)))
url_presenti.append(reverse('autorizzazioni:nega', args=(richiesta.pk,)))
self.client.login(email=presidente.email_contatto, password='******')
response = self.client.get(reverse('autorizzazioni-aperte'))
for url in url_presenti:
self.assertContains(response, url)
for url in url_assenti:
self.assertNotContains(response, url)
self.assertContains(response, 'Corso non ancora iniziato, impossibile processare la richiesta.')
for url in url_assenti:
response = self.client.get(url)
self.assertContains(response, 'Richiesta non processabile')
for richiesta in partecipazione2.autorizzazioni.all():
response = self.client.get(reverse('autorizzazioni:concedi', args=(richiesta.pk,)))
self.assertContains(response, 'Per dare consenso a questa richiesta')
for richiesta in partecipazione3.autorizzazioni.all():
response = self.client.get(reverse('autorizzazioni:nega', args=(richiesta.pk,)))
self.assertContains(response, 'Per negare questa richiesta')
for richiesta in est.autorizzazioni.all():
response = self.client.get(reverse('autorizzazioni:nega', args=(richiesta.pk,)))
self.assertContains(response, 'Per negare questa richiesta')
def test_aggiungi_sostenitore_aspirante(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
sostenitore = crea_persona()
sostenitore.email_contatto = email_fittizzia()
sostenitore.codice_fiscale = codice_fiscale()
sostenitore.save()
Appartenenza.objects.create(
persona=sostenitore,
sede=sede,
membro=Appartenenza.SOSTENITORE,
inizio="1980-12-10",
)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
aspirante2 = crea_persona()
aspirante2.email_contatto = email_fittizzia()
aspirante2.codice_fiscale = codice_fiscale()
aspirante2.save()
a = Aspirante(persona=aspirante2)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.codice_fiscale[:3]))
self.assertContains(response, aspirante1.nome_completo)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertContains(response, aspirante2.nome_completo)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(sostenitore.codice_fiscale[:3]))
self.assertContains(response, sostenitore.nome_completo)
self.client.login(username=presidente.email_contatto, password='******')
# Iscrizione aspirante
iscritto = {
'persone': [aspirante1.pk]
}
response = self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritto)
self.assertEqual(corso.partecipazioni.count(), 0)
self.assertEqual(corso.inviti.count(), 1)
self.assertContains(response, aspirante1.nome_completo)
self.assertContains(response, 'In attesa')
# Correttezza email di invito
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertTrue(email.subject.find("Richiesta di iscrizione a Corso Base da {}".format(presidente.nome_completo)) > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(aspirante1.email_contatto, email.to)
# Iscrizione aspirante
iscritto = {
'persone': [aspirante2.pk]
}
self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritto)
self.assertEqual(corso.inviti.count(), 2)
# Correttezza email di invito
self.assertEqual(len(mail.outbox), 2)
email = mail.outbox[0]
self.assertTrue(email.subject.find("Richiesta di iscrizione a Corso Base da {}".format(presidente.nome_completo)) > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(aspirante1.email_contatto, email.to)
# Iscrizione sostenitore
iscritto = {
'persone': [sostenitore.pk]
}
response = self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritto)
self.assertEqual(corso.partecipazioni.count(), 1)
self.assertContains(response, 'Sì')
self.assertContains(response, sostenitore.nome_completo)
# Correttezza email di iscrizione
self.assertEqual(len(mail.outbox), 3)
email = mail.outbox[2]
self.assertTrue(email.subject.find("Iscrizione a Corso Base") > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(sostenitore.email_contatto, email.to)
# Un aspirante approva
self.assertEqual(corso.partecipazioni.count(), 1)
self.assertEqual(aspirante1.autorizzazioni_in_attesa().count(), 1)
aspirante1.autorizzazioni_in_attesa()[0].concedi()
self.assertEqual(len(mail.outbox), 5)
email_aspirante = False
email_presidente = False
for email in mail.outbox[3:]:
if aspirante1.email_contatto in email.to:
email_aspirante = True
self.assertTrue(email.subject.find('Iscrizione a Corso Base') > -1)
elif presidente.email_contatto in email.to:
email_presidente = True
self.assertTrue(email.subject.find('Richiesta di iscrizione a Corso Base APPROVATA') > -1)
else:
raise AssertionError('Email a destinatario sconosciuto')
self.assertTrue(email_aspirante)
self.assertTrue(email_presidente)
self.assertFalse(aspirante1.autorizzazioni_in_attesa().exists())
self.assertEqual(corso.inviti.count(), 1)
self.assertEqual(corso.partecipazioni.count(), 2)
# Un aspirante declina
self.assertEqual(aspirante2.autorizzazioni_in_attesa().count(), 1)
aspirante2.autorizzazioni_in_attesa()[0].nega()
self.assertEqual(len(mail.outbox), 6)
email = mail.outbox[5]
self.assertIn(presidente.email_contatto, email.to)
self.assertTrue(email.subject.find('Richiesta di iscrizione a Corso Base RESPINTA') > -1)
self.assertFalse(aspirante2.autorizzazioni_in_attesa().exists())
self.assertFalse(corso.inviti.exists())
self.assertEqual(corso.partecipazioni.count(), 2)
def test_cancellazione_partecipante(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
sostenitore = crea_persona()
sostenitore.email_contatto = email_fittizzia()
sostenitore.save()
Appartenenza.objects.create(persona=sostenitore, sede=sede, membro=Appartenenza.SOSTENITORE, inizio=poco_fa())
altro = crea_persona()
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
aspirante2 = crea_persona()
aspirante2.email_contatto = email_fittizzia()
aspirante2.codice_fiscale = codice_fiscale()
aspirante2.save()
a = Aspirante(persona=aspirante2)
a.locazione = sede.locazione
a.save()
aspirante3 = crea_persona()
aspirante3.email_contatto = email_fittizzia()
aspirante3.codice_fiscale = codice_fiscale()
aspirante3.save()
a = Aspirante(persona=aspirante3)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione1 = InvitoCorsoBase.objects.create(persona=aspirante1, corso=corso, invitante=presidente)
partecipazione1.richiedi()
partecipazione2 = InvitoCorsoBase.objects.create(persona=aspirante2, corso=corso, invitante=presidente)
partecipazione2.richiedi()
partecipazione3 = PartecipazioneCorsoBase.objects.create(persona=aspirante3, corso=corso)
partecipazione3.richiedi()
partecipazione4 = PartecipazioneCorsoBase.objects.create(persona=sostenitore, corso=corso)
partecipazione4.richiedi()
for autorizzazione in partecipazione1.autorizzazioni:
autorizzazione.concedi(firmatario=presidente, modulo=None)
for autorizzazione in partecipazione4.autorizzazioni:
autorizzazione.concedi(firmatario=presidente, modulo=None)
mail.outbox = []
self.assertEqual(corso.partecipazioni_confermate_o_in_attesa().count(), 3)
self.assertEqual(corso.inviti_confermati_o_in_attesa().count(), 1)
self.assertEqual(corso.numero_partecipazioni_in_attesa_e_inviti(), 2)
self.client.login(username=presidente.email_contatto, password='******')
# Test del controllo di cancellazione nei 4 stati del corso
corso.stato = CorsoBase.TERMINATO
corso.save()
response = self.client.get(reverse('aspirante:formazione_iscritti_cancella', args=(corso.pk, sostenitore.pk)))
self.assertContains(response, "stadio della vita del corso base")
corso.stato = CorsoBase.ANNULLATO
corso.save()
response = self.client.get(reverse('aspirante:formazione_iscritti_cancella', args=(corso.pk, sostenitore.pk)))
self.assertContains(response, "stadio della vita del corso base")
corso.stato = CorsoBase.PREPARAZIONE
corso.save()
response = self.client.get(reverse('aspirante:formazione_iscritti_cancella', args=(corso.pk, sostenitore.pk)))
self.assertContains(response, "Conferma cancellazione")
corso.stato = CorsoBase.ATTIVO
corso.save()
response = self.client.get(reverse('aspirante:formazione_iscritti_cancella', args=(corso.pk, sostenitore.pk)))
self.assertContains(response, "Conferma cancellazione")
# GET chiede conferma
response = self.client.get(reverse('aspirante:formazione_iscritti_cancella', args=(corso.pk, sostenitore.pk)))
self.assertContains(response, "Conferma cancellazione")
self.assertContains(response, force_text(sostenitore))
# POST cancella
response = self.client.post(reverse('aspirante:formazione_iscritti_cancella', args=(corso.pk, sostenitore.pk)))
self.assertContains(response, "Iscritto cancellato")
self.assertEqual(corso.partecipazioni_confermate_o_in_attesa().count(), 2)
self.assertEqual(corso.inviti_confermati_o_in_attesa().count(), 1)
self.assertEqual(corso.numero_partecipazioni_in_attesa_e_inviti(), 2)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].subject, "Disiscrizione dal Corso Base: %s" % corso)
self.assertTrue(force_text(corso.sede) in mail.outbox[0].body)
self.assertTrue(presidente.nome_completo in mail.outbox[0].body)
self.assertFalse(sostenitore.nome_completo in mail.outbox[0].body)
self.assertTrue(sostenitore.nome in mail.outbox[0].body)
self.assertTrue(sostenitore.email_contatto in mail.outbox[0].to)
self.assertTrue(presidente.email_contatto in mail.outbox[1].to)
self.assertFalse(presidente.nome_completo in mail.outbox[1].body)
self.assertTrue(presidente.nome in mail.outbox[1].body)
self.assertTrue(sostenitore.nome_completo in mail.outbox[1].body)
mail.outbox = []
# Cancellare utente non esistente ritorna errore
response = self.client.post(reverse('aspirante:formazione_iscritti_cancella', args=(corso.pk, altro.pk + 10000)))
self.assertContains(response, "La persona cercata non è iscritta")
# Cancellare utente non associato al corso non ritorna errore -per evitare information leak- ma non cambia
# i dati
response = self.client.post(reverse('aspirante:formazione_iscritti_cancella', args=(corso.pk, altro.pk)))
self.assertContains(response, "Iscritto cancellato")
self.assertEqual(corso.partecipazioni_confermate_o_in_attesa().count(), 2)
self.assertEqual(corso.inviti_confermati_o_in_attesa().count(), 1)
self.assertEqual(corso.numero_partecipazioni_in_attesa_e_inviti(), 2)
self.assertEqual(len(mail.outbox), 0)
# Cancellare invitato confermato
response = self.client.post(reverse('aspirante:formazione_iscritti_cancella', args=(corso.pk, aspirante1.pk)))
self.assertContains(response, "Iscritto cancellato")
self.assertEqual(corso.partecipazioni_confermate_o_in_attesa().count(), 1)
self.assertEqual(corso.inviti_confermati_o_in_attesa().count(), 1)
self.assertEqual(corso.numero_partecipazioni_in_attesa_e_inviti(), 2)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].subject, "Disiscrizione dal Corso Base: %s" % corso)
self.assertTrue(force_text(corso.sede) in mail.outbox[0].body)
self.assertTrue(presidente.nome_completo in mail.outbox[0].body)
self.assertFalse(aspirante1.nome_completo in mail.outbox[0].body)
self.assertTrue(aspirante1.nome in mail.outbox[0].body)
self.assertTrue(aspirante1.email_contatto in mail.outbox[0].to)
self.assertTrue(presidente.email_contatto in mail.outbox[1].to)
self.assertFalse(presidente.nome_completo in mail.outbox[1].body)
self.assertTrue(presidente.nome in mail.outbox[1].body)
self.assertTrue(aspirante1.nome_completo in mail.outbox[1].body)
mail.outbox = []
# Cancellare invitato in attesa
response = self.client.post(reverse('aspirante:formazione_iscritti_cancella', args=(corso.pk, aspirante2.pk)))
self.assertContains(response, "Iscritto cancellato")
self.assertEqual(corso.partecipazioni_confermate_o_in_attesa().count(), 1)
self.assertEqual(corso.inviti_confermati_o_in_attesa().count(), 0)
self.assertEqual(corso.numero_partecipazioni_in_attesa_e_inviti(), 1)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].subject, "Annullamento invito al Corso Base: %s" % corso)
self.assertTrue(force_text(corso.sede) in mail.outbox[0].body)
self.assertTrue(aspirante2.email_contatto in mail.outbox[0].to)
self.assertTrue(presidente.email_contatto in mail.outbox[1].to)
mail.outbox = []
# Cancellare partecipante in attesa
response = self.client.post(reverse(
'aspirante:formazione_iscritti_cancella', args=(corso.pk,
aspirante3.pk)))
self.assertContains(response, "Iscritto cancellato")
self.assertEqual(corso.partecipazioni_confermate_o_in_attesa().count(), 0)
self.assertEqual(corso.inviti_confermati_o_in_attesa().count(), 0)
self.assertEqual(corso.numero_partecipazioni_in_attesa_e_inviti(), 0)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].subject, "Disiscrizione dal Corso Base: %s" % corso)
self.assertTrue(force_text(corso.sede) in mail.outbox[0].body)
self.assertTrue(aspirante3.email_contatto in mail.outbox[0].to)
self.assertTrue(presidente.email_contatto in mail.outbox[1].to)
mail.outbox = []
def test_cancellazione_partecipante(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
sostenitore = crea_persona()
sostenitore.email_contatto = email_fittizzia()
sostenitore.save()
Appartenenza.objects.create(persona=sostenitore, sede=sede, membro=Appartenenza.SOSTENITORE, inizio=poco_fa())
altro = crea_persona()
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
aspirante2 = crea_persona()
aspirante2.email_contatto = email_fittizzia()
aspirante2.codice_fiscale = codice_fiscale()
aspirante2.save()
a = Aspirante(persona=aspirante2)
a.locazione = sede.locazione
a.save()
aspirante3 = crea_persona()
aspirante3.email_contatto = email_fittizzia()
aspirante3.codice_fiscale = codice_fiscale()
aspirante3.save()
a = Aspirante(persona=aspirante3)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione1 = InvitoCorsoBase.objects.create(persona=aspirante1, corso=corso, invitante=presidente)
partecipazione1.richiedi()
partecipazione2 = InvitoCorsoBase.objects.create(persona=aspirante2, corso=corso, invitante=presidente)
partecipazione2.richiedi()
partecipazione3 = PartecipazioneCorsoBase.objects.create(persona=aspirante3, corso=corso)
partecipazione3.richiedi()
partecipazione4 = PartecipazioneCorsoBase.objects.create(persona=sostenitore, corso=corso)
partecipazione4.richiedi()
for autorizzazione in partecipazione1.autorizzazioni:
autorizzazione.concedi(firmatario=presidente, modulo=None)
for autorizzazione in partecipazione4.autorizzazioni:
autorizzazione.concedi(firmatario=presidente, modulo=None)
mail.outbox = []
self.assertEqual(corso.partecipazioni_confermate_o_in_attesa().count(), 3)
self.assertEqual(corso.inviti_confermati_o_in_attesa().count(), 1)
self.assertEqual(corso.numero_partecipazioni_in_attesa_e_inviti(), 2)
self.client.login(username=presidente.email_contatto, password='******')
# Test del controllo di cancellazione nei 4 stati del corso
corso.stato = CorsoBase.TERMINATO
corso.save()
response = self.client.get(reverse('formazione-iscritti-cancella', args=(corso.pk, sostenitore.pk)))
self.assertContains(response, "stadio della vita del corso base")
corso.stato = CorsoBase.ANNULLATO
corso.save()
response = self.client.get(reverse('formazione-iscritti-cancella', args=(corso.pk, sostenitore.pk)))
self.assertContains(response, "stadio della vita del corso base")
corso.stato = CorsoBase.PREPARAZIONE
corso.save()
response = self.client.get(reverse('formazione-iscritti-cancella', args=(corso.pk, sostenitore.pk)))
self.assertContains(response, "Conferma cancellazione")
corso.stato = CorsoBase.ATTIVO
corso.save()
response = self.client.get(reverse('formazione-iscritti-cancella', args=(corso.pk, sostenitore.pk)))
self.assertContains(response, "Conferma cancellazione")
# GET chiede conferma
response = self.client.get(reverse('formazione-iscritti-cancella', args=(corso.pk, sostenitore.pk)))
self.assertContains(response, "Conferma cancellazione")
self.assertContains(response, force_text(sostenitore))
# POST cancella
response = self.client.post(reverse('formazione-iscritti-cancella', args=(corso.pk, sostenitore.pk)))
self.assertContains(response, "Iscritto cancellato")
self.assertEqual(corso.partecipazioni_confermate_o_in_attesa().count(), 2)
self.assertEqual(corso.inviti_confermati_o_in_attesa().count(), 1)
self.assertEqual(corso.numero_partecipazioni_in_attesa_e_inviti(), 2)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].subject, "Disiscrizione dal Corso Base: %s" % corso)
self.assertTrue(force_text(corso.sede) in mail.outbox[0].body)
self.assertTrue(presidente.nome_completo in mail.outbox[0].body)
self.assertFalse(sostenitore.nome_completo in mail.outbox[0].body)
self.assertTrue(sostenitore.nome in mail.outbox[0].body)
self.assertTrue(sostenitore.email_contatto in mail.outbox[0].to)
self.assertTrue(presidente.email_contatto in mail.outbox[1].to)
self.assertFalse(presidente.nome_completo in mail.outbox[1].body)
self.assertTrue(presidente.nome in mail.outbox[1].body)
self.assertTrue(sostenitore.nome_completo in mail.outbox[1].body)
mail.outbox = []
# Cancellare utente non esistente ritorna errore
response = self.client.post(reverse('formazione-iscritti-cancella', args=(corso.pk, altro.pk + 10000)))
self.assertContains(response, "La persona cercata non è iscritta")
# Cancellare utente non associato al corso non ritorna errore -per evitare information leak- ma non cambia
# i dati
response = self.client.post(reverse('formazione-iscritti-cancella', args=(corso.pk, altro.pk)))
self.assertContains(response, "Iscritto cancellato")
self.assertEqual(corso.partecipazioni_confermate_o_in_attesa().count(), 2)
self.assertEqual(corso.inviti_confermati_o_in_attesa().count(), 1)
self.assertEqual(corso.numero_partecipazioni_in_attesa_e_inviti(), 2)
self.assertEqual(len(mail.outbox), 0)
# Cancellare invitato confermato
response = self.client.post(reverse('formazione-iscritti-cancella', args=(corso.pk, aspirante1.pk)))
self.assertContains(response, "Iscritto cancellato")
self.assertEqual(corso.partecipazioni_confermate_o_in_attesa().count(), 1)
self.assertEqual(corso.inviti_confermati_o_in_attesa().count(), 1)
self.assertEqual(corso.numero_partecipazioni_in_attesa_e_inviti(), 2)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].subject, "Disiscrizione dal Corso Base: %s" % corso)
self.assertTrue(force_text(corso.sede) in mail.outbox[0].body)
self.assertTrue(presidente.nome_completo in mail.outbox[0].body)
self.assertFalse(aspirante1.nome_completo in mail.outbox[0].body)
self.assertTrue(aspirante1.nome in mail.outbox[0].body)
self.assertTrue(aspirante1.email_contatto in mail.outbox[0].to)
self.assertTrue(presidente.email_contatto in mail.outbox[1].to)
self.assertFalse(presidente.nome_completo in mail.outbox[1].body)
self.assertTrue(presidente.nome in mail.outbox[1].body)
self.assertTrue(aspirante1.nome_completo in mail.outbox[1].body)
mail.outbox = []
# Cancellare invitato in attesa
response = self.client.post(reverse('formazione-iscritti-cancella', args=(corso.pk, aspirante2.pk)))
self.assertContains(response, "Iscritto cancellato")
self.assertEqual(corso.partecipazioni_confermate_o_in_attesa().count(), 1)
self.assertEqual(corso.inviti_confermati_o_in_attesa().count(), 0)
self.assertEqual(corso.numero_partecipazioni_in_attesa_e_inviti(), 1)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].subject, "Annullamento invito al Corso Base: %s" % corso)
self.assertTrue(force_text(corso.sede) in mail.outbox[0].body)
self.assertTrue(aspirante2.email_contatto in mail.outbox[0].to)
self.assertTrue(presidente.email_contatto in mail.outbox[1].to)
mail.outbox = []
# Cancellare partecipante in attesa
response = self.client.post(reverse('formazione-iscritti-cancella', args=(corso.pk, aspirante3.pk)))
self.assertContains(response, "Iscritto cancellato")
self.assertEqual(corso.partecipazioni_confermate_o_in_attesa().count(), 0)
self.assertEqual(corso.inviti_confermati_o_in_attesa().count(), 0)
self.assertEqual(corso.numero_partecipazioni_in_attesa_e_inviti(), 0)
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].subject, "Disiscrizione dal Corso Base: %s" % corso)
self.assertTrue(force_text(corso.sede) in mail.outbox[0].body)
self.assertTrue(aspirante3.email_contatto in mail.outbox[0].to)
self.assertTrue(presidente.email_contatto in mail.outbox[1].to)
mail.outbox = []
def test_gestione_inviti(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
sostenitore = crea_persona()
sostenitore.email_contatto = email_fittizzia()
sostenitore.codice_fiscale = codice_fiscale()
sostenitore.save()
Appartenenza.objects.create(
persona=sostenitore,
sede=sede,
membro=Appartenenza.SOSTENITORE,
inizio="1980-12-10",
)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
crea_utenza(aspirante1, aspirante1.email_contatto)
aspirante2 = crea_persona()
aspirante2.email_contatto = email_fittizzia()
aspirante2.codice_fiscale = codice_fiscale()
aspirante2.save()
a = Aspirante(persona=aspirante2)
a.locazione = sede.locazione
a.save()
crea_utenza(aspirante2, aspirante2.email_contatto)
# Attività degli aspiranti
sessione_aspirante1 = self.sessione_utente(persona=aspirante1)
sessione_aspirante2 = self.sessione_utente(persona=aspirante2)
sessione_aspirante1.click_link_by_partial_text("Richieste")
self.assertTrue(sessione_aspirante1.is_text_present("Non ci sono richieste in attesa."), msg="Nessun invito")
# setup dei dati
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.client.login(username=presidente.email_contatto, password='******')
iscritti = {
'persone': [aspirante1.pk]
}
self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritti)
iscritti = {
'persone': [aspirante2.pk]
}
self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritti)
self.assertEqual(corso.inviti.count(), 2)
sessione_aspirante1.click_link_by_partial_text("Richieste")
self.assertTrue(sessione_aspirante1.is_text_present(corso.nome), msg="Invito disponibile")
sessione_aspirante1.click_link_by_partial_text("Conferma")
self.assertTrue(sessione_aspirante1.is_text_present("Richiesta autorizzata."), msg="Richiesta autorizzata")
self.assertEqual(corso.inviti.count(), 1)
self.assertEqual(corso.partecipazioni.count(), 1)
self.assertEqual(aspirante2.inviti_corsi.count(), 1)
sessione_aspirante2.click_link_by_partial_text("Richieste")
self.assertTrue(sessione_aspirante2.is_text_present(corso.nome), msg="Invito disponibile")
sessione_aspirante2.click_link_by_partial_text("Nega")
sessione_aspirante2.fill('motivo', 'Test')
sessione_aspirante2.find_by_css(".btn-danger").first.click()
self.assertTrue(sessione_aspirante2.is_text_present("Richiesta negata."), msg="Richiesta negata")
self.assertEqual(corso.inviti.count(), 0)
self.assertEqual(corso.partecipazioni.count(), 1)
self.assertEqual(aspirante2.inviti_corsi.count(), 0)
def test_aggiungi_sostenitore_aspirante(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
sostenitore = crea_persona()
sostenitore.email_contatto = email_fittizzia()
sostenitore.codice_fiscale = codice_fiscale()
sostenitore.save()
Appartenenza.objects.create(
persona=sostenitore,
sede=sede,
membro=Appartenenza.SOSTENITORE,
inizio="1980-12-10",
)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
aspirante2 = crea_persona()
aspirante2.email_contatto = email_fittizzia()
aspirante2.codice_fiscale = codice_fiscale()
aspirante2.save()
a = Aspirante(persona=aspirante2)
a.locazione = sede.locazione
a.save()
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.codice_fiscale[:3]))
self.assertContains(response, aspirante1.nome_completo)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertContains(response, aspirante2.nome_completo)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(sostenitore.codice_fiscale[:3]))
self.assertContains(response, sostenitore.nome_completo)
self.client.login(username=presidente.email_contatto, password='******')
# Iscrizione aspirante
iscritto = {
'persone': [aspirante1.pk]
}
response = self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritto)
self.assertEqual(corso.partecipazioni.count(), 0)
self.assertEqual(corso.inviti.count(), 1)
self.assertContains(response, aspirante1.nome_completo)
self.assertContains(response, 'In attesa')
# Correttezza email di invito
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertTrue(email.subject.find("Richiesta di iscrizione a Corso Base da {}".format(presidente.nome_completo)) > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(aspirante1.email_contatto, email.to)
# Iscrizione aspirante
iscritto = {
'persone': [aspirante2.pk]
}
self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritto)
self.assertEqual(corso.inviti.count(), 2)
# Correttezza email di invito
self.assertEqual(len(mail.outbox), 2)
email = mail.outbox[0]
self.assertTrue(email.subject.find("Richiesta di iscrizione a Corso Base da {}".format(presidente.nome_completo)) > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(aspirante1.email_contatto, email.to)
# Iscrizione sostenitore
iscritto = {
'persone': [sostenitore.pk]
}
response = self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritto)
self.assertEqual(corso.partecipazioni.count(), 1)
self.assertContains(response, 'Sì')
self.assertContains(response, sostenitore.nome_completo)
# Correttezza email di iscrizione
self.assertEqual(len(mail.outbox), 3)
email = mail.outbox[2]
self.assertTrue(email.subject.find("Iscrizione a Corso Base") > -1)
self.assertEqual(len(email.to), 1)
self.assertIn(sostenitore.email_contatto, email.to)
# Un aspirante approva
self.assertEqual(corso.partecipazioni.count(), 1)
self.assertEqual(aspirante1.autorizzazioni_in_attesa().count(), 1)
aspirante1.autorizzazioni_in_attesa()[0].concedi()
self.assertEqual(len(mail.outbox), 5)
email_aspirante = False
email_presidente = False
for email in mail.outbox[3:]:
if aspirante1.email_contatto in email.to:
email_aspirante = True
self.assertTrue(email.subject.find('Iscrizione a Corso Base') > -1)
elif presidente.email_contatto in email.to:
email_presidente = True
self.assertTrue(email.subject.find('Richiesta di iscrizione a Corso Base APPROVATA') > -1)
else:
raise AssertionError('Email a destinatario sconosciuto')
self.assertTrue(email_aspirante)
self.assertTrue(email_presidente)
self.assertFalse(aspirante1.autorizzazioni_in_attesa().exists())
self.assertEqual(corso.inviti.count(), 1)
self.assertEqual(corso.partecipazioni.count(), 2)
# Un aspirante declina
self.assertEqual(aspirante2.autorizzazioni_in_attesa().count(), 1)
aspirante2.autorizzazioni_in_attesa()[0].nega()
self.assertEqual(len(mail.outbox), 6)
email = mail.outbox[5]
self.assertIn(presidente.email_contatto, email.to)
self.assertTrue(email.subject.find('Richiesta di iscrizione a Corso Base RESPINTA') > -1)
self.assertFalse(aspirante2.autorizzazioni_in_attesa().exists())
self.assertFalse(corso.inviti.exists())
self.assertEqual(corso.partecipazioni.count(), 2)
def test_gestione_inviti(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
sostenitore = crea_persona()
sostenitore.email_contatto = email_fittizzia()
sostenitore.codice_fiscale = codice_fiscale()
sostenitore.save()
Appartenenza.objects.create(
persona=sostenitore,
sede=sede,
membro=Appartenenza.SOSTENITORE,
inizio="1980-12-10",
)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
crea_utenza(aspirante1, aspirante1.email_contatto)
aspirante2 = crea_persona()
aspirante2.email_contatto = email_fittizzia()
aspirante2.codice_fiscale = codice_fiscale()
aspirante2.save()
a = Aspirante(persona=aspirante2)
a.locazione = sede.locazione
a.save()
crea_utenza(aspirante2, aspirante2.email_contatto)
# Attività degli aspiranti
sessione_aspirante1 = self.sessione_utente(persona=aspirante1)
sessione_aspirante2 = self.sessione_utente(persona=aspirante2)
sessione_aspirante1.click_link_by_partial_text("Richieste")
self.assertTrue(sessione_aspirante1.is_text_present("Non ci sono richieste in attesa."), msg="Nessun invito")
# setup dei dati
oggi = poco_fa()
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
self.client.login(username=presidente.email_contatto, password='******')
iscritti = {
'persone': [aspirante1.pk]
}
self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritti)
iscritti = {
'persone': [aspirante2.pk]
}
self.client.post('/aspirante/corso-base/{}/iscritti/aggiungi/'.format(corso.pk), data=iscritti)
self.assertEqual(corso.inviti.count(), 2)
sessione_aspirante1.click_link_by_partial_text("Richieste")
self.assertTrue(sessione_aspirante1.is_text_present(corso.nome), msg="Invito disponibile")
sessione_aspirante1.click_link_by_partial_text("Conferma")
self.assertTrue(sessione_aspirante1.is_text_present("Richiesta autorizzata."), msg="Richiesta autorizzata")
self.assertEqual(corso.inviti.count(), 1)
self.assertEqual(corso.partecipazioni.count(), 1)
self.assertEqual(aspirante2.inviti_corsi.count(), 1)
sessione_aspirante2.click_link_by_partial_text("Richieste")
self.assertTrue(sessione_aspirante2.is_text_present(corso.nome), msg="Invito disponibile")
sessione_aspirante2.click_link_by_partial_text("Nega")
sessione_aspirante2.fill('motivo', 'Test')
sessione_aspirante2.find_by_css(".btn-danger").first.click()
self.assertTrue(sessione_aspirante2.is_text_present("Richiesta negata."), msg="Richiesta negata")
self.assertEqual(corso.inviti.count(), 0)
self.assertEqual(corso.partecipazioni.count(), 1)
self.assertEqual(aspirante2.inviti_corsi.count(), 0)
def test_richieste_processabili(self):
presidente = crea_persona()
presidente.email_contatto = email_fittizzia()
presidente.save()
crea_utenza(presidente, presidente.email_contatto)
sede = crea_sede(presidente)
crea_appartenenza(sede=sede, persona=presidente)
sede2 = crea_sede(presidente)
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
aspirante1.save()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
est = Estensione.objects.create(
destinazione=sede2,
persona=presidente,
richiedente=presidente,
motivo='test'
)
est.richiedi()
oggi = poco_fa()
corso1 = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi + timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione1 = PartecipazioneCorsoBase.objects.create(persona=aspirante1, corso=corso1)
partecipazione1.richiedi()
corso2 = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi - timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione2 = PartecipazioneCorsoBase.objects.create(persona=aspirante1, corso=corso2)
partecipazione2.richiedi()
corso3 = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=oggi - timedelta(days=7),
data_esame=oggi + timedelta(days=14),
progressivo=1,
anno=oggi.year,
descrizione='Un corso',
)
partecipazione3 = PartecipazioneCorsoBase.objects.create(persona=aspirante1, corso=corso3)
partecipazione3.richiedi()
ctype = ContentType.objects.get_for_model(CorsoBase)
Delega.objects.create(
persona=presidente, tipo=DIRETTORE_CORSO, stato=Delega.ATTIVA, firmatario=presidente, inizio=poco_fa(),
oggetto_id=corso1.pk, oggetto_tipo=ctype
)
Delega.objects.create(
persona=presidente, tipo=DIRETTORE_CORSO, stato=Delega.ATTIVA, firmatario=presidente, inizio=poco_fa(),
oggetto_id=corso2.pk, oggetto_tipo=ctype
)
Delega.objects.create(
persona=presidente, tipo=DIRETTORE_CORSO, stato=Delega.ATTIVA, firmatario=presidente, inizio=poco_fa(),
oggetto_id=corso3.pk, oggetto_tipo=ctype
)
url_presenti = []
url_assenti = []
richieste_non_processabili = partecipazione1.autorizzazioni.all()
for richiesta in richieste_non_processabili:
self.assertFalse(PartecipazioneCorsoBase.controlla_richiesta_processabile(richiesta))
url_assenti.append(reverse('autorizzazioni-concedi', args=(richiesta.pk,)))
url_assenti.append(reverse('autorizzazioni-nega', args=(richiesta.pk,)))
non_processabili = PartecipazioneCorsoBase.richieste_non_processabili(Autorizzazione.objects.all())
self.assertEqual(list(non_processabili), [richiesta.pk for richiesta in richieste_non_processabili])
richieste_processabili = partecipazione2.autorizzazioni.all() | partecipazione3.autorizzazioni.all()
for richiesta in richieste_processabili:
self.assertTrue(PartecipazioneCorsoBase.controlla_richiesta_processabile(richiesta))
url_presenti.append(reverse('autorizzazioni-concedi', args=(richiesta.pk,)))
url_presenti.append(reverse('autorizzazioni-nega', args=(richiesta.pk,)))
# Mettendo nel mezzo anche autorizzazioni diverse si verifica che il meccanismo non interferisca
richieste_estensioni = est.autorizzazioni.all()
for richiesta in richieste_estensioni:
pass
url_presenti.append(reverse('autorizzazioni-concedi', args=(richiesta.pk,)))
url_presenti.append(reverse('autorizzazioni-nega', args=(richiesta.pk,)))
self.client.login(email=presidente.email_contatto, password='******')
response = self.client.get(reverse('autorizzazioni-aperte'))
for url in url_presenti:
self.assertContains(response, url)
for url in url_assenti:
self.assertNotContains(response, url)
self.assertContains(response, 'Corso non ancora iniziato, impossibile processare la richiesta.')
for url in url_assenti:
response = self.client.get(url)
self.assertContains(response, 'Richiesta non processabile')
for richiesta in partecipazione2.autorizzazioni.all():
response = self.client.get(reverse('autorizzazioni-concedi', args=(richiesta.pk,)))
self.assertContains(response, 'Per dare consenso a questa richiesta')
for richiesta in partecipazione3.autorizzazioni.all():
response = self.client.get(reverse('autorizzazioni-nega', args=(richiesta.pk,)))
self.assertContains(response, 'Per negare questa richiesta')
for richiesta in est.autorizzazioni.all():
response = self.client.get(reverse('autorizzazioni-nega', args=(richiesta.pk,)))
self.assertContains(response, 'Per negare questa richiesta')