def setUp(self):
self.crear_arbol()
grupo3 = Grupo.objects.get(id=300)
self.grupo = Grupo.objects.get(id=500)
self.lider1 = MiembroFactory(lider=True, grupo=grupo3)
self.lider2 = MiembroFactory(lider=True, grupo=grupo3)
self.barrio = BarrioFactory()
def setUp(self):
self.crear_arbol()
grupo3 = Grupo.objects.get(id=300)
self.padre = Grupo.objects.get(id=800)
self.lider1 = MiembroFactory(lider=True, grupo=grupo3)
self.lider2 = MiembroFactory(lider=True, grupo=self.padre)
self.barrio = BarrioFactory()
self.red_jovenes = Red.objects.get(nombre='jovenes')
def setUp(self):
self.crear_arbol()
self.admin = UsuarioFactory(admin=True)
self.padre = Grupo.objects.get(id=800)
self.lider1 = MiembroFactory(lider=True, grupo=self.padre)
self.lider2 = MiembroFactory(lider=True, grupo=self.padre)
self.barrio = BarrioFactory()
Red.objects.get(nombre='jovenes')
def setUp(self):
self.crear_arbol()
grupo3 = Grupo.objects.get(id=300)
self.padre = Grupo.objects.get(id=800)
self.lider1 = MiembroFactory(lider=True, grupo=grupo3)
self.lider2 = MiembroFactory(lider=True, grupo=self.padre)
self.barrio = BarrioFactory()
self.red_jovenes = Red.objects.get(nombre='jovenes')
self.url = reverse('common:busqueda_miembro_api', args=(self.red_jovenes.id, ))
def datos_pruebas(self):
self.crear_arbol()
grupo = Grupo.objects.get(id=400)
self.lider.grupo_lidera = grupo
self.lider.save()
grupo2 = Grupo.objects.get(id=700)
self.miembro_red = MiembroFactory(grupo=grupo2)
self.lider_red = grupo2.lideres.first()
self.miembro_no_red = MiembroFactory(nombre='maria')
self.lider_no_red = Grupo.objects.get(id=300).lideres.first()
def test_get_buscar_todos_miembros(self):
"""
Prueba el buscador de miembros cuando el usuario tiene permiso de buscar todos.
"""
MiembroFactory(nombre='adriana', primer_apellido='mendoza')
MiembroFactory(nombre='maria', primer_apellido='fernandez')
self.login_usuario(self.usuario)
response = self.client.get(self.URL_MIEMBROS, self.termino_busqueda())
self.assertContains(response, 'adriana'.upper())
self.assertContains(response, 'fernandez'.upper())
def test_campo_lideres_solo_muestra_lideres_red_ingresada(self):
"""
Prueba que el campo lideres solo muestra lideres que pertenecen a los grupos de la red ingresada.
"""
grupo1 = Grupo.objects.get(id=300)
lider_joven = MiembroFactory(lider=True, grupo=grupo1)
grupo2 = Grupo.objects.get(id=400)
otro_lider = MiembroFactory(lider=True, grupo=grupo2)
form = NuevoGrupoForm(red=self.red_jovenes)
self.assertIn(lider_joven, form.fields['lideres'].queryset)
self.assertNotIn(otro_lider, form.fields['lideres'].queryset)
def test_fusionar_traslada_miembros(self):
"""
Prueba que se trasladen todas los miembros asociados al grupo que se esta fusionando con el nuevo grupo.
"""
grupo = Grupo.objects.get(id=500)
nuevo_grupo = Grupo.objects.get(id=800)
miembro1 = MiembroFactory(grupo=grupo)
miembro2 = MiembroFactory(grupo=grupo, admin=True)
grupo.fusionar(nuevo_grupo)
miembros = nuevo_grupo.miembros.all()
self.assertIn(miembro1, miembros)
self.assertIn(miembro2, miembros)
def test_grupo_by_solo_muestra_lideres_disponibles_debajo_de_grupo(self):
"""
Prueba que a partir de el campo de grupo_by, solo sean mostrados los lideres disponibles que se encuentran
por debajo de ese grupo.
"""
grupo = Grupo.objects.get(id=300)
grupo_lider_disponible = Grupo.objects.get(id=700)
lider_disponible_1 = MiembroFactory(lider=True, grupo=grupo_lider_disponible)
lider_disponible_2 = MiembroFactory(lider=True, grupo=grupo)
response = self.POST(data={'value': lider_disponible_1.nombre[0:5], 'grupo_by': grupo.id})
self.assertNotIn(str(lider_disponible_1), [x['id'] for x in response['miembros']])
response = self.POST(data={'value': lider_disponible_2.nombre[0:5], 'grupo_by': grupo.id})
self.assertIn(str(lider_disponible_2.id), [x['id'] for x in response['miembros']])
def test_campo_lideres_solo_muestra_lideres(self):
"""
Prueba que el campo lideres solo se muestren miembros que sean lideres.
"""
no_lider = MiembroFactory()
form = GrupoRaizForm()
self.assertNotIn(no_lider, form.fields['lideres'].queryset)
def test_busqueda_solo_muestra_lideres(self):
"""
Prueba que en la busqueda solo se muestren miembros que sean lideres.
"""
no_lider = MiembroFactory()
response = self.POST(data={'value': no_lider.nombre[0:5]})
self.assertEqual(response['miembros'].__len__(), 0)
lider = MiembroFactory(lider=True, grupo=Grupo.objects.red(self.red_jovenes)[0])
response = self.POST(data={'value': lider.nombre[0:5]})
self.assertIn('id', response['miembros'][0])
# self.assertEqual(str(response['miembros'][0]['id']), str(lider.id))
self.assertIn(str(lider.id), [x['id'] for x in response['miembros']])
def test_campo_lideres_solo_muestra_lideres_red_ingresada(self):
"""
Prueba que el campo lideres solo muestra lideres que pertenecen a los grupos de la red ingresada.
"""
grupo1 = Grupo.objects.get(id=200)
lider_joven = MiembroFactory(lider=True, grupo=grupo1, nombre='asdfder')
response = self.POST(data={'value': lider_joven.nombre[0:5]})
self.assertEqual(response['miembros'].__len__(), 0)
def test_campo_lideres_solo_muestra_lideres_sin_grupo(self):
"""
Prueba que en el campo lideres solo se muestren miembros que sean lideres que no lideren grupo.
"""
grupo = Grupo.objects.get(id=300)
lider_sin_grupo = MiembroFactory(lider=True, grupo=grupo)
form = NuevoGrupoForm(red=self.red_jovenes)
self.assertNotIn(grupo.lideres.first(), form.fields['lideres'].queryset)
self.assertIn(lider_sin_grupo, form.fields['lideres'].queryset)
def test_lider_sin_grupo_devuelve_403(self):
"""
Prueba que si el usuario no lidera grupo y no tiene el permiso buscar_todos devuelva permiso denegado.
"""
grupo = GrupoFactory()
lider = MiembroFactory(lider=True)
self.login_usuario(lider.usuario)
response = self.client.get(reverse(self.URL_NAME, args=[grupo.id]))
self.assertEqual(response.status_code, 403)
def test_campo_lideres_solo_muestra_lideres_sin_grupo(self):
"""
Prueba que en el campo lideres solo se muestren miembros que sean lideres que no lideren grupo.
"""
grupo = GrupoFactory()
lider_sin_grupo = MiembroFactory(lider=True)
form = GrupoRaizForm()
self.assertNotIn(grupo.lideres.first(), form.fields['lideres'].queryset)
self.assertIn(lider_sin_grupo, form.fields['lideres'].queryset)
def test_modificar_lideres_raiz(self):
"""
Prueba que cuando se editen los lideres del grupo raiz, se les coloque a los lideres nuevos el grupo raiz como
su grupo que lidera y a los lideres que se cambiaron se les quite.
"""
raiz = GrupoRaizFactory()
lider3 = MiembroFactory(lider=True, grupo_lidera=raiz)
lideres_viejos = list(raiz.lideres.values_list('id', flat=True))
data = self.datos_formulario()
data['lideres'].append(lider3.id)
form = GrupoRaizForm(instance=raiz, data=data)
form.save()
lider3.refresh_from_db()
self.lider1.refresh_from_db()
self.lider2.refresh_from_db()
self.assertEqual(lider3.grupo_lidera, raiz)
self.assertEqual(self.lider1.grupo_lidera, raiz)
self.assertEqual(self.lider2.grupo_lidera, raiz)
self.assertEqual(len(raiz.lideres.filter(id__in=lideres_viejos)), 1)
def test_discipulos_devuelve_solo_miembros_grupo_son_lideres(self):
"""
Prueba que los discipulos obtenidos son los miembros del grupo que son lideres.
"""
grupo = Grupo.objects.get(id=300)
miembro = MiembroFactory(grupo=grupo)
lider = Grupo.objects.get(id=500).lideres.first()
otro_lider = Grupo.objects.get(id=200).lideres.first()
discipulos = list(grupo.discipulos)
self.assertIn(lider, discipulos)
self.assertNotIn(miembro, discipulos)
self.assertNotIn(otro_lider, discipulos)
def test_campo_lideres_muestra_lideres_raiz_si_red_no_tiene_grupo(self):
"""
Prueba que el campo lideres muestre los lideres disponibles que asisten al grupo raiz de una iglesia si la red
ingresada no tiene ningún grupo.
"""
raiz = Grupo.objects.get(id=100)
otro = Grupo.objects.get(id=300)
red_nueva = RedFactory(nombre='nueva red')
miembro = MiembroFactory(lider=True, grupo=raiz)
form = NuevoGrupoForm(red=red_nueva)
self.assertIn(miembro, form.fields['lideres'].queryset)
self.assertNotIn(otro.lideres.first(), form.fields['lideres'].queryset)
def test_redireccion_si_cabeza_red_no_entra_a_su_red(self):
"""
Verifica que el usuario, si es cabeza de red y no entra a crear un grupo de su red, sea redireccionado.
"""
grupo = Grupo.objects.get(id=300)
cabeza_red = MiembroFactory(lider=True,
grupo=grupo,
grupo_lidera=self.padre)
otra_red = RedFactory(nombre='nueva red')
red = self.padre.red
self.assertTrue(cabeza_red.es_cabeza_red)
self.login_usuario(cabeza_red.usuario)
response = self.get(self.URL, pk=otra_red.id)
self.assertRedirects(response, self.reverse(self.URL, pk=red.id))
def test_grupos_listados_sean_red_de_cabeza_red(self):
"""
Verifica que los grupos que sean listados sean de la red del cabeza de red, y no de otra red.
"""
grupo = Grupo.objects.get(id=300)
padre = Grupo.objects.get(id=800)
otro_grupo = Grupo.objects.get(id=500)
red_jovenes = Red.objects.get(nombre='jovenes')
cabeza_red = MiembroFactory(lider=True,
grupo=grupo,
grupo_lidera=padre)
self.assertTrue(cabeza_red.es_cabeza_red)
self.login_usuario(cabeza_red.usuario)
self.get(self.URL, pk=red_jovenes.id)
self.assertResponseNotContains(str(otro_grupo), html=False)
self.assertResponseContains(str(padre), html=False)
def test_campo_lideres_muestra_lideres_raiz_si_red_no_tiene_grupo(self):
"""
Prueba que el campo lideres muestre los lideres disponibles que asisten al grupo raiz de la iglesia si la red
ingresada no tiene ningún grupo.
"""
raiz = Grupo.objects.get(id=100)
otro = Grupo.objects.get(id=300)
red_nueva = RedFactory(nombre='nueva red')
miembro = MiembroFactory(lider=True, grupo=raiz)
url = reverse('common:busqueda_miembro_api', args=(red_nueva.id, ))
response = self.POST(url=url, data={'value': miembro.nombre[0:5]})
self.assertEqual(str(response['miembros'][0]['id']), miembro.id.__str__())
for m in response['miembros']:
self.assertNotEqual(str(otro.lideres.first().id), str(m['id']))
class EditarGrupoFormTest(BaseTest):
"""
Pruebas unitarias para el formulario de edición de grupos de una iglesia.
"""
def setUp(self):
self.crear_arbol()
grupo3 = Grupo.objects.get(id=300)
self.grupo = Grupo.objects.get(id=500)
self.lider1 = MiembroFactory(lider=True, grupo=grupo3)
self.lider2 = MiembroFactory(lider=True, grupo=grupo3)
self.barrio = BarrioFactory()
def datos_formulario(self):
"""
Retorna un diccionario con datos para el formulario.
"""
data = {
'direccion': 'Calle 34 N 74 - 23', 'estado': 'AC', 'fechaApertura': '2012-03-03', 'diaGAR': '1',
'horaGAR': '12:00', 'diaDiscipulado': '3', 'horaDiscipulado': '16:00', 'nombre': 'Pastor presidente',
'barrio': self.barrio.id, 'lideres': [self.lider1.id, self.lider2.id], 'parent': '300'
}
return data
def test_campo_parent_muestra_padre_del_grupo_seleccionado(self):
"""
Prueba que en el campo parent se muestre el padre del grupo que se esta editando.
"""
form = EditarGrupoForm(instance=self.grupo)
self.assertIn(self.grupo.parent, form.fields['parent'].queryset)
@skip
def test_campo_parent_no_muestra_grupos_esten_debajo_de_grupo_seleccionado(self):
"""
Prueba que en el campo parent no se muestren los grupos que se encuentren debajo del grupo seleccionado ni el
grupo seleccionado.
"""
descendiente = Grupo.objects.get(id=600)
form = EditarGrupoForm(instance=self.grupo)
self.assertNotIn(self.grupo, form.fields['parent'].queryset)
self.assertNotIn(descendiente, form.fields['parent'].queryset)
@skip
def test_campo_parent_muestra_raiz_si_padre_grupo_seleccionado_es_raiz(self):
"""
Prueba que el campo padre muestre el grupo raiz de una iglesia si el padre del grupo seleccionado es la raiz.
"""
raiz = Grupo.objects.get(id=100)
seleccionado = Grupo.objects.get(id=300)
form = EditarGrupoForm(instance=seleccionado)
self.assertIn(raiz, form.fields['parent'].queryset)
def test_campo_lideres_muestra_lideres_del_grupo_escogido(self):
"""
Prueba que en el campo lideres muestren los lideres del grupo que se esta editando.
"""
form = EditarGrupoForm(instance=self.grupo)
self.assertIn(self.grupo.lideres.first(), form.fields['lideres'].queryset)
def test_formulario_edita_grupo(self):
form = EditarGrupoForm(instance=self.grupo, data=self.datos_formulario())
form.save()
self.lider1.refresh_from_db()
self.assertEqual(self.lider1.grupo_lidera, self.grupo)
@mock.patch('django.db.models.query.QuerySet.update', side_effect=IntegrityError)
def test_error_al_guardar_formulario_no_se_guarda_nada_en_db(self, update_mock):
"""
Prueba que si ocurre un error al guardar el formulario no se guarde ni el grupo ni los lideres.
"""
form = EditarGrupoForm(instance=self.grupo, data=self.datos_formulario())
form.save()
self.lider1.refresh_from_db()
self.lider2.refresh_from_db()
self.assertTrue(update_mock.called)
self.assertEqual(self.lider1.grupo_lidera, None)
self.assertEqual(self.lider2.grupo_lidera, None)
@mock.patch('django.db.models.query.QuerySet.update', side_effect=IntegrityError)
def test_error_al_guardar_formulario_agrega_error_form(self, update_mock):
"""
Prueba que si ocurre un error al momento de guardar el formulario, se agregue un error al formulario.
"""
form = EditarGrupoForm(instance=self.grupo, data=self.datos_formulario())
form.save()
self.assertTrue(update_mock.called)
self.assertEqual(len(form.non_field_errors()), 1)
def setUp(self):
self.usuario = UsuarioFactory(user_permissions=['buscar_todos'])
self.lider = MiembroFactory(lider=True, nombre='mariana')
class BuscarViewTest(BaseTest):
"""
Pruebas unitarias para la vista de busqueda de miembros y grupos.
"""
URL_MIEMBROS = reverse('buscar', args=['miembro'])
URL_GRUPOS = reverse('buscar', args=['grupo'])
def setUp(self):
self.usuario = UsuarioFactory(user_permissions=['buscar_todos'])
self.lider = MiembroFactory(lider=True, nombre='mariana')
def termino_busqueda(self, termino='adriana fernandez'):
return {'buscar': termino}
def test_get_buscar_todos_miembros(self):
"""
Prueba el buscador de miembros cuando el usuario tiene permiso de buscar todos.
"""
MiembroFactory(nombre='adriana', primer_apellido='mendoza')
MiembroFactory(nombre='maria', primer_apellido='fernandez')
self.login_usuario(self.usuario)
response = self.client.get(self.URL_MIEMBROS, self.termino_busqueda())
self.assertContains(response, 'adriana'.upper())
self.assertContains(response, 'fernandez'.upper())
def test_get_buscar_todos_grupos(self):
"""
Prueba el buscador de grupos cuando el usuario tiene permiso de buscar todos.
"""
grupo1 = GrupoFactory(lider__nombre='adriana',
lider__primer_apellido='mendoza',
nombre='mendoza')
grupo2 = GrupoFactory(lider__nombre='maria',
lider__primer_apellido='fernandez',
nombre='fernandez')
self.login_usuario(self.usuario)
response = self.client.get(self.URL_GRUPOS, self.termino_busqueda())
self.assertContains(response, grupo1.nombre.upper())
self.assertContains(response, grupo2.nombre.upper())
def datos_pruebas(self):
self.crear_arbol()
grupo = Grupo.objects.get(id=400)
self.lider.grupo_lidera = grupo
self.lider.save()
grupo2 = Grupo.objects.get(id=700)
self.miembro_red = MiembroFactory(grupo=grupo2)
self.lider_red = grupo2.lideres.first()
self.miembro_no_red = MiembroFactory(nombre='maria')
self.lider_no_red = Grupo.objects.get(id=300).lideres.first()
def test_get_lider_sin_grupo_buscar_miembros(self):
"""
Prueba que cuando el lider no tenga el permiso buscar_todos y no lidere grupo la busqueda no devuelva
resultados.
"""
self.login_usuario(self.lider.usuario)
response = self.client.get(self.URL_MIEMBROS, self.termino_busqueda())
self.assertContains(response, 'No se encontraron resultados')
def test_get_lider_sin_grupo_buscar_grupos(self):
"""
Prueba que cuando el lider no tenga el permiso buscar_todos y no lidere grupo la busqueda no devuelva
resultados.
"""
self.login_usuario(self.lider.usuario)
response = self.client.get(self.URL_GRUPOS, self.termino_busqueda())
self.assertContains(response, 'No se encontraron resultados')
def test_get_lider_buscar_miembros(self):
"""
Prueba que cuando el lider no tenga el permiso buscar_todos solo puede buscar miembros entre sus descendientes.
"""
self.datos_pruebas()
termino = 'maria {0} {1} {2}'.format(self.lider_red.primer_apellido,
self.miembro_red.nombre,
self.lider_no_red.nombre)
self.login_usuario(self.lider.usuario)
response = self.client.get(self.URL_MIEMBROS,
self.termino_busqueda(termino=termino))
self.assertContains(response, self.miembro_red.cedula)
self.assertContains(response, self.lider_red.cedula)
self.assertContains(response, self.lider.cedula)
self.assertNotContains(response, self.miembro_no_red.cedula)
self.assertNotContains(response, self.lider_no_red.cedula)
def test_get_lider_buscar_grupos(self):
"""
Prueba que cuando lider no tenga el permiso buscar_todos solo pueda buscar grupos entre sus descendientes.
"""
self.datos_pruebas()
termino = 'maria {0} {1} {2}'.format(self.lider_red.primer_apellido,
self.miembro_red.nombre,
self.lider_no_red.nombre)
self.login_usuario(self.lider.usuario)
response = self.client.get(self.URL_GRUPOS,
self.termino_busqueda(termino=termino))
self.assertContains(response, self.lider_red.cedula)
self.assertContains(response, self.lider.cedula)
self.assertNotContains(response, self.lider_no_red.cedula)
def setUp(self):
self.lider1 = MiembroFactory(lider=True)
self.lider2 = MiembroFactory(lider=True)
self.barrio = BarrioFactory()
class GrupoRaizFormTest(BaseTest):
"""
Pruebas unitarias para el formulario de creación y/o edición del grupo raiz.
"""
def setUp(self):
self.lider1 = MiembroFactory(lider=True)
self.lider2 = MiembroFactory(lider=True)
self.barrio = BarrioFactory()
def datos_formulario(self):
"""
Retorna un diccionario con datos para el formulario GrupoRaiz.
"""
data = {
'direccion': 'Calle 34 N 74 - 23', 'estado': 'AC', 'fechaApertura': '2012-03-03', 'diaGAR': '1',
'horaGAR': '12:00', 'diaDiscipulado': '3', 'horaDiscipulado': '16:00', 'nombre': 'Pastor presidente',
'barrio': self.barrio.id, 'lideres': [self.lider1.id, self.lider2.id]
}
return data
def test_campo_lideres_solo_muestra_lideres(self):
"""
Prueba que el campo lideres solo se muestren miembros que sean lideres.
"""
no_lider = MiembroFactory()
form = GrupoRaizForm()
self.assertNotIn(no_lider, form.fields['lideres'].queryset)
def test_campo_lideres_solo_muestra_lideres_sin_grupo(self):
"""
Prueba que en el campo lideres solo se muestren miembros que sean lideres que no lideren grupo.
"""
grupo = GrupoFactory()
lider_sin_grupo = MiembroFactory(lider=True)
form = GrupoRaizForm()
self.assertNotIn(grupo.lideres.first(), form.fields['lideres'].queryset)
self.assertIn(lider_sin_grupo, form.fields['lideres'].queryset)
def test_campo_lideres_muestra_lideres_del_grupo_raiz(self):
"""
Prueba que en el campo lideres muestren los lideres del grupo raiz.
"""
raiz = GrupoRaizFactory()
form = GrupoRaizForm(instance=raiz)
self.assertIn(raiz.lideres.first(), form.fields['lideres'].queryset)
def test_formulario_crea_raiz_se_asigna_grupo_a_lideres_escogidos(self):
"""
Prueba que cuando se guarde el formulario se crea el grupo raiz sino existe y es asignado a los lideres
escogidos.
"""
form = GrupoRaizForm(data=self.datos_formulario())
raiz = form.save()
self.lider1.refresh_from_db()
self.lider2.refresh_from_db()
self.assertEqual(len(Grupo.get_root_nodes()), 1)
self.assertEqual(self.lider1.grupo_lidera, raiz)
self.assertEqual(self.lider2.grupo_lidera, raiz)
def test_formulario_no_crea_nueva_raiz_si_ya_existe(self):
"""
Prueba que cuando se guarde el formulario no se cree un nuevo grupo raiz si ya existe.
"""
raiz = GrupoRaizFactory()
form = GrupoRaizForm(instance=raiz, data=self.datos_formulario())
form.save()
self.assertEqual(len(Grupo.get_root_nodes()), 1)
def test_modificar_lideres_raiz(self):
"""
Prueba que cuando se editen los lideres del grupo raiz, se les coloque a los lideres nuevos el grupo raiz como
su grupo que lidera y a los lideres que se cambiaron se les quite.
"""
raiz = GrupoRaizFactory()
lider3 = MiembroFactory(lider=True, grupo_lidera=raiz)
lideres_viejos = list(raiz.lideres.values_list('id', flat=True))
data = self.datos_formulario()
data['lideres'].append(lider3.id)
form = GrupoRaizForm(instance=raiz, data=data)
form.save()
lider3.refresh_from_db()
self.lider1.refresh_from_db()
self.lider2.refresh_from_db()
self.assertEqual(lider3.grupo_lidera, raiz)
self.assertEqual(self.lider1.grupo_lidera, raiz)
self.assertEqual(self.lider2.grupo_lidera, raiz)
self.assertEqual(len(raiz.lideres.filter(id__in=lideres_viejos)), 1)
@mock.patch('django.db.models.query.QuerySet.update', side_effect=IntegrityError)
def test_error_al_guardar_formulario_no_se_guarda_nada_en_db(self, update_mock):
"""
Prueba que si ocurre un error al guardar el formulario no se guarde ni el grupo ni los lideres.
"""
form = GrupoRaizForm(data=self.datos_formulario())
form.save()
self.lider1.refresh_from_db()
self.lider2.refresh_from_db()
self.assertTrue(update_mock.called)
self.assertEqual(len(Grupo.get_root_nodes()), 0)
self.assertEqual(self.lider1.grupo_lidera, None)
self.assertEqual(self.lider2.grupo_lidera, None)
@mock.patch('django.db.models.query.QuerySet.update', side_effect=IntegrityError)
def test_error_al_guardar_formulario_agrega_error_form(self, update_mock):
"""
Prueba que si ocurre un error al momento de guardar el formulario, se agregue un error al formulario.
"""
form = GrupoRaizForm(data=self.datos_formulario())
form.save()
self.assertTrue(update_mock.called)
self.assertEqual(len(form.non_field_errors()), 1)
class NuevoGrupoFormTest(BaseTest):
"""
Pruebas unitarias para el formulario de creación de grupos de una iglesia.
"""
def setUp(self):
self.crear_arbol()
grupo3 = Grupo.objects.get(id=300)
self.padre = Grupo.objects.get(id=800)
self.lider1 = MiembroFactory(lider=True, grupo=grupo3)
self.lider2 = MiembroFactory(lider=True, grupo=self.padre)
self.barrio = BarrioFactory()
self.red_jovenes = Red.objects.get(nombre='jovenes')
def datos_formulario(self):
"""
Retorna un diccionario con datos para el formulario GrupoRaiz.
"""
data = {
'direccion': 'Calle 34 N 74 - 23', 'estado': 'A', 'fechaApertura': '2012-03-03', 'diaGAR': '1',
'horaGAR': '12:00', 'diaDiscipulado': '3', 'horaDiscipulado': '16:00', 'nombre': 'Pastor presidente',
'barrio': self.barrio.id, 'lideres': [self.lider1.id, self.lider2.id], 'parent': self.padre.id
}
return data
def test_campo_parent_solo_muestra_grupos_red_ingresada(self):
"""
Prueba que el campo parent solo muestra los grupos pertenecientes a la red ingresada.
"""
raiz = Grupo.objects.get(id=100)
grupo1 = Grupo.objects.get(id=300)
grupo2 = Grupo.objects.get(id=400)
form = NuevoGrupoForm(red=self.red_jovenes)
self.assertIn(grupo1, form.fields['parent'].queryset)
self.assertNotIn(grupo2, form.fields['parent'].queryset)
self.assertNotIn(raiz, form.fields['parent'].queryset)
def test_campo_parent_muestra_raiz_sino_red_no_tiene_grupos(self):
"""
Prueba que el campo parent muestre el grupo raiz de la iglesia si la red ingresada no tiene ningún grupo.
"""
raiz = Grupo.objects.get(id=100)
otro = Grupo.objects.get(id=300)
red_nueva = RedFactory(nombre='nueva red')
form = NuevoGrupoForm(red=red_nueva)
self.assertIn(raiz, form.fields['parent'].queryset)
self.assertNotIn(otro, form.fields['parent'].queryset)
@skip
def test_campo_lideres_solo_muestra_lideres(self):
"""
Prueba que el campo lideres solo se muestren miembros que sean lideres.
"""
no_lider = MiembroFactory()
form = NuevoGrupoForm(red=self.red_jovenes)
self.assertNotIn(no_lider, form.fields['lideres'].queryset)
@skip
def test_campo_lideres_solo_muestra_lideres_sin_grupo(self):
"""
Prueba que en el campo lideres solo se muestren miembros que sean lideres que no lideren grupo.
"""
grupo = Grupo.objects.get(id=300)
lider_sin_grupo = MiembroFactory(lider=True, grupo=grupo)
form = NuevoGrupoForm(red=self.red_jovenes)
self.assertNotIn(grupo.lideres.first(), form.fields['lideres'].queryset)
self.assertIn(lider_sin_grupo, form.fields['lideres'].queryset)
@skip
def test_campo_lideres_solo_muestra_lideres_red_ingresada(self):
"""
Prueba que el campo lideres solo muestra lideres que pertenecen a los grupos de la red ingresada.
"""
grupo1 = Grupo.objects.get(id=300)
lider_joven = MiembroFactory(lider=True, grupo=grupo1)
grupo2 = Grupo.objects.get(id=400)
otro_lider = MiembroFactory(lider=True, grupo=grupo2)
form = NuevoGrupoForm(red=self.red_jovenes)
self.assertIn(lider_joven, form.fields['lideres'].queryset)
self.assertNotIn(otro_lider, form.fields['lideres'].queryset)
@skip
def test_campo_lideres_muestra_lideres_raiz_si_red_no_tiene_grupo(self):
"""
Prueba que el campo lideres muestre los lideres disponibles que asisten al grupo raiz de una iglesia si la red
ingresada no tiene ningún grupo.
"""
raiz = Grupo.objects.get(id=100)
otro = Grupo.objects.get(id=300)
red_nueva = RedFactory(nombre='nueva red')
miembro = MiembroFactory(lider=True, grupo=raiz)
form = NuevoGrupoForm(red=red_nueva)
self.assertIn(miembro, form.fields['lideres'].queryset)
self.assertNotIn(otro.lideres.first(), form.fields['lideres'].queryset)
def test_formulario_crea_grupo_y_se_asigna_a_lideres_escogidos(self):
"""
Prueba que cuando se guarde el formulario se crea el grupo y es asignado a los lideres escogidos como grupo
que lidera y el padre como grupo al que pertenecen.
"""
form = NuevoGrupoForm(red=self.red_jovenes, data=self.datos_formulario())
grupo = form.save()
self.lider1.refresh_from_db()
self.lider2.refresh_from_db()
self.assertEqual(self.padre.get_children_count(), 1)
self.assertEqual(grupo.red, self.red_jovenes)
self.assertEqual(self.lider1.grupo_lidera, grupo)
self.assertEqual(self.lider2.grupo_lidera, grupo)
self.assertEqual(self.lider1.grupo, self.padre)
self.assertEqual(self.lider2.grupo, self.padre)
@mock.patch('django.db.models.query.QuerySet.update', side_effect=IntegrityError)
def test_error_al_guardar_formulario_no_se_guarda_nada_en_db(self, update_mock):
"""
Prueba que si ocurre un error al guardar el formulario no se guarde ni el grupo ni los lideres.
"""
form = NuevoGrupoForm(red=self.red_jovenes, data=self.datos_formulario())
form.save()
self.lider1.refresh_from_db()
self.lider2.refresh_from_db()
self.assertTrue(update_mock.called)
self.assertEqual(self.padre.get_children_count(), 0)
self.assertEqual(self.lider1.grupo_lidera, None)
self.assertEqual(self.lider2.grupo_lidera, None)
@mock.patch('django.db.models.query.QuerySet.update', side_effect=IntegrityError)
def test_error_al_guardar_formulario_agrega_error_form(self, update_mock):
"""
Prueba que si ocurre un error al momento de guardar el formulario, se agregue un error al formulario.
"""
form = NuevoGrupoForm(red=self.red_jovenes, data=self.datos_formulario())
form.save()
self.assertTrue(update_mock.called)
self.assertEqual(len(form.non_field_errors()), 1)
