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 = 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 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 setUpTestData(cls):
cls.factory = RequestFactory()
cls.presidente = crea_persona()
cls.presidente.email_contatto = email_fittizzia()
crea_utenza(cls.presidente, email=cls.presidente.email_contatto)
cls.sede = crea_sede(cls.presidente)
for i in range(cls.num_persone):
persona = crea_persona()
crea_appartenenza(persona, cls.sede)
persona.email_contatto = email_fittizzia()
persona.save()
cls.persone.append(crea_utenza(persona, email=email_fittizzia()))
def setUpTestData(cls):
cls.factory = RequestFactory()
cls.presidente = crea_persona()
cls.presidente.email_contatto = email_fittizzia()
crea_utenza(cls.presidente, email=cls.presidente.email_contatto)
cls.sede = crea_sede(cls.presidente)
for i in range(cls.num_persone):
persona = crea_persona()
crea_appartenenza(persona, cls.sede)
persona.email_contatto = email_fittizzia()
persona.save()
cls.persone.append(crea_utenza(persona, email=email_fittizzia()))
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_registrazione_quota_socio_senza_fine_chiuso(self):
# Crea oggetti e nomina il delegato US
delegato = crea_persona()
utente = crea_utenza(delegato, email="*****@*****.**", password="******")
volontario, sede, appartenenza = crea_persona_sede_appartenenza()
sede.aggiungi_delegato(UFFICIO_SOCI, delegato)
oggi = poco_fa()
inizio_anno = oggi.replace(month=1, day=1)
Tesseramento.objects.create(
stato=Tesseramento.CHIUSO, inizio=inizio_anno,
anno=inizio_anno.year, quota_attivo=8, quota_ordinario=8,
quota_benemerito=8, quota_aspirante=8, quota_sostenitore=8
)
sede.telefono = '+3902020202'
sede.email = '*****@*****.**'
sede.codice_fiscale = '01234567891'
sede.partita_iva = '01234567891'
sede.locazione = crea_locazione()
sede.save()
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': (oggi - datetime.timedelta(days=60)).strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')), data=data)
# tesseramento chiuso, quota non registrata
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'tesseramento {} è chiuso'.format(oggi.year))
def test_modifica_email(self):
EMAIL_UTENZA = email_fittizzia()
EMAIL_NUOVA = email_fittizzia()
persona = crea_persona()
utenza = crea_utenza(persona, EMAIL_UTENZA)
sessione = self.sessione_utente(persona=persona)
sessione.click_link_by_partial_text("Contatti")
sessione.is_text_present(EMAIL_UTENZA)
sessione.fill('email', EMAIL_NUOVA)
sessione.find_by_xpath("//button[@type='submit']").first.click()
sessione.is_text_present('Conferma nuovo indirizzo email')
sessione.is_text_present(EMAIL_NUOVA)
email = mail.outbox[0]
code_re = re.compile("/utente/contatti/\?code_m=([^']+)")
code_text = code_re.findall(email.alternatives[0][0])[0]
sessione.visit("%s%s?code_m=%s" % (self.live_server_url, persona.url_contatti, code_text))
sessione.is_text_present('Nuovo indirizzo email confermato!')
utenza.refresh_from_db()
self.assertTrue(
utenza.email == EMAIL_NUOVA,
msg="E-mail di accesso cambiata correttamente"
)
def setUp(self):
persona, sede, appartenenza = crea_persona_sede_appartenenza()
self.persona = persona
self.persona.email_contatto = email_fittizzia()
self.persona.save()
self.utenza = crea_utenza(persona=self.persona,
email=email_fittizzia())
def test_aggiornamento_ultima_azione(self):
persona = crea_persona()
utente = crea_utenza(persona)
utente.is_staff = True
utente.richiedi_2fa = True
utente.save()
data_base = datetime.datetime(2016, 1, 11, 12, 34, 56)
data_1 = data_base + datetime.timedelta(seconds=60)
data_2 = data_base + datetime.timedelta(seconds=120)
data_3 = data_base + datetime.timedelta(seconds=180)
data_4 = data_base + datetime.timedelta(seconds=240)
mock_time = Mock()
mock_time.return_value = data_base
with patch('autenticazione.two_factor.middleware.now', return_value=mock_time()):
self.assertIsNone(utente.ultima_azione)
response = self.client.post(settings.LOGIN_URL, data={
'auth-username': utente.email, 'auth-password': '******',
'jorvik_login_view-current_step': 'auth'
})
self.assertEqual(response.status_code, 302)
self.assertRedirects(response, reverse('two_factor:profile'))
utente = self._ricarica_model(utente._meta.model, utente)
self.assertEqual(utente.ultima_azione, data_base)
mock_time.return_value = data_1
with patch('autenticazione.two_factor.middleware.now', return_value=mock_time()):
response = self.client.post(settings.LOGOUT_URL)
self.assertContains(response, 'Sei uscito da Gaia')
utente = self._ricarica_model(utente._meta.model, utente)
self.assertEqual(utente.ultima_azione, data_1)
mock_time.return_value = data_2
with patch('autenticazione.two_factor.middleware.now', return_value=mock_time()):
StaticDevice.objects.create(user=utente, name="Device")
response = self.client.post(settings.LOGIN_URL, data={
'auth-username': utente.email, 'auth-password': '******',
'jorvik_login_view-current_step': 'auth'
})
self.assertEqual(response.status_code, 302)
self.assertRedirects(response, '/utente/', fetch_redirect_response=False)
utente = self._ricarica_model(utente._meta.model, utente)
self.assertEqual(utente.ultima_azione, data_2)
mock_time.return_value = data_3
with patch('autenticazione.two_factor.middleware.now', return_value=mock_time()):
response = self.client.get('/utente/')
utente = self._ricarica_model(utente._meta.model, utente)
self.assertEqual(utente.ultima_azione, data_3)
mock_time.return_value = data_4
with patch('autenticazione.two_factor.middleware.now', return_value=mock_time()):
response = self.client.get(reverse('two_factor:profile'))
utente = self._ricarica_model(utente._meta.model, utente)
self.assertEqual(utente.ultima_azione, data_4)
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_registrazione_quota_socio_inizio_anno(self):
# Crea oggetti e nomina il delegato US
delegato = crea_persona()
utente = crea_utenza(delegato, email="*****@*****.**", password="******")
volontario, sede, appartenenza = crea_persona_sede_appartenenza()
sede.aggiungi_delegato(UFFICIO_SOCI, delegato)
oggi = poco_fa()
inizio_anno = oggi.replace(month=1, day=1)
fine_soci = inizio_anno.replace(month=3) - datetime.timedelta(days=1)
post_fine_soci = fine_soci + datetime.timedelta(days=2)
Tesseramento.objects.create(
stato=Tesseramento.APERTO, inizio=inizio_anno, fine_soci=fine_soci,
anno=inizio_anno.year, quota_attivo=8, quota_ordinario=8, quota_benemerito=8,
quota_aspirante=8, quota_sostenitore=8
)
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': post_fine_soci.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')), data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'non può essere nel futuro')
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': oggi.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')), data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Necessario impostare indirizzo del Comitato')
sede.telefono = '+3902020202'
sede.email = '*****@*****.**'
sede.codice_fiscale = '01234567891'
sede.partita_iva = '01234567891'
sede.locazione = crea_locazione()
sede.save()
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': oggi.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')), data=data)
# quota registrata con successo
self.assertEqual(response.status_code, 302)
self.assertTrue(response['location'].find('?appena_registrata='))
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_recupero_password_corretto(self, mocked):
presidente = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza(presidente=presidente)
persona_in_sede = crea_persona()
utenza_persona_in_sede = crea_utenza(persona_in_sede)
appartenenza_persona_in_sede = crea_appartenenza(persona, sede)
sessione = self.sessione_anonimo()
sessione.visit("%s%s" % (self.live_server_url, reverse('recupera_password')))
sessione.fill('codice_fiscale', persona_in_sede.codice_fiscale)
sessione.fill('email', utenza_persona_in_sede.email)
sessione.find_by_css('.btn.btn-block.btn-primary').first.click()
self.assertTrue(sessione.is_text_present('Ti abbiamo inviato le istruzioni per cambiare la tua password tramite e-mail'))
def test_us_cambio_credenziali(self):
VECCHIA_EMAIL = email_fittizzia()
NUOVA_EMAIL = email_fittizzia()
presidente = crea_persona()
persona, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
utenza = crea_utenza(persona=persona, email=VECCHIA_EMAIL)
sessione_presidente = self.sessione_utente(persona=presidente)
sessione_presidente.visit("%s%s" % (self.live_server_url, persona.url_profilo_credenziali))
sessione_presidente.fill('email', NUOVA_EMAIL)
sessione_presidente.check('ok_1')
sessione_presidente.check('ok_3')
sessione_presidente.check('ok_4')
sessione_presidente.find_by_xpath("//button[@type='submit']").first.click()
# Ottieni e-mail inviata
msg = Messaggio.objects.filter(oggetto__icontains="credenziali",
oggetti_destinatario__persona=persona)
self.assertTrue(
msg.exists(),
msg="Email di avviso con nuove credenziali inviata"
)
msg_body = msg.first().corpo
self.assertTrue(
VECCHIA_EMAIL in msg_body,
msg="Il messaggio contiene la vecchia e-mail"
)
self.assertTrue(
NUOVA_EMAIL in msg_body,
msg="Il messaggio contiene la nuova e-mail"
)
utenza = persona.utenza
utenza.refresh_from_db()
self.assertTrue(
utenza.email == NUOVA_EMAIL,
msg="E-mail di accesso cambiata correttamente"
)
sessione_persona = self.sessione_utente(utente=utenza)
self.assertTrue(
True,
msg="Login effettuato con nuove credenziali"
)
def test_recupero_password_email_errata(self, mocked):
presidente = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza(presidente=presidente)
persona_in_sede = crea_persona()
utenza_persona_in_sede = crea_utenza(persona_in_sede)
appartenenza_persona_in_sede = crea_appartenenza(persona, sede)
sessione = self.sessione_anonimo()
sessione.visit("%s%s" % (self.live_server_url, reverse('recupera_password')))
sessione.fill('codice_fiscale', persona_in_sede.codice_fiscale)
sessione.fill('email', '*****@*****.**')
sessione.find_by_css('.btn.btn-block.btn-primary').first.click()
self.assertTrue(sessione.is_text_present('ma NON con questo indirizzo e-mail ([email protected])'))
self.assertTrue(sessione.is_text_present('Supporto di Gaia'))
def test_recupero_password_link_valido(self):
presidente = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza(presidente=presidente)
persona_in_sede = crea_persona()
utenza_persona_in_sede = crea_utenza(persona_in_sede)
appartenenza_persona_in_sede = crea_appartenenza(persona, sede)
uid = urlsafe_base64_encode(force_bytes(utenza_persona_in_sede.pk))
reset_pw_link = default_token_generator.make_token(utenza_persona_in_sede)
sessione = self.sessione_anonimo()
sessione.visit("%s%s" % (self.live_server_url, reverse('recupera_password_conferma', kwargs={ 'uidb64': uid, 'token': reset_pw_link})))
sessione.fill('new_password1', 'new_password')
sessione.fill('new_password2', 'new_password')
sessione.find_by_css('.btn.btn-block.btn-primary').first.click()
self.assertTrue(sessione.is_text_present('La tua nuova password è stata impostata'))
sessione.visit("%s%s" % (self.live_server_url, '/login/'))
sessione.fill('auth-username', utenza_persona_in_sede.email)
sessione.fill('auth-password', 'new_password')
sessione.find_by_css('.btn.btn-block.btn-primary').first.click()
testo_personalizzato = 'Ciao, {0}'.format(persona_in_sede.nome)
self.assertTrue(sessione.is_text_present(testo_personalizzato))
def pagamento_quota_nuovo_volontario(self):
"""
Testa che un nuovo volontario sia in grado di registarare
la quota nell'anno in cui è diventato volontario
"""
delegato = crea_persona()
utente = crea_utenza(delegato, email="*****@*****.**", password="******")
volontario, sede, appartenenza = crea_persona_sede_appartenenza()
sede.aggiungi_delegato(UFFICIO_SOCI, delegato)
sede.telefono = '+3902020202'
sede.email = '*****@*****.**'
sede.codice_fiscale = '01234567891'
sede.partita_iva = '01234567891'
sede.locazione = crea_locazione()
sede.save()
appartenenza.inizio = poco_fa().replace(month=8)
appartenenza.save()
oggi = poco_fa().replace(month=9)
inizio_anno = oggi.replace(month=1, day=1)
fine_soci = inizio_anno.replace(month=3) - datetime.timedelta(days=1)
fine_anno = inizio_anno.replace(month=12) - datetime.timedelta(days=31)
Tesseramento.objects.create(
stato=Tesseramento.APERTO, inizio=inizio_anno, fine_soci=fine_soci,
anno=inizio_anno.year, quota_attivo=8, quota_ordinario=8, quota_benemerito=8,
quota_aspirante=8, quota_sostenitore=8, fine_soci_nv=fine_anno
)
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': oggi.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')), data=data)
# quota registrata con successo
self.assertEqual(response.status_code, 302)
self.assertTrue(response['location'].find('?appena_registrata='))
def test_aggiornamento_ultima_azione(self):
persona = crea_persona()
utente = crea_utenza(persona)
utente.is_staff = True
utente.richiedi_2fa = True
utente.save()
data_base = datetime.datetime(2016, 1, 11, 12, 34, 56)
data_1 = data_base + datetime.timedelta(seconds=60)
data_2 = data_base + datetime.timedelta(seconds=120)
data_3 = data_base + datetime.timedelta(seconds=180)
data_4 = data_base + datetime.timedelta(seconds=240)
data_5 = data_base + datetime.timedelta(seconds=130 * 60)
mock_time = Mock()
mock_time.return_value = data_base
# simulazione del login e richiesta di attivazione 2FA
# la data dell'ultima azione viene aggiornata
with patch('autenticazione.two_factor.middleware.now',
return_value=mock_time()):
self.assertIsNone(utente.ultima_azione)
response = self.client.post(settings.LOGIN_URL,
data={
'auth-username':
utente.email,
'auth-password':
'******',
'jorvik_login_view-current_step':
'auth'
})
self.assertEqual(response.status_code, 302)
self.assertRedirects(response, reverse('two_factor:profile'))
utente = self._ricarica_model(utente._meta.model, utente)
self.assertEqual(utente.ultima_azione, data_base)
# simulazione del logout
# la data dell'ultima azione non viene aggiornata
mock_time.return_value = data_1
with patch('autenticazione.two_factor.middleware.now',
return_value=mock_time()):
response = self.client.post(settings.LOGOUT_URL)
self.assertContains(response, 'Sei uscito da Gaia')
utente = self._ricarica_model(utente._meta.model, utente)
self.assertEqual(utente.ultima_azione, data_base)
# Login con device 2FA attivo
# L'utente viene accettato e diretto alla home
# la data dell'ultima azione viene aggiornata
mock_time.return_value = data_2
with patch('autenticazione.two_factor.middleware.now',
return_value=mock_time()):
StaticDevice.objects.create(user=utente, name="Device")
response = self.client.post(settings.LOGIN_URL,
data={
'auth-username':
utente.email,
'auth-password':
'******',
'jorvik_login_view-current_step':
'auth'
})
self.assertEqual(response.status_code, 302)
self.assertRedirects(response,
'/utente/',
fetch_redirect_response=False)
utente = self._ricarica_model(utente._meta.model, utente)
self.assertEqual(utente.ultima_azione, data_2)
# visita di una pagina normale del sito
# la data dell'ultima azione viene aggiornata
mock_time.return_value = data_3
with patch('autenticazione.two_factor.middleware.now',
return_value=mock_time()):
response = self.client.get('/utente/')
utente = self._ricarica_model(utente._meta.model, utente)
self.assertEqual(utente.ultima_azione, data_3)
# visita di una pagina di servizio
# la data dell'ultima azione non viene aggiornata
mock_time.return_value = data_4
with patch('autenticazione.two_factor.middleware.now',
return_value=mock_time()):
response = self.client.get(reverse('two_factor:profile'))
utente = self._ricarica_model(utente._meta.model, utente)
self.assertEqual(utente.ultima_azione, data_3)
# visita di una pagina di servizio
# la data dell'ultima azione non viene aggiornata
mock_time.return_value = data_5
with patch('autenticazione.two_factor.middleware.now',
return_value=mock_time()):
response = self.client.get(settings.TWO_FACTOR_SESSIONE_SCADUTA)
utente = self._ricarica_model(utente._meta.model, utente)
self.assertEqual(utente.ultima_azione, data_3)
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_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_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_registrazione_quota_socio_iv(self):
# Crea oggetti e nomina il delegato US
delegato = crea_persona()
utente = crea_utenza(delegato, email="*****@*****.**", password="******")
volontario, sede, __ = crea_persona_sede_appartenenza()
volontario_iv_1 = crea_persona()
crea_appartenenza(volontario_iv_1, sede)
volontario_iv_1.iv = True
volontario_iv_1.save()
volontario_iv_2 = crea_persona()
crea_appartenenza(volontario_iv_2, sede)
volontario_iv_2.iv = True
volontario_iv_2.save()
sede.aggiungi_delegato(UFFICIO_SOCI, delegato)
sede.telefono = '+3902020202'
sede.email = '*****@*****.**'
sede.codice_fiscale = '01234567891'
sede.partita_iva = '01234567891'
sede.locazione = crea_locazione()
sede.save()
oggi = poco_fa()
inizio_anno = oggi.replace(month=1, day=1)
fine_soci = oggi - datetime.timedelta(days=60)
fine_soci_iv = oggi - datetime.timedelta(days=30)
data_1 = fine_soci_iv - datetime.timedelta(days=10)
data_2 = fine_soci - datetime.timedelta(days=10)
Tesseramento.objects.create(
stato=Tesseramento.APERTO, inizio=inizio_anno, fine_soci=fine_soci,
fine_soci_iv=fine_soci_iv, anno=inizio_anno.year, quota_attivo=8, quota_ordinario=8,
quota_benemerito=8, quota_aspirante=8, quota_sostenitore=8
)
# registrazione con data odierna bloccata per entrambi
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': oggi.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')),
data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'successiva al {}'.format(fine_soci.strftime('%Y-%m-%d')))
data = {
'volontario': volontario_iv_1.pk,
'importo': 8,
'data_versamento': oggi.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')),
data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'successiva al {}'.format(fine_soci_iv.strftime('%Y-%m-%d')))
# registrazione con data di un mese fa bloccata solo per soci normali
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': data_1.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')),
data=data)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'successiva al {}'.format(fine_soci.strftime('%Y-%m-%d')))
data = {
'volontario': volontario_iv_1.pk,
'importo': 8,
'data_versamento': data_1.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')),
data=data)
# quota registrata con successo
self.assertEqual(response.status_code, 302)
self.assertTrue(response['location'].find('?appena_registrata='))
# registrazione con data di due mesi fa bloccata solo per soci normali
data = {
'volontario': volontario.pk,
'importo': 8,
'data_versamento': data_2.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')),
data=data)
# quota registrata con successo
self.assertEqual(response.status_code, 302)
self.assertTrue(response['location'].find('?appena_registrata='))
data = {
'volontario': volontario_iv_2.pk,
'importo': 8,
'data_versamento': data_2.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')),
data=data)
# quota registrata con successo
self.assertEqual(response.status_code, 302)
self.assertTrue(response['location'].find('?appena_registrata='))
data = {
'volontario': volontario_iv_1.pk,
'importo': 8,
'data_versamento': data_1.strftime('%d/%m/%Y')
}
self.client.login(email="*****@*****.**", password="******")
response = self.client.post('{}{}'.format(self.live_server_url, reverse('us_quote_nuova')),
data=data)
# quota registrata con successo
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Questo volontario ha già pagato la Quota associativa '
'per l'anno {}'.format(oggi.year))
def setUpTestData(cls):
for i in range(cls.num_persone):
persona, sede, appartenenza = crea_persona_sede_appartenenza()
persona.email_contatto = email_fittizzia()
persona.save()
cls.persone.append(crea_utenza(persona, email=email_fittizzia()))
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_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')
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 setUp(self):
persona, sede, appartenenza = crea_persona_sede_appartenenza()
self.persona = persona
self.persona.email_contatto = email_fittizzia()
self.persona.save()
self.utenza = crea_utenza(persona=self.persona, email=email_fittizzia())
def test_richiesta_supporto(self):
presidente = crea_persona()
persona_normale, sede, app = crea_persona_sede_appartenenza(presidente=presidente)
persona_us = crea_persona()
persona_us_territoriale = crea_persona()
crea_appartenenza(persona_us, sede)
crea_appartenenza(persona_us_territoriale, sede)
crea_utenza(presidente, email=email_fittizzia())
crea_utenza(persona_normale, email=email_fittizzia())
crea_utenza(persona_us, email=email_fittizzia())
crea_utenza(persona_us_territoriale, email=email_fittizzia())
Delega.objects.create(
inizio="1980-12-10",
persona=persona_us,
tipo=UFFICIO_SOCI,
oggetto=sede
)
Delega.objects.create(
inizio="1980-12-10",
persona=persona_us_territoriale,
tipo=UFFICIO_SOCI_UNITA,
oggetto=sede
)
# Utente normale senza persone
sessione_normale = self.sessione_utente(persona=persona_normale)
sessione_normale.visit("%s/supporto/" % self.live_server_url)
sessione_normale.is_text_not_present('Seleziona le persone per cui si richiede assistenza.')
sessione_normale.find_option_by_value(ModuloRichiestaSupporto.SANGUE).first.click()
sessione_normale.fill('oggetto', 'Oggetto')
sessione_normale.fill('descrizione', 'Descrizione')
sessione_normale.find_by_css('.btn.btn-block.btn-primary').first.click()
self.assertTrue(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertEqual(email.subject, '(%s) Oggetto' % ModuloRichiestaSupporto.SANGUE)
self.assertTrue('Descrizione' in email.body)
mail.outbox = []
# Utente US con persone
sessione = self.sessione_utente(persona=persona_us)
sessione.visit("%s/supporto/" % self.live_server_url)
sessione.is_text_present('Seleziona le persone per cui si richiede assistenza.')
# Utente US con persone
sessione = self.sessione_utente(persona=persona_us_territoriale)
sessione.visit("%s/supporto/" % self.live_server_url)
sessione.is_text_present('Seleziona le persone per cui si richiede assistenza.')
# Presidente con persone
sessione = self.sessione_utente(persona=presidente)
sessione.visit("%s/supporto/" % self.live_server_url)
sessione.is_text_present('Seleziona le persone per cui si richiede assistenza.')
# Invio form persona normale
self.client.login(username=presidente.utenza.email, password='******')
dati = {
'oggetto': 'Oggetto',
'descrizione': 'Descrizione',
'tipo': ModuloRichiestaSupporto.TERZO_LIVELLO,
}
self.client.post('/supporto/', data=dati)
self.assertTrue(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertEqual(email.subject, '(%s) Oggetto' % ModuloRichiestaSupporto.TERZO_LIVELLO)
self.assertTrue('Descrizione' in email.body)
mail.outbox = []
# Invio form con selezione persone
dati = {
'persona': persona_normale.pk,
'oggetto': 'Oggetto',
'descrizione': 'Descrizione',
'tipo': ModuloRichiestaSupporto.TERZO_LIVELLO,
}
self.client.post('/supporto/', data=dati)
self.assertTrue(len(mail.outbox), 1)
email = mail.outbox[0]
self.assertEqual(email.subject, '(%s) Oggetto' % ModuloRichiestaSupporto.TERZO_LIVELLO)
self.assertTrue('Descrizione' in email.body)
self.assertTrue(force_text(persona_normale) in email.body)
mail.outbox = []
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)