def test_recupero_password_persona_non_utente(self, mocked):
presidente = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza(presidente=presidente)
sessione = self.sessione_anonimo()
# test con codice fiscale non associato ad utenza per persona associata a sede
sessione.visit("%s%s" % (self.live_server_url, reverse('recupera_password')))
sessione.fill('codice_fiscale', persona.codice_fiscale)
sessione.fill('email', '*****@*****.**')
sessione.find_by_css('.btn.btn-block.btn-primary').first.click()
self.assertTrue(sessione.is_text_present('Nessuna utenza'))
self.assertTrue(sessione.is_text_present('Chiedi al tuo Ufficio Soci'))
self.assertTrue(sessione.is_text_present('{} (Presidente)'.format(presidente.nome_completo)))
# test con codice fiscale non associato ad utenza per persona non associata a sede
persona_senza_sede = crea_persona()
sessione.visit("%s%s" % (self.live_server_url, reverse('recupera_password')))
sessione.fill('codice_fiscale', persona_senza_sede.codice_fiscale)
sessione.fill('email', '*****@*****.**')
sessione.find_by_css('.btn.btn-block.btn-primary').first.click()
sessione.screenshot()
self.assertTrue(sessione.is_text_present('Nessuna utenza'))
self.assertTrue(sessione.is_text_present('Supporto di Gaia'))
def test_reclama_ordinario(self):
# Crea oggetti e nomina i delegati US regionali e Locali
us_regionale = crea_persona()
us_locale = crea_persona()
ordinario, regionale, appartenenza = crea_persona_sede_appartenenza(presidente=us_regionale)
appartenenza.membro = Appartenenza.ORDINARIO
appartenenza.save()
regionale.estensione = REGIONALE
regionale.save()
locale = crea_sede(presidente=us_locale, genitore=regionale)
sessione_regionale = self.sessione_utente(persona=us_regionale)
sessione_locale = self.sessione_utente(persona=us_locale)
# Prima di tutto, assicurati che il socio ordinario risulti correttamente
# nell'elenco del regionale.
sessione_regionale.click_link_by_partial_text("Soci")
sessione_regionale.click_link_by_partial_text("Ordinari")
self.assertTrue(self.presente_in_elenco(sessione_regionale, persona=ordinario),
msg="Il socio ordinario è in elenco al regionale")
# Poi, vai alla procedura di reclamo per il locale e completa.
sessione_locale.click_link_by_partial_text("Soci")
sessione_locale.click_link_by_partial_text("Reclama Persona")
sessione_locale.fill('codice_fiscale', ordinario.codice_fiscale)
sessione_locale.find_by_xpath("//button[@type='submit']").first.click()
# Completa dati di inizio appartenenza - data nel passato!
sessione_locale.fill('app-inizio', "1/1/1910")
sessione_locale.select('app-membro', Appartenenza.SOSTENITORE)
sessione_locale.select('quota-registra_quota', ModuloReclamaQuota.NO)
sessione_locale.find_by_xpath("//button[@type='submit']").first.click()
self.assertTrue(sessione_locale.is_text_present("1. Appartenenza al Comitato"),
msg="Non e possibile reclamare ordinario nel passato")
# Compila con la data di oggi.
sessione_locale.fill('app-inizio', timezone.now().strftime("%d/%m/%Y"))
sessione_locale.find_by_xpath("//button[@type='submit']").first.click()
# Controlla elenco dei sostenitori.
sessione_locale.visit("%s/utente/" % self.live_server_url)
sessione_locale.click_link_by_partial_text("Soci")
sessione_locale.click_link_by_partial_text("Sostenitori")
self.assertTrue(
self.presente_in_elenco(sessione_locale, persona=ordinario),
msg="L'ex ordinario è stato reclamato con successo")
# Controlla la rimozione corretta dagli ordinari.
sessione_regionale.click_link_by_partial_text("Ordinari")
self.assertFalse(
self.presente_in_elenco(sessione_regionale, persona=ordinario),
msg="L'ex ordinario non è più in elenco al regionale"
)
def test_campo_centrale_operativa_disabilitata(self):
presidente = crea_persona()
referente = crea_persona()
volontario, sede, appartenenza = crea_persona_sede_appartenenza()
delega = Delega(
oggetto=sede,
persona=presidente,
tipo=PRESIDENTE,
inizio="2005-11-15",
)
delega.save()
delega_2 = Delega(
oggetto=sede,
persona=referente,
tipo=DELEGATO_CO,
inizio="2005-11-15",
)
delega_2.save()
area, attivita = crea_area_attivita(sede=sede)
inizio = timezone.now() + timedelta(hours=12)
fine = inizio + timedelta(hours=2)
turno = crea_turno(attivita, inizio=inizio, fine=fine)
attivita.aggiungi_delegato(REFERENTE, volontario)
attivita.aggiungi_delegato(REFERENTE, referente)
# Crea le sessioni
sessione_referente = self.sessione_utente(persona=referente)
sessione_volontario = self.sessione_utente(persona=volontario)
sessione_presidente = self.sessione_utente(persona=presidente)
# Volontario: Apri la pagina dell'attivita'
sessione_volontario.visit("%s%smodifica/" %
(self.live_server_url, attivita.url))
self.assertIn(
'disabled',
sessione_volontario.find_by_id('id_centrale_operativa')
[0].outer_html)
sessione_presidente.visit("%s%smodifica/" %
(self.live_server_url, attivita.url))
self.assertNotIn(
'disabled',
sessione_presidente.find_by_id('id_centrale_operativa')
[0].outer_html)
sessione_referente.visit("%s%smodifica/" %
(self.live_server_url, attivita.url))
self.assertNotIn(
'disabled',
sessione_referente.find_by_id('id_centrale_operativa')
[0].outer_html)
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 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 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_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_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_controllo_anni_attivita(self):
from anagrafica.costanti import LIMITE_ETA, LIMITE_ANNI_ATTIVITA
ora = now()
data_limite = ora.today()
data_sotto = data_limite.replace(year=data_limite.year -
(LIMITE_ETA - 1))
data_sopra = data_limite.replace(year=data_limite.year -
(LIMITE_ETA + 1))
data_limite = data_limite.replace(year=data_limite.year - LIMITE_ETA)
sede = crea_sede()
persona_sotto_limite = crea_persona()
persona_sotto_limite.data_nascita = data_sotto
persona_sotto_limite.save()
crea_appartenenza(persona_sotto_limite, sede)
persona_sopra_limite = crea_persona()
persona_sopra_limite.data_nascita = data_sopra
persona_sopra_limite.save()
crea_appartenenza(persona_sopra_limite, sede)
persona_al_limite = crea_persona()
persona_al_limite.data_nascita = data_limite
persona_al_limite.save()
crea_appartenenza(persona_al_limite, sede)
area, attivita = crea_area_attivita(sede)
for anni in range(0, LIMITE_ANNI_ATTIVITA + 3):
inizio = ora.replace(year=ora.year - (anni - 1))
fine = ora.replace(year=ora.year -
(anni - 1)) + datetime.timedelta(hours=1)
t1 = crea_turno(attivita, inizio=inizio, fine=fine)
if anni < LIMITE_ANNI_ATTIVITA:
for persona in (persona_sotto_limite, persona_sopra_limite,
persona_al_limite):
crea_partecipazione(persona, t1)
elif anni == LIMITE_ANNI_ATTIVITA:
for persona in (persona_sopra_limite, persona_al_limite):
crea_partecipazione(persona, t1)
else:
crea_partecipazione(persona_sopra_limite, t1)
lista = _calcola_anni_attivita(Persona.objects.all())
self.assertEqual(set(lista), {persona_sotto_limite})
lista = _calcola_anni_attivita(Persona.objects.all(), meno=False)
self.assertEqual(set(lista), {persona_al_limite, persona_sopra_limite})
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_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_apertura_elenchi(self):
# Crea oggetti e nomina il delegato US
delegato = crea_persona()
volontario, sede, appartenenza = crea_persona_sede_appartenenza()
sede.aggiungi_delegato(UFFICIO_SOCI, delegato)
# Inizia la sessione
sessione = self.sessione_utente(persona=delegato)
elenchi = ['volontari', 'giovani', 'estesi', 'ivcm', 'riserva',
'soci', 'sostenitori', 'dipendenti', 'dimessi',
'trasferiti', 'elettorato']
# Vai al pannello soci
sessione.click_link_by_partial_text("Soci")
for elenco in elenchi: # Per ogni elenco
sessione.visit("%s/us/elenchi/%s/" % (self.live_server_url, elenco))
# Genera con impostazioni di default (clicca due volte su "Genera")
sessione.find_by_xpath("//button[@type='submit']").first.click()
with sessione.get_iframe(0) as iframe: # Dentro la finestra
if iframe.is_text_present("Genera elenco"):
iframe.find_by_xpath("//button[@type='submit']").first.click()
self.assertTrue(
iframe.is_text_present("Invia messaggio", wait_time=5),
msg="Elenco %s apribile da web" % elenco,
)
def test_presidente_recursetree(self):
"""
Questo test controlla che la pagina /presidente
funzioni correttamente nel caso particolare di due sottoalberi
completamente separati, che causa problemi e non puo essere usata
con {% recursetree %}.
"""
presidente = crea_persona()
# Struttura:
# x
# - y presidenza
# - - a
# - - - b (unita)
# - c presidenza
# - - d (unita)
x = crea_sede()
y = crea_sede(genitore=x)
a = crea_sede(genitore=y, presidente=presidente)
b = crea_sede(genitore=a, estensione=TERRITORIALE)
c = crea_sede(genitore=x, presidente=presidente)
d = crea_sede(genitore=c, estensione=TERRITORIALE)
sessione = self.sessione_utente(persona=presidente)
sessione.click_link_by_partial_text("Sedi")
self.assertTrue(
sessione.is_text_present(c.nome),
msg="Pagina caricata correttamente"
)
def test_documenti(self):
p = crea_persona()
p.save()
d = Documento(
persona=p,
tipo=Documento.PATENTE_CIVILE,
file=None,
)
d.save()
self.assertTrue(
p.documenti.all(),
msg="Il membro ha almeno un documento"
)
self.assertTrue(
p.documenti.filter(tipo=Documento.PATENTE_CIVILE),
msg="Il membro ha di fatto una patente civile"
)
self.assertFalse(
p.documenti.filter(tipo=Documento.CARTA_IDENTITA),
msg="Il membro non ha davvero alcuna carta di identita"
)
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 test_dettaglio_articoli_privati(self):
articolo = Articolo.objects.create(
titolo='Titolo 1981',
corpo='Testo random',
estratto='qualcosa',
data_inizio_pubblicazione='1981-12-10',
stato=Articolo.PUBBLICATO
)
presidente = crea_persona()
presidente.save()
presidente, sede, _ = crea_persona_sede_appartenenza(presidente)
delega_presidente_in_corso = Delega(
persona=presidente,
tipo=PRESIDENTE,
oggetto=sede,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5)
)
delega_presidente_in_corso.save()
sessione_persona = self.sessione_utente(persona=presidente)
sessione_persona.visit("%s%s" % (
self.live_server_url, reverse('articoli:dettaglio', kwargs={
'articolo_slug': articolo.slug
})
))
self.assertTrue(sessione_persona.is_text_present(articolo.titolo))
def test_dettaglio_articoli_protected(self):
articolo = Articolo.objects.create(
titolo='Titolo 1981',
corpo='Testo random',
estratto='qualcosa',
data_inizio_pubblicazione='1981-12-10',
stato=Articolo.PUBBLICATO)
segmento_presidenti_no_filtri = ArticoloSegmento.objects.create(
segmento='I',
articolo=articolo,
)
normale = crea_persona()
normale.save()
normale, sede, _ = crea_persona_sede_appartenenza(normale)
delega_us = Delega(
persona=normale,
tipo=UFFICIO_SOCI,
oggetto=sede,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5))
delega_us.save()
sessione_persona = self.sessione_utente(persona=normale)
sessione_persona.visit(
"%s%s" % (self.live_server_url,
reverse('dettaglio_articolo',
kwargs={'articolo_slug': articolo.slug})))
self.assertTrue(
sessione_persona.is_text_present(
'Accesso Negato, siamo spiacenti'))
def test_dettaglio_articoli_privati(self):
articolo = Articolo.objects.create(
titolo='Titolo 1981',
corpo='Testo random',
estratto='qualcosa',
data_inizio_pubblicazione='1981-12-10',
stato=Articolo.PUBBLICATO
)
presidente = crea_persona()
presidente.save()
presidente, sede, _ = crea_persona_sede_appartenenza(presidente)
delega_presidente_in_corso = Delega(
persona=presidente,
tipo=PRESIDENTE,
oggetto=sede,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5)
)
delega_presidente_in_corso.save()
sessione_persona = self.sessione_utente(persona=presidente)
sessione_persona.visit("%s%s" % (
self.live_server_url, reverse('dettaglio_articolo', kwargs={
'articolo_slug': articolo.slug
})
))
self.assertTrue(sessione_persona.is_text_present(articolo.titolo))
def test_autorizzazioni_automatiche_non_scadute(self):
presidente = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza(presidente=presidente)
ora = timezone.now()
area, attivita = crea_area_attivita(sede)
domani_inizio = ora + timedelta(days=24)
domani_fine = ora + timedelta(days=180)
t1 = crea_turno(attivita, inizio=domani_inizio, fine=domani_fine)
partecipazione = crea_partecipazione(persona, t1)
attivita.centrale_operativa = Attivita.CO_AUTO
attivita.save()
self.assertEqual(0, Autorizzazione.objects.count())
partecipazione.richiedi()
self.assertEqual(0, len(mail.outbox))
self.assertEqual(1, Autorizzazione.objects.count())
autorizzazione = Autorizzazione.objects.first()
Autorizzazione.gestisci_automatiche()
self.assertEqual(0, len(mail.outbox))
self.assertFalse(partecipazione.automatica)
Autorizzazione.gestisci_automatiche()
self.assertEqual(0, len(mail.outbox))
self.assertFalse(partecipazione.automatica)
def test_autorizzazioni_automatiche_non_scadute(self):
presidente = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza(
presidente=presidente)
ora = timezone.now()
area, attivita = crea_area_attivita(sede)
domani_inizio = ora + timedelta(days=24)
domani_fine = ora + timedelta(days=180)
t1 = crea_turno(attivita, inizio=domani_inizio, fine=domani_fine)
partecipazione = crea_partecipazione(persona, t1)
attivita.centrale_operativa = Attivita.CO_AUTO
attivita.save()
self.assertEqual(0, Autorizzazione.objects.count())
partecipazione.richiedi()
self.assertEqual(0, len(mail.outbox))
self.assertEqual(1, Autorizzazione.objects.count())
autorizzazione = Autorizzazione.objects.first()
Autorizzazione.gestisci_automatiche()
self.assertEqual(0, len(mail.outbox))
self.assertFalse(partecipazione.automatica)
Autorizzazione.gestisci_automatiche()
self.assertEqual(0, len(mail.outbox))
self.assertFalse(partecipazione.automatica)
def test_dettaglio_articoli_protected(self):
articolo = Articolo.objects.create(
titolo='Titolo 1981',
corpo='Testo random',
estratto='qualcosa',
data_inizio_pubblicazione='1981-12-10',
stato=Articolo.PUBBLICATO
)
segmento_presidenti_no_filtri = ArticoloSegmento.objects.create(
segmento='I',
articolo=articolo,
)
normale = crea_persona()
normale.save()
normale, sede, _ = crea_persona_sede_appartenenza(normale)
delega_us = Delega(
persona=normale,
tipo=UFFICIO_SOCI,
oggetto=sede,
inizio=datetime.datetime.now() - datetime.timedelta(days=5),
fine=datetime.datetime.now() + datetime.timedelta(days=5)
)
delega_us.save()
sessione_persona = self.sessione_utente(persona=normale)
sessione_persona.visit("%s%s" % (
self.live_server_url, reverse('dettaglio_articolo', kwargs={
'articolo_slug': articolo.slug
})
))
self.assertTrue(sessione_persona.is_text_present('Accesso Negato, siamo spiacenti'))
def test_crea_area(self):
presidente = crea_persona()
persona, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
if not presidente.volontario:
crea_appartenenza(presidente, sede)
sessione_presidente = self.sessione_utente(persona=presidente)
#sessione_persona = self.sessione_utente(persona=persona)
# Crea area di intervento
sessione_presidente.click_link_by_partial_href("/attivita/")
sessione_presidente.click_link_by_partial_text("Aree di intervento")
sessione_presidente.click_link_by_partial_text(sede.nome)
sessione_presidente.fill('nome', "Area 42")
sessione_presidente.fill('obiettivo', '6')
sessione_presidente.find_by_xpath("//button[@type='submit']").first.click()
# Nomina la persona come responsabile
self.seleziona_delegato(sessione_presidente, persona)
self.assertTrue(
sessione_presidente.is_text_present("Area 42"),
"La nuova area è stata creata con successo",
)
self.assertTrue(
sessione_presidente.is_text_present(persona.nome_completo),
"La nuova area ha il responsabile assegnato",
)
self.assertTrue(
sessione_presidente.is_text_present("0 attività"),
"La nuova area non ha alcuna attività",
)
def test_corso_pubblico(self):
"""
Un corso è visibile fino a FORMAZIONE_FINESTRA_CORSI_INIZIATI giorni dal suo inizio
"""
presidente = crea_persona()
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
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.assertTrue(CorsoBase.pubblici().exists())
self.assertFalse(corso.iniziato)
self.assertFalse(corso.troppo_tardi_per_iscriverti)
self.assertTrue(corso.possibile_aggiungere_iscritti)
corso.data_inizio = oggi - timedelta(days=(settings.FORMAZIONE_FINESTRA_CORSI_INIZIATI - 1))
corso.save()
self.assertTrue(corso.iniziato)
self.assertFalse(corso.troppo_tardi_per_iscriverti)
self.assertTrue(corso.possibile_aggiungere_iscritti)
self.assertTrue(CorsoBase.pubblici().exists())
corso.data_inizio = oggi - timedelta(days=settings.FORMAZIONE_FINESTRA_CORSI_INIZIATI)
corso.save()
self.assertTrue(corso.iniziato)
self.assertTrue(corso.troppo_tardi_per_iscriverti)
self.assertTrue(corso.possibile_aggiungere_iscritti)
self.assertFalse(CorsoBase.pubblici().exists())
def test_corso_pubblico(self):
"""
Un corso è visibile fino a FORMAZIONE_FINESTRA_CORSI_INIZIATI giorni dal suo inizio
"""
presidente = crea_persona()
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
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.assertTrue(CorsoBase.pubblici().exists())
self.assertFalse(corso.iniziato)
self.assertFalse(corso.troppo_tardi_per_iscriverti)
self.assertTrue(corso.possibile_aggiungere_iscritti)
corso.data_inizio = oggi - timedelta(days=(settings.FORMAZIONE_FINESTRA_CORSI_INIZIATI - 1))
corso.save()
self.assertTrue(corso.iniziato)
self.assertFalse(corso.troppo_tardi_per_iscriverti)
self.assertTrue(corso.possibile_aggiungere_iscritti)
self.assertTrue(CorsoBase.pubblici().exists())
corso.data_inizio = oggi - timedelta(days=settings.FORMAZIONE_FINESTRA_CORSI_INIZIATI)
corso.save()
self.assertTrue(corso.iniziato)
self.assertTrue(corso.troppo_tardi_per_iscriverti)
self.assertTrue(corso.possibile_aggiungere_iscritti)
self.assertFalse(CorsoBase.pubblici().exists())
def test_ricerca_posizione(self):
presidente = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza(presidente=presidente)
area, attivita = crea_area_attivita(sede=sede)
sessione_presidente = self.sessione_utente(persona=presidente)
sessione_presidente.visit("%s%s" % (self.live_server_url,
attivita.url_modifica))
with sessione_presidente.get_iframe(0) as iframe:
iframe.fill('indirizzo', 'via etnea 353')
iframe.fill('comune', 'ct')
iframe.fill('provincia', 'ctnia')
iframe.find_by_xpath("//button[@type='submit']").first.click()
self.assertTrue(
iframe.is_text_present("Via Etnea, 353, 95125 Catania CT, Italia"),
msg="Indirizzo trovato correttamente"
)
iframe.find_by_xpath("//button[@value='Via Etnea, 353, 95125 Catania CT, Italia']").first.click()
self.assertTrue(
iframe.is_text_present("Via Etnea, 353, 95125 Catania CT, Italia", wait_time=5),
msg="Indirizzo salvato correttamente"
)
def test_login(self):
persona = crea_persona()
sessione = self.sessione_utente(persona=persona)
self.assertTrue(
True,
"Login effettuato con successo",
)
def test_logout(self):
persona = crea_persona()
sessione = self.sessione_utente(persona=persona)
sessione.visit("%s/logout/" % self.live_server_url)
self.assertFalse(sessione.is_text_present(persona.nome),
"Logout effettuato con successo")
def test_login(self):
persona = crea_persona()
sessione = self.sessione_utente(persona=persona)
self.assertTrue(
True,
"Login effettuato con successo",
)
def test_campo_centrale_operativa_disabilitata(self):
presidente = crea_persona()
referente = crea_persona()
volontario, sede, appartenenza = crea_persona_sede_appartenenza()
delega = Delega(
oggetto=sede,
persona=presidente,
tipo=PRESIDENTE,
inizio="2005-11-15",
)
delega.save()
delega_2 = Delega(
oggetto=sede,
persona=referente,
tipo=DELEGATO_CO,
inizio="2005-11-15",
)
delega_2.save()
area, attivita = crea_area_attivita(sede=sede)
inizio = timezone.now() + timedelta(hours=12)
fine = inizio + timedelta(hours=2)
turno = crea_turno(attivita, inizio=inizio, fine=fine)
attivita.aggiungi_delegato(REFERENTE, volontario)
attivita.aggiungi_delegato(REFERENTE, referente)
# Crea le sessioni
sessione_referente = self.sessione_utente(persona=referente)
sessione_volontario = self.sessione_utente(persona=volontario)
sessione_presidente = self.sessione_utente(persona=presidente)
# Volontario: Apri la pagina dell'attivita'
sessione_volontario.visit("%s%smodifica/" % (self.live_server_url, attivita.url))
self.assertIn('disabled', sessione_volontario.find_by_id('id_centrale_operativa')[0].outer_html)
sessione_presidente.visit("%s%smodifica/" % (self.live_server_url, attivita.url))
self.assertNotIn('disabled', sessione_presidente.find_by_id('id_centrale_operativa')[0].outer_html)
sessione_referente.visit("%s%smodifica/" % (self.live_server_url, attivita.url))
self.assertNotIn('disabled', sessione_referente.find_by_id('id_centrale_operativa')[0].outer_html)
def test_controllo_anni_attivita(self):
from anagrafica.costanti import LIMITE_ETA, LIMITE_ANNI_ATTIVITA
ora = now()
data_limite = ora.today()
data_sotto = data_limite.replace(year=data_limite.year - (LIMITE_ETA - 1))
data_sopra = data_limite.replace(year=data_limite.year - (LIMITE_ETA + 1))
data_limite = data_limite.replace(year=data_limite.year - LIMITE_ETA)
sede = crea_sede()
persona_sotto_limite = crea_persona()
persona_sotto_limite.data_nascita = data_sotto
persona_sotto_limite.save()
crea_appartenenza(persona_sotto_limite, sede)
persona_sopra_limite = crea_persona()
persona_sopra_limite.data_nascita = data_sopra
persona_sopra_limite.save()
crea_appartenenza(persona_sopra_limite, sede)
persona_al_limite = crea_persona()
persona_al_limite.data_nascita = data_limite
persona_al_limite.save()
crea_appartenenza(persona_al_limite, sede)
area, attivita = crea_area_attivita(sede)
for anni in range(0, LIMITE_ANNI_ATTIVITA + 3):
inizio = ora.replace(year=ora.year - (anni - 1))
fine = ora.replace(year=ora.year - (anni - 1)) + datetime.timedelta(hours=1)
t1 = crea_turno(attivita, inizio=inizio, fine=fine)
if anni < LIMITE_ANNI_ATTIVITA:
for persona in (persona_sotto_limite, persona_sopra_limite, persona_al_limite):
crea_partecipazione(persona, t1)
elif anni == LIMITE_ANNI_ATTIVITA:
for persona in (persona_sopra_limite, persona_al_limite):
crea_partecipazione(persona, t1)
else:
crea_partecipazione(persona_sopra_limite, t1)
lista = _calcola_anni_attivita(Persona.objects.all())
self.assertEqual(set(lista), {persona_sotto_limite})
lista = _calcola_anni_attivita(Persona.objects.all(), meno=False)
self.assertEqual(set(lista), {persona_al_limite, persona_sopra_limite})
def test_segmento_anzianita(self):
meno_di_tre_anni_fa = poco_fa() - timedelta(days=360*3)
meno_di_due_anni_fa = poco_fa() - timedelta(days=360*2)
meno_di_un_anno_fa = poco_fa() - timedelta(days=360)
presidente = crea_persona()
persona_1 = crea_persona()
persona_2 = crea_persona()
persona_3 = crea_persona()
presidente, sede, _ = crea_persona_sede_appartenenza(presidente)
Appartenenza.objects.create(
persona=persona_1,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio=meno_di_tre_anni_fa,
confermata=True
)
Appartenenza.objects.create(
persona=persona_2,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio=meno_di_due_anni_fa,
confermata=True
)
Appartenenza.objects.create(
persona=persona_3,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio=meno_di_un_anno_fa,
confermata=True
)
meno_di_un_anno = volontari_meno_un_anno(Persona.objects.all())
self.assertEqual(meno_di_un_anno.count(), 1)
self.assertEqual(meno_di_un_anno.get(), persona_3)
meno_di_due_anni = volontari_piu_un_anno(Persona.objects.all())
self.assertEqual(meno_di_due_anni.count(), 3)
self.assertTrue(presidente in meno_di_due_anni)
self.assertTrue(persona_1 in meno_di_due_anni)
self.assertTrue(persona_2 in meno_di_due_anni)
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_lista_articoli_vuota(self):
persona = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza()
sessione_persona = self.sessione_utente(persona=persona)
sessione_persona.visit(
"%s%s" % (self.live_server_url, reverse('lista_articoli')))
self.assertTrue(
sessione_persona.is_text_present(
'Non è stato trovato alcun articolo'))
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 test_lista_documenti(self):
extra_headers = {}
self.assertEqual(Documento.objects.count(), 0)
folder_radice = Folder.objects.create(name='radice')
folder_figlia = Folder.objects.create(name='sottocartella',
parent=folder_radice)
file_obj = django.core.files.File(open(self.doc_filename, 'rb'))
url = reverse('admin:filer-ajax_upload',
kwargs={'folder_id': folder_figlia.pk})
post_data = {
'Filename': self.doc_name,
'Filedata': file_obj,
'jsessionid': self.client.session.session_key
}
self.client.post(url, post_data, **extra_headers)
self.assertEqual(Documento.objects.count(), 1)
uploaded_file = Documento.objects.all()[0]
self.assertEqual(uploaded_file.original_filename, self.doc_name)
url = reverse('admin:gestione_file_documento_add'
) + '?parent_id={}'.format(folder_radice.pk)
post_data = {
'url_documento': 'http://www.example.com',
'segmenti-TOTAL_FORMS': 0,
'segmenti-INITIAL_FORMS': 0,
'segmenti-MIN_NUM_FORMS': 0,
'segmenti-MAX_NUM_FORMS': 0,
'data_pubblicazione_0': '2016-01-01',
'data_pubblicazione_1': '22:22:22',
}
response = self.client.post(url, post_data, **extra_headers)
self.assertEqual(Documento.objects.count(), 2)
uploaded_file = Documento.objects.all()[1]
self.assertEqual(uploaded_file.folder, folder_radice)
self.assertEqual(uploaded_file.original_filename, 'www.example.com')
persona = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza()
sessione_persona = self.sessione_utente(persona=persona)
sessione_persona.visit(
"%s%s" %
(self.live_server_url, reverse('documenti:lista_documenti')))
self.assertTrue(sessione_persona.is_text_present('Nome del documento'))
self.assertTrue(sessione_persona.is_text_present('Pubblicato il'))
self.assertTrue(sessione_persona.is_text_present('Peso'))
self.assertTrue(sessione_persona.is_text_present('Accessi'))
self.assertEqual(
1, len(sessione_persona.find_by_tag('tbody').find_by_tag('tr')))
sessione_persona.find_link_by_text('radice').first.click()
self.assertTrue(sessione_persona.is_text_present('www.example.com'))
sessione_persona.find_link_by_text('sottocartella').first.click()
self.assertTrue(sessione_persona.is_text_present(self.doc_name))
sessione_persona.fill('q', 'example')
sessione_persona.find_by_xpath(
'//button[@type="submit"]').first.click()
self.assertTrue(sessione_persona.is_text_present('www.example.com'))
def test_logout(self):
persona = crea_persona()
sessione = self.sessione_utente(persona=persona)
sessione.visit("%s/logout/" % self.live_server_url)
self.assertFalse(
sessione.is_text_present(persona.nome),
"Logout effettuato con successo"
)
def test_lista_documenti_vuota(self):
persona = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza()
sessione_persona = self.sessione_utente(persona=persona)
sessione_persona.visit("%s%s" % (self.live_server_url, reverse('lista_documenti')))
self.assertTrue(sessione_persona.is_text_present('Nome del documento'))
self.assertTrue(sessione_persona.is_text_present('Pubblicato il'))
self.assertTrue(sessione_persona.is_text_present('Peso'))
self.assertTrue(sessione_persona.is_text_present('Accessi'))
self.assertEqual(1, len(sessione_persona.find_by_tag('tbody').find_by_css('tr.warning')))
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 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_pulizia_aspiranti(self):
presidente = crea_persona()
sede = crea_sede(presidente)
corso = CorsoBase.objects.create(
stato=CorsoBase.ATTIVO,
sede=sede,
data_inizio=poco_fa() + timedelta(days=7),
data_esame=poco_fa() + timedelta(days=14),
progressivo=1,
anno=poco_fa().year,
descrizione='Un corso',
)
for x in range(30):
persona = crea_persona()
Aspirante.objects.create(persona=persona, locazione = sede.locazione)
PartecipazioneCorsoBase.objects.create(persona=persona, corso=corso, confermata=True)
if x % 4 == 1:
crea_appartenenza(persona, sede)
elif x % 4 == 2:
app = crea_appartenenza(persona, sede)
app.fine = poco_fa()
app.save()
elif x % 4 == 3:
app = crea_appartenenza(persona, sede)
app.membro = Appartenenza.SOSTENITORE
app.save()
vol = Aspirante._anche_volontari()
persone = Persona.objects.filter(pk__in=vol.values_list('persona', flat=True))
self.assertEqual(len(vol), 8)
Aspirante.pulisci_volontari()
for persona in persone:
self.assertFalse(hasattr(persona, 'aspirante'))
self.assertTrue(persona.partecipazioni_corsi.esito_esame, PartecipazioneCorsoBase.IDONEO)
def test_controllo_eta(self):
from anagrafica.costanti import LIMITE_ETA
data_limite = datetime.date.today()
data_sotto = data_limite.replace(year=data_limite.year -
(LIMITE_ETA - 1))
data_sopra = data_limite.replace(year=data_limite.year -
(LIMITE_ETA + 1))
data_limite = data_limite.replace(year=data_limite.year - LIMITE_ETA)
persona_sotto_limite = crea_persona()
persona_sotto_limite.data_nascita = data_sotto
persona_sotto_limite.save()
persona_sopra_limite = crea_persona()
persona_sopra_limite.data_nascita = data_sopra
persona_sopra_limite.save()
persona_al_limite = crea_persona()
persona_al_limite.data_nascita = data_limite
persona_al_limite.save()
lista = _calcola_eta(Persona.objects.all())
self.assertEqual(set(lista), {persona_sotto_limite})
lista = _calcola_eta(Persona.objects.all(), meno=False)
self.assertEqual(set(lista), {persona_al_limite, persona_sopra_limite})
def test_lista_documenti_vuota(self):
persona = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza()
sessione_persona = self.sessione_utente(persona=persona)
sessione_persona.visit(
"%s%s" % (self.live_server_url, reverse('lista_documenti')))
self.assertTrue(sessione_persona.is_text_present('Nome del documento'))
self.assertTrue(sessione_persona.is_text_present('Pubblicato il'))
self.assertTrue(sessione_persona.is_text_present('Peso'))
self.assertTrue(sessione_persona.is_text_present('Accessi'))
self.assertEqual(
1,
len(
sessione_persona.find_by_tag('tbody').find_by_css(
'tr.warning')))
def test_autorizzazioni_automatiche_scadute(self):
presidente = crea_persona()
persona, sede, app = crea_persona_sede_appartenenza(
presidente=presidente)
persona.email_contatto = email_fittizzia()
persona.save()
ora = timezone.now()
area, attivita = crea_area_attivita(sede)
domani_inizio = ora + timedelta(days=24)
domani_fine = ora + timedelta(days=180)
t1 = crea_turno(attivita, inizio=domani_inizio, fine=domani_fine)
partecipazione = crea_partecipazione(persona, t1)
attivita.centrale_operativa = Attivita.CO_AUTO
attivita.save()
self.assertEqual(0, Autorizzazione.objects.count())
partecipazione.richiedi()
self.assertNotIn(partecipazione, Partecipazione.con_esito_ok())
self.assertEqual(0, len(mail.outbox))
self.assertEqual(1, Autorizzazione.objects.count())
autorizzazione = Autorizzazione.objects.first()
self.assertNotEqual(autorizzazione.scadenza, None)
autorizzazione.scadenza = timezone.now() - timedelta(days=10)
autorizzazione.save()
self.assertFalse(autorizzazione.concessa)
Autorizzazione.gestisci_automatiche()
self.assertEqual(1, len(mail.outbox))
messaggio = mail.outbox[0]
self.assertTrue(
messaggio.subject.find(
'Richiesta di partecipazione attività RESPINTA') > -1)
self.assertFalse(
messaggio.subject.find(
'Richiesta di partecipazione attività APPROVATA') > -1)
self.assertTrue(
messaggio.body.find(
'una tua richiesta è rimasta in attesa per 30 giorni e come da policy'
) == -1)
self.assertTrue(autorizzazione.oggetto.automatica)
Autorizzazione.gestisci_automatiche()
self.assertEqual(1, len(mail.outbox))
self.assertEqual(autorizzazione.concessa, None)
self.assertIn(partecipazione, Partecipazione.con_esito_no())
def test_registrazione_doppio_click_email(self):
"""
Effettua la registrazione come aspirante, il presidente
del Comitato organizza un corso, avvisa tutti, l'aspirante trova
un corso e vi ci si iscrive.
"""
presidente = crea_persona()
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
sessione_iniziale = self.sessione_anonimo()
sessione_iniziale.click_link_by_partial_text("Iscriviti al prossimo corso base")
sessione_iniziale.fill('codice_fiscale', 'MRARSS42A01C351F')
sessione_iniziale.find_by_xpath('//button[@type="submit"]').first.click()
email = email_fittizzia()
sessione_iniziale.fill('email', email)
sessione_iniziale.fill('password', 'ciao12345')
sessione_iniziale.fill('ripeti_password', 'ciao12345')
sessione_iniziale.find_by_xpath('//button[@type="submit"]').first.click()
self.assertTrue(sessione_iniziale.is_text_present('è necessario cliccare sul link'),
msg="Invio email attivazione")
self.sessione_termina(sessione_iniziale)
# Estrazione della chiave di conferma
self.assertEqual(len(mail.outbox), 1)
body = mail.outbox[0].alternatives[0][0]
url_conferma = re.findall('/registrati/aspirante/anagrafica/\?code=\w+®istration=\w+', body)[0]
sessione_aspirante = self.sessione_anonimo()
sessione_secondo = self.sessione_anonimo()
sessione_aspirante.visit("%s%s" % (self.live_server_url, url_conferma))
self.assertTrue(sessione_aspirante.is_text_present('Parlaci un po\' di te'),
msg="Link accettato")
sessione_secondo.visit("%s%s" % (self.live_server_url, url_conferma))
self.assertEqual(len(mail.outbox), 1)
self.assertTrue(sessione_secondo.is_text_present('Errore nel processo di registrazione.'),
msg="Errore link")
def test_crea_area(self):
presidente = crea_persona()
persona, sede, appartenenza = crea_persona_sede_appartenenza(
presidente=presidente)
if not presidente.volontario:
crea_appartenenza(presidente, sede)
sessione_presidente = self.sessione_utente(persona=presidente)
#sessione_persona = self.sessione_utente(persona=persona)
# Crea area di intervento
sessione_presidente.click_link_by_partial_href("/attivita/")
sessione_presidente.click_link_by_partial_text("Aree di intervento")
sessione_presidente.click_link_by_partial_text(sede.nome)
sessione_presidente.fill('nome', "Area 42")
sessione_presidente.fill('obiettivo', '6')
sessione_presidente.find_by_xpath(
"//button[@type='submit']").first.click()
# Nomina la persona come responsabile
self.seleziona_delegato(sessione_presidente, persona)
self.assertTrue(
sessione_presidente.is_text_present("Area 42"),
"La nuova area è stata creata con successo",
)
self.assertTrue(
sessione_presidente.is_text_present(persona.nome_completo),
"La nuova area ha il responsabile assegnato",
)
self.assertTrue(
sessione_presidente.is_text_present("0 attività"),
"La nuova area non ha alcuna attività",
)
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 test_registrazione_aspirante(self):
"""
Effettua la registrazione come aspirante, il presidente
del Comitato organizza un corso, avvisa tutti, l'aspirante trova
un corso e vi ci si iscrive.
"""
presidente = crea_persona()
direttore, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
sessione_iniziale = self.sessione_anonimo()
sessione_iniziale.click_link_by_partial_text("Iscriviti al prossimo corso base")
sessione_iniziale.fill('codice_fiscale', 'MRARSS42A01C351F')
sessione_iniziale.find_by_xpath('//button[@type="submit"]').first.click()
email = email_fittizzia()
sessione_iniziale.fill('email', email)
sessione_iniziale.fill('password', 'ciao12345')
sessione_iniziale.fill('ripeti_password', 'ciao12345')
sessione_iniziale.find_by_xpath('//button[@type="submit"]').first.click()
self.assertTrue(sessione_iniziale.is_text_present('è necessario cliccare sul link'),
msg="Invio email attivazione")
self.sessione_termina(sessione_iniziale)
# Estrazione della chiave di conferma
self.assertEqual(len(mail.outbox), 1)
body = mail.outbox[0].alternatives[0][0]
url_conferma = re.findall('/registrati/aspirante/anagrafica/\?code=\w+®istration=\w+', body)[0]
sessione_aspirante = self.sessione_anonimo()
sessione_aspirante.visit("%s%s" % (self.live_server_url, url_conferma))
self.assertEqual(len(mail.outbox), 1)
sessione_aspirante.fill('nome', 'Mario')
sessione_aspirante.fill('cognome', 'Rossi Accènto')
sessione_aspirante.fill('data_nascita', '1/1/1942')
sessione_aspirante.fill('comune_nascita', 'Catania')
sessione_aspirante.fill('provincia_nascita', 'CT')
sessione_aspirante.fill('indirizzo_residenza', 'Via Etnea 353')
sessione_aspirante.fill('comune_residenza', 'Catania')
sessione_aspirante.fill('provincia_residenza', 'CT')
sessione_aspirante.fill('cap_residenza', '95128')
sessione_aspirante.find_by_xpath('//button[@type="submit"]').first.click()
self.assertTrue(sessione_aspirante.is_text_present("acconsenti al trattamento "
"dei tuoi dati personali"),
msg="Presente clausola di accettazione trattamento dei dati personali")
sessione_aspirante.find_by_xpath('//button[@type="submit"]').first.click()
self.assertTrue(sessione_aspirante.is_text_present("Ciao, Mario"),
msg="Login effettuato automaticamente")
self.assertTrue(sessione_aspirante.is_text_present(email),
msg="Indirizzo e-mail visibile e mostrato correttamente")
sede.locazione = Locazione.objects.filter(comune="Catania").first()
sede.save()
sessione_presidente = self.sessione_utente(persona=presidente)
sessione_presidente.click_link_by_partial_text("Formazione")
sessione_presidente.click_link_by_partial_text("Domanda formativa")
self.assertTrue(sessione_presidente.is_text_present("1 aspiranti"),
msg="Aspirante correttamente considerato in domanda formativa")
sessione_presidente.click_link_by_partial_text("Elenco Corsi Base")
sessione_presidente.click_link_by_partial_text("Pianifica nuovo")
sessione_presidente.select('sede', sede.pk)
sessione_presidente.find_by_xpath('//button[@type="submit"]').first.click()
self.sessione_conferma(sessione_presidente, accetta=True)
self.seleziona_delegato(sessione_presidente, direttore)
self.assertTrue(sessione_presidente.is_text_present("Corso Base pianificato"),
msg="Conferma che il corso base e' stato creato")
self.assertTrue(sessione_presidente.is_text_present(direttore.nome_completo),
msg="Il nome completo del direttore viene mostrato")
self.sessione_termina(sessione_presidente) # Non abbiamo piu' bisogno del presidente
sessione_direttore = self.sessione_utente(persona=direttore)
sessione_direttore.click_link_by_partial_text("Formazione")
sessione_direttore.click_link_by_partial_text("Elenco Corsi Base")
self.assertTrue(sessione_direttore.is_text_present("Corso Base"),
msg="Corso base in lista")
self.assertTrue(sessione_direttore.is_text_present("In preparazione"),
msg="Il corso appare con lo stato corretto")
sessione_direttore.click_link_by_partial_text("Corso Base")
self.assertTrue(sessione_direttore.is_text_present("Non c'è tempo da perdere"),
msg="Visibile promemoria corso che sta per iniziare a breve")
self.assertTrue(sessione_direttore.is_text_present("1 aspiranti"),
msg="Visibile numero di aspiranti nelle vicinanze")
sessione_direttore.click_link_by_partial_text("Gestione corso")
self.scrivi_tinymce(sessione_direttore, "descrizione", "Sarà un corso bellissimo")
sessione_direttore.find_by_xpath('//button[@type="submit"]').first.click()
sessione_direttore.click_link_by_partial_text("Attiva il corso e informa gli aspiranti")
self.assertTrue(sessione_direttore.is_text_present("Anteprima messaggio"),
msg="Anteprima del messaggio visibile")
self.assertTrue(sessione_direttore.is_text_present("Sarà un corso bellissimo"),
msg="La descrizione del corso e' nell'anteprima del messaggio")
sessione_direttore.find_by_xpath('//button[@type="submit"]').first.click()
self.sessione_conferma(sessione_direttore, accetta=True)
self.assertTrue(sessione_direttore.is_text_present("Corso attivato con successo"),
msg="Messaggio di conferma attivazione corso")
if os.environ.get('TRAVIS', 'false') == 'true':
self.skipTest('Questo test fallisce su travis senza motivo apparente')
sessione_aspirante.click_link_by_partial_text("Posta")
self.assertTrue(sessione_aspirante.is_text_present("Nuovo Corso per Volontari CRI"),
msg="E-mail di attivazione corso ricevuta")
sessione_aspirante.click_link_by_partial_text("Nuovo Corso per Volontari CRI")
self.assertTrue(sessione_aspirante.is_text_present("Sarà un corso bellissimo"),
msg="La descrizione del corso è stata comunicata per e-mail")
sessione_aspirante.visit("%s/utente/" % self.live_server_url)
sessione_aspirante.click_link_by_partial_text("Aspirante")
sessione_aspirante.click_link_by_partial_text("Elenco dei corsi nelle vicinanze")
self.assertTrue(sessione_aspirante.is_text_present(direttore.nome_completo),
msg="Il nome completo del Direttore e' visibile in elenco")
sessione_aspirante.click_link_by_partial_text("Corso Base")
sessione_aspirante.click_link_by_partial_text("Voglio iscrivermi a questo corso")
self.assertTrue(sessione_aspirante.is_text_present("Abbiamo inoltrato la tua richiesta"),
msg="Conferma data all'aspirante")
sessione_direttore.visit("%s/utente/" % self.live_server_url)
sessione_direttore.click_link_by_partial_text("Richieste")
self.assertTrue(sessione_direttore.is_text_present("chiede di essere contattato"),
msg="Esplicitare che l'aspirante vuole essere contattato")
self.assertTrue(sessione_direttore.is_text_present("Corso non ancora iniziato, impossibile processare la richiesta."),
msg="Corso non ancora iniziato, impossibile processare la richiesta.")
for corso in sede.corsobase_set.all():
corso.data_inizio = poco_fa()
corso.save()
sessione_direttore.click_link_by_partial_text("Richieste")
sessione_direttore.click_link_by_partial_text("Conferma")
sessione_direttore.check('conferma_1')
sessione_direttore.check('conferma_2')
sessione_direttore.find_by_xpath('//button[@type="submit"]').first.click()
sessione_aspirante.visit("%s/utente/" % self.live_server_url)
sessione_aspirante.click_link_by_partial_text("Aspirante")
self.assertTrue(sessione_aspirante.is_text_present("Sei iscritt"),
msg="Conferma di iscrizione")
sessione_aspirante.click_link_by_partial_text("Vai alla pagina del Corso Base")
self.assertTrue(sessione_aspirante.is_text_present("Presentati alle lezioni del corso"),
msg="Invita l'aspirante a presentarsi alle lezioni del corso")
nuove = []
for sede in sedi: # Per ogni Sede
locazione = Locazione.oggetto(
indirizzo=random.sample(COMUNI.keys(), 1)[0])
sede.locazione = locazione
sede.save()
if sede.estensione == REGIONALE:
tipi = [
Appartenenza.VOLONTARIO, Appartenenza.SOSTENITORE,
Appartenenza.ORDINARIO
]
else:
tipi = [Appartenenza.VOLONTARIO, Appartenenza.SOSTENITORE]
for membro in tipi:
for i in range(0, 25): # Creo 20 volontari
p = crea_persona()
p.comune_nascita = random.sample(COMUNI.keys(), 1)[0]
p.genere = random.choice((p.MASCHIO, p.FEMMINA))
p.indirizzo_residenza = 'Via prova 34'
p.comune_residenza = random.sample(COMUNI.keys(), 1)[0]
p.provincia_residenza = 'ZZ'
p.cap_residenza = '00100'
p.codice_fiscale = codice_fiscale_persona(p)
p.save()
nuove.append(p)
data = poco_fa() - timedelta(days=random.randint(10, 5000))
a = Appartenenza.objects.create(persona=p,
sede=sede,
inizio=data,
membro=membro)
if membro == Appartenenza.VOLONTARIO:
def test_crea_attivita(self):
presidente = crea_persona()
persona, sede, appartenenza = crea_persona_sede_appartenenza(
presidente=presidente)
if not presidente.volontario:
crea_appartenenza(presidente, sede)
area = Area(sede=sede, nome="Area 42", obiettivo=6)
area.save()
# Crea le sessioni
sessione_presidente = self.sessione_utente(persona=presidente)
sessione_persona = self.sessione_utente(persona=persona)
# Presidente: Vai a organizza attivita
sessione_presidente.click_link_by_partial_href("/attivita/")
sessione_presidente.click_link_by_partial_text("Organizza attività")
# Presidente: Riempi dettagli attivita
sessione_presidente.fill('nome', "Fine del mondo")
sessione_presidente.select('area', area.pk)
sessione_presidente.select('scelta',
ModuloOrganizzaAttivitaReferente.SONO_IO)
# Presidente: Invia il modulo
sessione_presidente.find_by_xpath(
"//button[@type='submit']").first.click()
# Presidente: Torna all'elenco attività, naviga fino a nuovo turno.
sessione_presidente.click_link_by_partial_text("Gestione turni")
sessione_presidente.click_link_by_partial_text("Crea nuovo turno")
inizio = (timezone.now()).strftime("%d/%m/%Y %H:%m")
fine = (timezone.now() +
timedelta(hours=30)).strftime("%d/%m/%Y %H:%m")
# Presidente: Riempi i dettagli del nuovo turno
sessione_presidente.fill('nome', "Vedetta")
sessione_presidente.fill('inizio', inizio)
sessione_presidente.fill('fine', fine)
sessione_presidente.fill('minimo', 1)
sessione_presidente.fill('massimo', 5)
sessione_presidente.fill('prenotazione', inizio)
sessione_presidente.execute_script(
'window.scrollTo(0, document.body.scrollHeight)')
# Presidente: Invia il modulo
sessione_presidente.find_by_css("button.btn-primary").first.click()
# Volontario: Vai in attività
sessione_persona.click_link_by_partial_text("Attività")
self.assertFalse(sessione_persona.is_text_present("Vedetta"),
msg="L'attività non è visibile.")
# Presidente: Modifica attività
sessione_presidente.click_link_by_partial_text("Elenco attività")
sessione_presidente.click_link_by_partial_text("modifica info")
sessione_presidente.click_link_by_partial_text("Gestione attività")
# Presidente: Imposta stato come VISIBILE
sessione_presidente.select('stato', Attivita.VISIBILE)
# Presidente: Invia il modulo
sessione_presidente.find_by_xpath(
"//button[@type='submit']").first.click()
# Volontario: Vai in attività
sessione_persona.click_link_by_partial_text("Attività")
self.assertTrue(sessione_persona.is_text_present("Vedetta"),
msg="L'attività è ora visibile.")
# Volontario: Clicca sul turno
sessione_persona.click_link_by_partial_text("Vedetta")
self.assertTrue(sessione_persona.is_text_present("Scoperto!"),
msg="Viene mostrata correttamente come scoperta.")
def test_richiesta_partecipazione(self):
referente = crea_persona()
volontario, sede, appartenenza = crea_persona_sede_appartenenza()
area, attivita = crea_area_attivita(sede=sede)
inizio = timezone.now() + timedelta(hours=12)
fine = inizio + timedelta(hours=2)
turno = crea_turno(attivita, inizio=inizio, fine=fine)
attivita.aggiungi_delegato(REFERENTE, referente)
# Crea le sessioni
sessione_referente = self.sessione_utente(persona=referente)
sessione_volontario = self.sessione_utente(persona=volontario)
# Volontario: Apri la pagina dell'attivita'
sessione_volontario.visit("%s%s" %
(self.live_server_url, attivita.url))
# Volontario: Apri pagina turni
sessione_volontario.click_link_by_partial_text("Turni")
# Volontario: Chiedi di partecipare
sessione_volontario.click_link_by_partial_text("Partecipa")
self.assertTrue(
sessione_volontario.is_text_present("Richiesta inoltrata"),
msg="La richiesta e stata inoltrata")
# Volontario: Apri la pagina dell'attivita', pagina turni
sessione_volontario.visit("%s%s" %
(self.live_server_url, attivita.url))
sessione_volontario.click_link_by_partial_text("Turni")
self.assertTrue(
sessione_volontario.is_text_present("Hai chiesto di partecipare"),
msg="Utente ha feedback sull'aver chiesto di partecipare")
# Volontario: Vai allo storico
sessione_volontario.click_link_by_partial_text("Miei turni")
self.assertTrue(sessione_volontario.is_text_present("In attesa"),
msg="Storico mostra stato in attesa della richiesta")
# Referente: Trova la richiesta
sessione_referente.click_link_by_partial_text("Richieste")
self.assertTrue(sessione_referente.is_text_present(
volontario.nome_completo),
msg="La richiesta mostra il nome del volontario")
self.assertTrue(sessione_referente.is_text_present(turno.nome),
msg="La richiesta mostra il nome del turno")
# Referente: Trova la richiesta
sessione_referente.click_link_by_partial_text("Conferma")
# Volontario: Vai allo storico
sessione_volontario.click_link_by_partial_text("Miei turni")
self.assertTrue(sessione_volontario.is_text_present("Approvata"),
msg="La richiesta risulta ora approvata")
# Volontario: Vai al turno
sessione_volontario.click_link_by_partial_text(turno.nome)
self.assertTrue(
sessione_volontario.is_text_present("Partecipazione confermata"),
msg="La partecipazione risulta nel turno")
