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_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_filtro_con_sede(self):
volontario_con_sede, sede, appartenenza = crea_persona_sede_appartenenza()
appartenenza.inizio = now()
appartenenza.save()
altra_sede = crea_sede()
segmento_0 = self._crea_segmento(self.file_1, 'D')
segmento_1 = self._crea_segmento(self.file_1, 'B', sede=altra_sede)
segmento_2 = self._crea_segmento(self.file_2, 'B', sede=sede)
qs = DocumentoSegmento.objects.all()
documenti = qs.filtra_per_segmenti(volontario_con_sede)
self.assertEqual(documenti.count(), 1)
self.assertEqual(set(documenti), set(DocumentoSegmento.objects.filter(pk=segmento_2.pk)))
oggetti = documenti.oggetti_collegati()
self.assertEqual(oggetti.count(), 1)
self.assertEqual(set(oggetti), set(Documento.objects.filter(pk=self.file_2.pk)))
segmento_3 = self._crea_segmento(self.file_1, 'B')
documenti = qs.filtra_per_segmenti(volontario_con_sede)
self.assertEqual(documenti.count(), 2)
self.assertEqual(set(documenti), set(DocumentoSegmento.objects.filter(pk__in=(segmento_2.pk, segmento_3.pk))))
oggetti = documenti.oggetti_collegati()
self.assertEqual(oggetti.count(), 2)
self.assertEqual(set(oggetti), set(Documento.objects.filter(pk__in=(self.file_1.pk, self.file_2.pk))))
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_filtro_con_titolo(self):
volontario_con_titolo, sede, appartenenza = crea_persona_sede_appartenenza(
)
appartenenza.inizio = now()
appartenenza.save()
titolo_personale = TitoloPersonale.objects.create(
titolo=self.titolo_patenteCRI, persona=volontario_con_titolo)
segmento_0 = self._crea_segmento(self.file_1, 'D')
segmento_1 = self._crea_segmento(self.file_1,
'AA',
titolo=self.titolo_altro)
segmento_2 = self._crea_segmento(self.file_2,
'AA',
titolo=self.titolo_patenteCRI)
qs = DocumentoSegmento.objects.all()
documenti = qs.filtra_per_segmenti(volontario_con_titolo)
self.assertEqual(documenti.count(), 1)
self.assertEqual(
set(documenti),
set(DocumentoSegmento.objects.filter(pk=segmento_2.pk)))
oggetti = documenti.oggetti_collegati()
self.assertEqual(oggetti.count(), 1)
self.assertEqual(set(oggetti),
set(Documento.objects.filter(pk=self.file_2.pk)))
def test_filtro_semplice(self):
segmento_1 = self._crea_segmento(self.file_1, 'A')
segmento_2 = self._crea_segmento(self.file_2, 'D')
volontario, sede, appartenenza = crea_persona_sede_appartenenza()
appartenenza.inizio = now()
appartenenza.save()
qs = DocumentoSegmento.objects.all()
documenti = qs.filtra_per_segmenti(volontario)
self.assertEqual(documenti.count(), 1)
self.assertEqual(
set(documenti),
set(DocumentoSegmento.objects.filter(pk=segmento_1.pk)))
oggetti = documenti.oggetti_collegati()
self.assertEqual(oggetti.count(), 1)
self.assertEqual(set(oggetti),
set(Documento.objects.filter(pk=self.file_1.pk)))
segmento_3 = self._crea_segmento(self.file_2, 'C')
documenti = qs.filtra_per_segmenti(volontario)
self.assertEqual(documenti.count(), 2)
self.assertEqual(
set(documenti),
set(
DocumentoSegmento.objects.filter(pk__in=(segmento_1.pk,
segmento_3.pk))))
oggetti = documenti.oggetti_collegati()
self.assertEqual(oggetti.count(), 2)
self.assertEqual(
set(oggetti),
set(
Documento.objects.filter(pk__in=(self.file_1.pk,
self.file_2.pk))))
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_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_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_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_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_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 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_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_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_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_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(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_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_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_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_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_messaggio_con_destinatario_vuoto(self, mock_smtp):
persona, sede, appartenenza = crea_persona_sede_appartenenza()
persona.save()
messaggio = Messaggio.costruisci_e_accoda(
destinatari=[persona],
oggetto="Email contatto",
modello="email.html",
)
messaggio._smaltisci_coda()
self.assertEqual(Messaggio.in_coda().count(), 0)
def test_messaggio_con_destinatario_vuoto(self, mock_smtp):
persona, sede, appartenenza = crea_persona_sede_appartenenza()
persona.save()
messaggio = Messaggio.costruisci_e_accoda(
destinatari=[persona],
oggetto="Email contatto",
modello="email.html",
)
messaggio.smaltisci_coda()
self.assertEqual(Messaggio.in_coda().count(), 0)
def test_autocomplete_sostentitore_aspirante(self):
direttore, sede, appartenenza = crea_persona_sede_appartenenza()
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
aspirante1.save()
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.codice_fiscale[:3]))
self.assertContains(response, aspirante1.nome_completo)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.nome_completo))
self.assertNotContains(response, aspirante1.nome_completo)
# Creiamo aspirante
aspirante2 = crea_persona()
aspirante2.email_contatto = email_fittizzia()
aspirante2.codice_fiscale = codice_fiscale()
a = Aspirante(persona=aspirante2)
a.locazione = sede.locazione
a.save()
aspirante2.save()
# Se è solo aspirante viene selezionato
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.codice_fiscale[:3]))
self.assertContains(response, aspirante1.nome_completo)
Appartenenza.objects.create(
persona=aspirante2,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
)
# Con un appartenenza come volontario non è più selezionabile
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertNotContains(response, aspirante2.nome_completo)
# Dimettiamolo
aspirante2.espelli()
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertContains(response, aspirante2.nome_completo)
# Reintegriamolo
Appartenenza.objects.create(
persona=aspirante2,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio=poco_fa(),
)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertNotContains(response, aspirante2.nome_completo)
def test_autocomplete_sostentitore_aspirante(self):
direttore, sede, appartenenza = crea_persona_sede_appartenenza()
aspirante1 = crea_persona()
aspirante1.email_contatto = email_fittizzia()
aspirante1.codice_fiscale = codice_fiscale()
a = Aspirante(persona=aspirante1)
a.locazione = sede.locazione
a.save()
aspirante1.save()
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.codice_fiscale[:3]))
self.assertContains(response, aspirante1.nome_completo)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.nome_completo))
self.assertNotContains(response, aspirante1.nome_completo)
# Creiamo aspirante
aspirante2 = crea_persona()
aspirante2.email_contatto = email_fittizzia()
aspirante2.codice_fiscale = codice_fiscale()
a = Aspirante(persona=aspirante2)
a.locazione = sede.locazione
a.save()
aspirante2.save()
# Se è solo aspirante viene selezionato
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante1.codice_fiscale[:3]))
self.assertContains(response, aspirante1.nome_completo)
Appartenenza.objects.create(
persona=aspirante2,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio="1980-12-10",
)
# Con un appartenenza come volontario non è più selezionabile
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertNotContains(response, aspirante2.nome_completo)
# Dimettiamolo
aspirante2.espelli()
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertContains(response, aspirante2.nome_completo)
# Reintegriamolo
Appartenenza.objects.create(
persona=aspirante2,
sede=sede,
membro=Appartenenza.VOLONTARIO,
inizio=poco_fa(),
)
response = self.client.get('/autocomplete/IscrivibiliCorsiAutocompletamento/?q={}'.format(aspirante2.codice_fiscale[:3]))
self.assertNotContains(response, aspirante2.nome_completo)
def test_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_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_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('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_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_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_us_attivazione_credenziali(self):
EMAIL_UTENZA = email_fittizzia()
presidente = crea_persona()
persona, sede, appartenenza = crea_persona_sede_appartenenza(presidente=presidente)
sessione_presidente = self.sessione_utente(persona=presidente)
sessione_presidente.visit("%s%s" % (self.live_server_url, persona.url_profilo_credenziali))
sessione_presidente.fill('email', EMAIL_UTENZA)
sessione_presidente.find_by_xpath("//button[@type='submit']").first.click()
self.assertTrue(
Utenza.objects.filter(persona=persona).exists(),
msg="L'utenza e' stata creata correttamente"
)
self.assertTrue(
Utenza.objects.get(persona=persona).email == EMAIL_UTENZA,
msg="L'email e' stata correttamente creata"
)
# Ottieni e-mail inviata
msg = Messaggio.objects.filter(oggetto__icontains="credenziali",
oggetti_destinatario__persona=persona)
self.assertTrue(
msg.exists(),
msg="Email delle credenziali spedita"
)
corpo_msg = msg.first().corpo
self.assertTrue(
EMAIL_UTENZA in corpo_msg,
msg="L'email contiene il nuovo indirizzo e-mail"
)
doc = html.document_fromstring(corpo_msg)
nuova_pwd = doc.xpath("//*[@id='nuova-password']")[0].text.strip()
utenza = persona.utenza
utenza.password_testing = nuova_pwd # Password per accesso
# Prova accesso con nuova utenza.
sessione_persona = self.sessione_utente(utente=utenza)
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_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_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_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_filtro_con_titolo(self):
volontario_con_titolo, sede, appartenenza = crea_persona_sede_appartenenza()
appartenenza.inizio = now()
appartenenza.save()
titolo_personale = TitoloPersonale.objects.create(
titolo=self.titolo_patenteCRI, persona=volontario_con_titolo
)
segmento_0 = self._crea_segmento(self.file_1, 'D')
segmento_1 = self._crea_segmento(self.file_1, 'AA', titolo=self.titolo_altro)
segmento_2 = self._crea_segmento(self.file_2, 'AA', titolo=self.titolo_patenteCRI)
qs = DocumentoSegmento.objects.all()
documenti = qs.filtra_per_segmenti(volontario_con_titolo)
self.assertEqual(documenti.count(), 1)
self.assertEqual(set(documenti), set(DocumentoSegmento.objects.filter(pk=segmento_2.pk)))
oggetti = documenti.oggetti_collegati()
self.assertEqual(oggetti.count(), 1)
self.assertEqual(set(oggetti), set(Documento.objects.filter(pk=self.file_2.pk)))
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 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_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 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 setUp(self):
""" Create users """
### Presidente ###
self.presidente, self.presidente_utenza = create_persona()
self.direttore, self.sede, self.appartenenza = crea_persona_sede_appartenenza(
presidente=self.presidente)
### Aspirante ###
self.aspirante1 = create_aspirante(sede=self.sede)
self.aspirante2 = create_aspirante(sede=self.sede)
### Volontario ###
self.volontario = None
""" Create a new courses tipo CORSO_NUOVO """
data_inizio = datetime.datetime.now() + timedelta(days=14)
self.c1 = create_course(data_inizio, self.sede) # corso_1_ext_mia_sede
self.c2 = create_course(data_inizio,
self.sede,
extension_type=CorsoBase.EXT_LVL_REGIONALE
) # corso_2_ext_a_livello_regionale
self.c3 = create_course(data_inizio, self.sede, tipo=Corso.BASE)
""" Create titles """
""" Create extensions """
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_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_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_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")
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")
def test_articolo(self):
CONTENUTO_1 = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.\n"
NOME_1 = 'Test1.txt'
CONTENUTO_2 = "Donec tempus nisi eu enim consequat, non scelerisque nisi accumsan.\n"
NOME_2 = 'Test/Test2.txt'
volontario, _, _ = crea_persona_sede_appartenenza()
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()
articolo = Articolo.objects.create(
titolo='Titolo 1',
corpo=parola_casuale(3000),
data_inizio_pubblicazione=datetime.datetime.now() -
datetime.timedelta(days=5),
)
self.assertEqual(articolo.corpo[:Articolo.DIMENSIONE_ESTRATTO],
articolo.estratto)
self.assertFalse(articolo.termina)
articolo2 = Articolo.objects.create(
titolo='Titolo 2',
corpo='Testo random',
estratto='estratto qualsiasi',
data_inizio_pubblicazione=datetime.datetime.now() -
datetime.timedelta(days=5),
data_fine_pubblicazione=datetime.datetime.now() +
datetime.timedelta(days=5),
stato=Articolo.PUBBLICATO)
segmento_presidenti_no_filtri = ArticoloSegmento.objects.create(
segmento='I',
articolo=articolo2,
)
self.assertNotEqual(articolo2.corpo, articolo2.estratto)
self.assertEqual(articolo2.estratto, 'estratto qualsiasi')
self.assertTrue(articolo2.termina)
articolo3 = Articolo.objects.create(
titolo='Titolo 3',
corpo='Testo qualsiasi',
estratto='estratto random',
data_inizio_pubblicazione=datetime.datetime.now() -
datetime.timedelta(days=5),
stato=Articolo.PUBBLICATO)
segmento_volontari_no_filtri = ArticoloSegmento.objects.create(
segmento='B', articolo=articolo3)
z = Zip(oggetto=articolo3)
f1 = NamedTemporaryFile(delete=False, mode='wt')
f1.write(CONTENUTO_1)
f1.close()
z.aggiungi_file(f1.name, NOME_1)
z.comprimi_e_salva(nome='TestZip.zip')
self.assertEqual(1, articolo3.allegati.all().count())
self.assertIn(z, articolo3.allegati.all())
articolo4 = Articolo.objects.create(
titolo='Titolo 4',
corpo='Testo qualsiasi 2',
estratto='estratto random 2',
data_inizio_pubblicazione=datetime.datetime.now() -
datetime.timedelta(days=5),
data_fine_pubblicazione=datetime.datetime.now() -
datetime.timedelta(days=2),
stato=Articolo.PUBBLICATO)
pubblicati = Articolo.objects.pubblicati()
bozze = Articolo.objects.bozze()
self.assertEqual(pubblicati.count(), 2)
self.assertEqual(bozze.count(), 1)
self.assertIn(articolo, bozze)
self.assertNotIn(articolo, pubblicati)
self.assertNotIn(articolo2, bozze)
self.assertIn(articolo2, pubblicati)
self.assertNotIn(articolo3, bozze)
self.assertIn(articolo3, pubblicati)
self.assertNotIn(articolo4, bozze)
self.assertNotIn(articolo4, pubblicati)
segmenti_volontario = ArticoloSegmento.objects.all(
).filtra_per_segmenti(volontario)
articoli_volontario = segmenti_volontario.oggetti_collegati()
self.assertNotIn(articolo2, articoli_volontario)
self.assertIn(articolo3, articoli_volontario)
segmenti_presidente = ArticoloSegmento.objects.all(
).filtra_per_segmenti(presidente)
articoli_presidente = segmenti_presidente.oggetti_collegati()
self.assertIn(articolo2, articoli_presidente)
self.assertIn(articolo3, articoli_presidente)
def test_lista_articoli(self):
articolo = Articolo.objects.create(
titolo='Titolo 1981',
corpo='Testo random 1',
estratto='qualcosa',
data_inizio_pubblicazione='1981-12-10',
stato=Articolo.PUBBLICATO)
articolo2 = Articolo.objects.create(
titolo='Titolo primo 1980',
corpo='Testo random 2',
estratto='un pezzo',
data_inizio_pubblicazione='1980-06-10',
stato=Articolo.PUBBLICATO)
articolo3 = Articolo.objects.create(
titolo='Titolo secondo 1980',
corpo='Testo random 3',
estratto='una parte',
data_inizio_pubblicazione='1980-12-10',
stato=Articolo.PUBBLICATO)
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.assertFalse(
sessione_persona.is_text_present(
'Non è stato trovato alcun articolo'))
self.assertTrue(sessione_persona.is_text_present(articolo.titolo))
self.assertTrue(sessione_persona.is_text_present(articolo.estratto))
self.assertTrue(sessione_persona.is_text_present(articolo2.titolo))
self.assertTrue(sessione_persona.is_text_present(articolo2.estratto))
self.assertTrue(sessione_persona.is_text_present(articolo3.titolo))
self.assertTrue(sessione_persona.is_text_present(articolo3.estratto))
self.assertEqual(
3, len(sessione_persona.find_by_css('.panel.panel-primary')))
sessione_persona.fill('q', 'primo')
sessione_persona.find_by_xpath(
'//button[@type="submit"]').first.click()
self.assertEqual(
1, len(sessione_persona.find_by_css('.panel.panel-primary')))
self.assertFalse(sessione_persona.is_text_present(articolo.titolo))
self.assertFalse(sessione_persona.is_text_present(articolo.estratto))
self.assertTrue(sessione_persona.is_text_present(articolo2.titolo))
self.assertTrue(sessione_persona.is_text_present(articolo2.estratto))
self.assertFalse(sessione_persona.is_text_present(articolo3.titolo))
self.assertFalse(sessione_persona.is_text_present(articolo3.estratto))
sessione_persona.find_by_xpath(
'//select[@name="anno"]//option[@value="1980"]').first.click()
sessione_persona.find_by_xpath(
'//button[@type="submit"]').first.click()
self.assertEqual(
1, len(sessione_persona.find_by_css('.panel.panel-primary')))
self.assertFalse(sessione_persona.is_text_present(articolo.titolo))
self.assertFalse(sessione_persona.is_text_present(articolo.estratto))
self.assertTrue(sessione_persona.is_text_present(articolo2.titolo))
self.assertTrue(sessione_persona.is_text_present(articolo2.estratto))
self.assertFalse(sessione_persona.is_text_present(articolo3.titolo))
self.assertFalse(sessione_persona.is_text_present(articolo3.estratto))
sessione_persona.fill('q', '')
sessione_persona.find_by_xpath(
'//select[@name="anno"]//option[@value="1980"]').first.click()
sessione_persona.find_by_xpath(
'//button[@type="submit"]').first.click()
self.assertEqual(
2, len(sessione_persona.find_by_css('.panel.panel-primary')))
self.assertFalse(sessione_persona.is_text_present(articolo.titolo))
self.assertFalse(sessione_persona.is_text_present(articolo.estratto))
self.assertTrue(sessione_persona.is_text_present(articolo2.titolo))
self.assertTrue(sessione_persona.is_text_present(articolo2.estratto))
self.assertTrue(sessione_persona.is_text_present(articolo3.titolo))
self.assertTrue(sessione_persona.is_text_present(articolo3.estratto))
sessione_persona.find_by_xpath(
'//select[@name="anno"]//option[@value="1980"]').first.click()
sessione_persona.find_by_xpath(
'//select[@name="mese"]//option[@value=6]').first.click()
sessione_persona.find_by_xpath(
'//button[@type="submit"]').first.click()
self.assertEqual(
1, len(sessione_persona.find_by_css('.panel.panel-primary')))
self.assertFalse(sessione_persona.is_text_present(articolo.titolo))
self.assertFalse(sessione_persona.is_text_present(articolo.estratto))
self.assertTrue(sessione_persona.is_text_present(articolo2.titolo))
self.assertTrue(sessione_persona.is_text_present(articolo2.estratto))
self.assertFalse(sessione_persona.is_text_present(articolo3.titolo))
self.assertFalse(sessione_persona.is_text_present(articolo3.estratto))
sessione_persona.find_link_by_partial_text(
'Continua a leggere').first.click()
self.assertFalse(sessione_persona.is_text_present(articolo.titolo))
self.assertFalse(sessione_persona.is_text_present(articolo.corpo))
self.assertTrue(sessione_persona.is_text_present(articolo2.titolo))
self.assertTrue(sessione_persona.is_text_present(articolo2.corpo))
self.assertFalse(sessione_persona.is_text_present(articolo3.titolo))
self.assertFalse(sessione_persona.is_text_present(articolo3.corpo))
self.assertTrue(sessione_persona.is_text_present('Letture'))
def test_list_segmenti(self):
volontario_con_titolo, _, _ = crea_persona_sede_appartenenza()
# Notizie di test
notizia_1 = NotiziaTest.objects.create(
testo="Notizia 1: Testo di prova!")
notizia_2 = NotiziaTest.objects.create(
testo="Notizia 2: Altro testo di prova!")
# SEGMENTI NOTIZIA_1
# Segmento per filtrare tutti gli utenti
segmento_tutti_no_filtri = NotiziaTestSegmento.objects.create(
segmento='A', notiziatest=notizia_1)
# Segmento per filtrare tutti i volontari
segmento_volontari_no_filtri = NotiziaTestSegmento.objects.create(
segmento='B', notiziatest=notizia_1)
# Segmento per filtrare tutti i volontari con meno di un anno di attivita
segmento_volontari_meno_uno_no_filtri = NotiziaTestSegmento.objects.create(
segmento='C', notiziatest=notizia_1)
# Segmento per filtrare tutti i volontari con più di un anno di attivita
segmento_volontari_piu_uno_no_filtri = NotiziaTestSegmento.objects.create(
segmento='D', notiziatest=notizia_1)
# Segmento per filtrare tutti i volontari con meno di 35 anni
segmento_volontari_meno_35_anni_no_filtri = NotiziaTestSegmento.objects.create(
segmento='E', notiziatest=notizia_1)
# Segmento per filtrare tutti i volontari con meno di 35 anni
segmento_volontari_35_anni_o_piu_no_filtri = NotiziaTestSegmento.objects.create(
segmento='F', notiziatest=notizia_1)
# Segmento per filtrare tutti i sostenitori
segmento_sostenitori_no_filtri = NotiziaTestSegmento.objects.create(
segmento='G', notiziatest=notizia_1)
# Segmento per filtrare tutti i sostenitori
segmento_aspiranti_corsisti_no_filtri = NotiziaTestSegmento.objects.create(
segmento='H', notiziatest=notizia_1)
# Segmento per filtrare tutti i presidenti con delega attiva
segmento_presidenti_no_filtri = NotiziaTestSegmento.objects.create(
segmento='I', notiziatest=notizia_1)
# Segmento per filtrare tutti i presidenti di comitati locali con delega attiva
segmento_presidenti_comitati_locali_no_filtri = NotiziaTestSegmento.objects.create(
segmento='J', notiziatest=notizia_1)
# Segmento per filtrare tutti i presidenti di comitati regionali con delega attiva
segmento_presidenti_comitati_regionali_no_filtri = NotiziaTestSegmento.objects.create(
segmento='K', notiziatest=notizia_1)
# Segmento per filtrare tutti i delegati Ufficio Soci con delega attiva
segmento_delegati_US_no_filtri = NotiziaTestSegmento.objects.create(
segmento='L', notiziatest=notizia_1)
# Segmento per filtrare tutti i delegati Autoparco con delega attiva
segmento_delegati_autoparco_no_filtri = NotiziaTestSegmento.objects.create(
segmento='Y', notiziatest=notizia_1)
# Segmento per filtrare tutti i delegati Formazione con delega attiva
segmento_delegati_formazione_no_filtri = NotiziaTestSegmento.objects.create(
segmento='Z', notiziatest=notizia_1)
# Segmento per filtrare tutti i volontari con titolo
titolo_patenteCRI = Titolo.objects.create(tipo='PC',
nome='Titolo test')
segmento_volontari_con_titolo_no_filtri = NotiziaTestSegmento.objects.create(
segmento='AA', notiziatest=notizia_1, titolo=titolo_patenteCRI)
qs = NotiziaTestSegmento.objects.all()
risultato = qs.filtra_per_segmenti(volontario_con_titolo)
attesi = [
segmento_tutti_no_filtri, segmento_volontari_no_filtri,
segmento_volontari_meno_uno_no_filtri,
segmento_volontari_meno_35_anni_no_filtri
]
self.assertEqual(set(risultato), set(attesi))
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 = []
