def test_boton_reactivar_usuario_en_template(self):
# Se crea un usuario inactivo
self.asigna_permisos_login()
usuario = User(
username='******',
email='*****@*****.**',
password='******',
is_superuser=True,
is_active=False
)
usuario.save()
administrativo = Administrativo(
nombre='Jorge',
primer_apellido='Solís',
segundo_apellido='Galván',
telefono='4949412345',
foto='foto.png',
usuario=usuario
)
administrativo.save()
id = usuario.id
response = self.client.get('/usuarios/')
self.assertInHTML('<a href="/usuarios/reactivar/'+str(id) +
'" class="btn btn-success btn-sm">Reactivar</a>',
response.rendered_content)
def setUp(self):
self.programa = Programa(
nombre='Programa para Jóvenes Zacatecanos',
anio_ejercicio_fiscal=2019,
recurso_asignado=600000,
fuente='Gobierno',
tipo='MEN',
status='ACT',
tipo_programa_p='APO',
)
self.programa.save()
self.partida = Partida(
numero_partida=3000,
nombre_partida='Partida 1 de 3000',
monto_partida=6700.00,
programa=self.programa,
)
self.partida.save()
self.usuario = User(username="******",
email="*****@*****.**",
password="******",
is_superuser=True)
self.usuario.save()
self.administrativo = Administrativo(nombre="usuario de prueba",
primer_apellido='Solís',
segundo_apellido='Galván',
telefono='4949412345',
foto='foto.png',
usuario=self.usuario)
self.administrativo.save()
class SubprogramaFormTests(TestCase):
def setUp(self):
self.programa = Programa(
nombre='Programa para Jóvenes Zacatecanos',
anio_ejercicio_fiscal=2019,
recurso_asignado=600000,
fuente='Gobierno',
tipo='MEN',
status='ACT',
tipo_programa_p='APO',
)
self.programa.save()
self.partida = Partida(
numero_partida=3000,
nombre_partida='Partida 1 de 3000',
monto_partida=6700.00,
programa=self.programa,
)
self.partida.save()
self.usuario = User(username="******",
email="*****@*****.**",
password="******",
is_superuser=True)
self.usuario.save()
self.administrativo = Administrativo(nombre="usuario de prueba",
primer_apellido='Solís',
segundo_apellido='Galván',
telefono='4949412345',
foto='foto.png',
usuario=self.usuario)
self.administrativo.save()
# El estatus se agrega por defecto
def test_SubprogramaForm_crear_sin_estatus(self):
form = SubprogramaForm(
data={
'programa': self.programa.id,
'nombre': 'ejemplo',
'presupuesto': 5000,
'responsable': self.usuario.id,
'estatus': 'ACT',
})
self.assertTrue(form.is_valid())
# El estatus se debe indicar de forma obligatoria
def test_EdicionSubprogramaForm_modificar_sin_estatus(self):
form = EdicionSubprogramaForm(
data={
'programa': self.programa.id,
'nombre': 'ejemplo',
'presupuesto': 5000,
'responsable': self.usuario.id,
})
self.assertFalse(form.is_valid())
def test_usuario_requerido(self):
administrativo = Administrativo(
nombre='Jorge',
primer_apellido='Solís',
segundo_apellido='Galván',
telefono='4949412345',
foto='foto.png',
)
with self.assertRaises(ValidationError):
administrativo.full_clean()
def setUp(self,
nombre='jorgesolis',
correo='*****@*****.**',
password='******'):
self.usuario = User(username=nombre,
email=correo,
password=password,
is_superuser=True)
self.administrativo = Administrativo(nombre='Jorge',
primer_apellido='Solís',
segundo_apellido='Galván',
telefono='4949412345',
foto='foto.png',
usuario=self.usuario)
def guarda_administrativo(self):
self.usuario = User(
username='******',
email='*****@*****.**',
password='******',
is_superuser=True
)
self.usuario.save()
self.administrativo = Administrativo(
nombre='Jorge',
primer_apellido='Solís',
segundo_apellido='Galván',
telefono='4949412345',
foto='foto.png',
usuario=self.usuario
)
self.administrativo.save()
return self.usuario
class TestViews(TestCase):
def setUp(self):
self.usuario = User(
username='******',
email='*****@*****.**',
password='******',
is_superuser=True,
is_active=True
)
self.data_admin = {
'nombre': 'Jorge Alfonso',
'primer_apellido': 'Solís',
'segundo_apellido': 'Galván',
'telefono': 4941056009,
'foto': 'C:\\Users\\Lenovo\\Pictures\\3.png',
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password_re': 'Jorgeasg15@',
'is_superuser': True,
}
# Tests para nuevo usuario
def test_crea_cuenta_response(self):
self.asigna_permisos_login()
response = self.client.get('/usuarios/nuevo')
self.assertEqual(response.status_code, 200)
def test_nombre_url_nuevo_usuario_response(self):
self.asigna_permisos_login()
response = self.client.get(reverse('nuevo_usuario'))
self.assertEqual(response.status_code, 200)
def test_template_correcto_nuevo_usuario(self):
self.asigna_permisos_login()
response = self.client.get('/usuarios/nuevo')
self.assertTemplateUsed(response, 'usuarios/usuario_form.html')
def test_titulo_se_encuentra_en_el_template(self):
self.asigna_permisos_login()
response = self.client.get('/usuarios/nuevo')
titulo = '<title> Crear cuenta de usuario </title>'
self.assertInHTML(titulo, response.rendered_content)
def test_agrega_administrativo_form(self):
self.asigna_permisos_login()
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 1)
def test_no_agrega_sin_nombre_usuario(self):
self.asigna_permisos_login()
self.data_admin['username'] = ''
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_con_nombre_usuario_con_espacios(self):
self.asigna_permisos_login()
self.data_admin['username'] = '******'
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_con_nombre_usuario_min_caracteres(self):
self.asigna_permisos_login()
self.data_admin['username'] = '******'
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_con_nombre_usuario_max_caracteres(self):
self.asigna_permisos_login()
self.data_admin['username'] = '******'*5
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_usuario_sin_correo(self):
self.asigna_permisos_login()
# Se agrega porque al crear el usuario para iniciar sesión y crear otro
# usuario, ya se guarda uno en la BD
no_users = User.objects.all().count()
self.data_admin['email'] = ''
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(User.objects.all().count(), no_users)
def test_no_agrega_usuario_correo_con_espacios(self):
self.asigna_permisos_login()
no_users = User.objects.all().count()
self.data_admin['email'] = 'jasg15 @hotmail.com'
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(User.objects.all().count(), no_users)
def test_no_agrega_usuario_correo_min_caracteres(self):
self.asigna_permisos_login()
no_users = User.objects.all().count()
self.data_admin['email'] = 'j@'
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(User.objects.all().count(), no_users)
def test_no_agrega_usuario_correo_max_caracteres(self):
self.asigna_permisos_login()
no_users = User.objects.all().count()
self.data_admin['email'] = '*****@*****.**'*30
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(User.objects.all().count(), no_users)
def test_no_agrega_usuario_sin_password(self):
self.asigna_permisos_login()
self.data_admin['password'] = ''
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_usuario_password_min_caracteres(self):
self.asigna_permisos_login()
self.data_admin['password'] = '******'
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_usuario_password_max_caracteres(self):
self.asigna_permisos_login()
self.data_admin['password'] = '******'*10
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_usuario_sin_nombre(self):
self.asigna_permisos_login()
self.data_admin['nombre'] = ''
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_usuario_nombre_max_caracteres(self):
self.asigna_permisos_login()
self.data_admin['nombre'] = 'jorgealfonso'*10
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_usuario_nombre_formato_incorrecto(self):
self.asigna_permisos_login()
self.data_admin['nombre'] = ' jorge alfonso'
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_usuario_sin_primer_apellido(self):
self.asigna_permisos_login()
self.data_admin['primer_apellido'] = ''
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_usuario_primer_apellido_max_caracteres(self):
self.asigna_permisos_login()
self.data_admin['primer_apellido'] = 'solisg'*10
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_usuario_primer_apellido_formato_incorrecto(self):
self.asigna_permisos_login()
self.data_admin['primer_apellido'] = ' solis'
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_agrega_usuario_sin_segundo_apellido(self):
self.asigna_permisos_login()
self.data_admin['segundo_apellido'] = ''
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 1)
def test_no_agrega_usuario_segundo_apellido_formato_incorrecto(self):
self.asigna_permisos_login()
self.data_admin['segundo_apellido'] = ' sanchez'
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_usuario_segundo_apellido_max_caracteres(self):
self.asigna_permisos_login()
self.data_admin['segundo_apellido'] = 'sanchez'*10
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_usuario_sin_telefono(self):
self.asigna_permisos_login()
self.data_admin['telefono'] = ''
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_no_agrega_usuario_telefono_formato_incorrecto(self):
self.asigna_permisos_login()
self.data_admin['telefono'] = '49494123'
self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(Administrativo.objects.all().count(), 0)
def test_redirige_despues_de_agregar_usuario(self):
self.asigna_permisos_login()
response = self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(response.url, '/usuarios/')
def test_redirige_si_no_inicio_sesion_agregar_usuario(self):
response = self.client.post('/usuarios/nuevo', data=self.data_admin)
self.assertEqual(response.url, '/usuarios/login?next=/usuarios/nuevo')
# Tests para listar usuarios
def test_redirige_si_no_inicio_sesion_listar_usuarios(self):
response = self.client.post('/usuarios/')
self.assertEqual(response.url, '/usuarios/login?next=/usuarios/')
def test_listar_cuentas_response(self):
self.asigna_permisos_login()
response = self.client.get('/usuarios/')
self.assertEqual(response.status_code, 200)
def test_nombre_url_lista_usuarios(self):
self.asigna_permisos_login()
response = self.client.get(reverse('lista_usuarios'))
self.assertEqual(response.status_code, 200)
def test_template_correcto_listar_cuentas(self):
self.asigna_permisos_login()
response = self.client.get('/usuarios/')
self.assertTemplateUsed(response, 'usuarios/usuarios.html')
def test_titulo_se_encuentra_en_el_template_lista_usuarios(self):
self.asigna_permisos_login()
response = self.client.get('/usuarios/')
titulo = '<h2 class="aex" >Usuarios</h2>'
self.assertInHTML(titulo, response.rendered_content)
def test_envio_datos_usuarios(self):
self.guarda_administrativo()
self.asigna_permisos_login()
response = self.client.get('/usuarios/')
self.assertIn('object_list', response.context)
def test_envio_jorgeasolis_datos_usuario(self):
self.guarda_administrativo()
self.asigna_permisos_login()
response = self.client.get('/usuarios/')
self.assertEqual(
'jorgesolis',
response.context['object_list'][0]['usuario'].username)
def test_jorgeasolis_se_encuentre_en_el_template(self):
self.guarda_administrativo()
self.asigna_permisos_login()
response = self.client.get('/usuarios/')
self.assertContains(response, 'jorgesolis')
def test_jorgeasolis_se_encuentre_en_el_template_en_un_td(self):
self.guarda_administrativo()
self.asigna_permisos_login()
response = self.client.get('/usuarios/')
self.assertInHTML('<td>jorgesolis</td>', response.rendered_content)
# Tests para Login
def test_login_response(self):
response = self.client.get('/usuarios/login')
self.assertEqual(response.status_code, 200)
def test_nombre_url_login_response(self):
response = self.client.get(reverse('login'))
self.assertEqual(response.status_code, 200)
def test_template_correcto_login(self):
response = self.client.get('/usuarios/login')
self.assertTemplateUsed(response, 'usuarios/login.html')
def test_titulo_se_encuentra_en_el_template_login(self):
response = self.client.get('/usuarios/login')
titulo = '<title> Inicio de sesión </title>'
self.assertInHTML(titulo, response.rendered_content)
def test_campo_usuario_se_encuentra_en_el_template(self):
response = self.client.get('/usuarios/login')
formulario = '<label for="id_username">Usuario:</label>'
formulario += '<input class="au-input au-input--full" type="text" '
formulario += 'name="username" id="id_username" placeholder'
formulario += '="Nombre de usuario">'
self.assertInHTML(formulario, response.rendered_content)
def test_campo_password_se_encuentra_en_el_template(self):
response = self.client.get('/usuarios/login')
formulario = '<label for="id_password">Contraseña</label>'
formulario += '<input class="au-input au-input--full" type="password" '
formulario += 'name="password" id="id_password" placeholder'
formulario += '="Contraseña">'
self.assertInHTML(formulario, response.rendered_content)
def test_redirige_despues_de_iniciar_sesion(self):
User.objects.create_user(
username='******',
password='******',
email='*****@*****.**'
)
data_login = {
'username': '******',
'password': '******',
}
response = self.client.post('/usuarios/login', data=data_login)
self.assertEqual(response.url, '/principal/')
# Tests para Logout
def test_boton_cerrar_se_encuentra_en_el_template_base(self):
self.asigna_permisos_login()
response = self.client.get('/usuarios/nuevo')
boton = '<a href="javascript: cerrarSesion(\'/usuarios/logout\')" '
boton += 'id="btnCerrarSesion"><i class="zmdi zmdi-power">'
boton += '</i>Cerrar Sesión</a>'
self.assertInHTML(boton, response.rendered_content)
def test_modal_confirmacion_cerrar_se_encuentra_en_el_template_base(self):
self.asigna_permisos_login()
response = self.client.get('/usuarios/nuevo')
boton = '<h5 class="modal-title" id="exampleModalLabel">'
boton += 'Confirmación</h5>'
self.assertInHTML(boton, response.rendered_content)
def test_logout_redireccion(self):
self.asigna_permisos_login()
response = self.client.get('/usuarios/logout')
self.assertEqual(response.url, '/usuarios/login')
# Tests para editar usuario
def test_editar_usuario_response(self):
self.guarda_administrativo()
id = User.objects.first().id
response = self.client.get('/usuarios/editar/'+str(id))
self.assertEqual(response.status_code, 200)
def test_template_correcto_editar_usuario(self):
self.guarda_administrativo()
id = User.objects.first().id
response = self.client.get('/usuarios/editar/'+str(id))
self.assertTemplateUsed(response, 'usuarios/editar_usuario.html')
def test_editar_usuario_form(self):
self.guarda_administrativo()
id = User.objects.first().id
data = {
'nombre': 'Jorge Alfonso',
'primer_apellido': 'Solís',
'segundo_apellido': 'Galván',
'telefono': '4949412345',
'foto': 'foto.png',
}
self.client.post('/usuarios/editar/'+str(id), data=data)
self.assertEqual(
Administrativo.objects.first().nombre, 'Jorge Alfonso')
def test_editar_nombre_incorrecto_form(self):
self.guarda_administrativo()
id = User.objects.first().id
data = {
'nombre': '',
'primer_apellido': 'Solís',
'segundo_apellido': 'Galván',
'telefono': '4949412345',
'foto': 'foto.png',
}
self.client.post('/usuarios/editar/'+str(id), data=data)
self.assertEqual(Administrativo.objects.first().nombre, 'Jorge')
# Tests para desactivar usuario
def test_redirige_si_no_inicio_sesion_desactivar_usuarios(self):
response = self.client.post('/usuarios/desactivar/1')
self.assertEqual(
response.url, '/usuarios/login?next=/usuarios/desactivar/1')
def test_desactivar_usuario_response(self):
self.asigna_permisos_login()
self.guarda_administrativo()
id = User.objects.first().id
self.client.post('/usuarios/desactivar/'+str(id))
self.assertFalse(User.objects.first().is_active)
def test_desactivar_usuario__ya_desactivado(self):
self.asigna_permisos_login()
usuario = User(
username='******',
email='*****@*****.**',
password='******',
is_superuser=True,
is_active=False
)
usuario.save()
id = User.objects.first().id
self.client.post('/usuarios/desactivar/'+str(id))
self.assertFalse(User.objects.first().is_active)
def test_boton_desactivar_usuario_en_template(self):
# Se crea un usuario activo
user = self.guarda_administrativo()
self.asigna_permisos_login()
response = self.client.get('/usuarios/')
id = user.id
self.assertInHTML('<a href="/usuarios/desactivar/'+str(id) +
'" class="btn btn-danger btn-sm">Desactivar</a>',
response.rendered_content)
# Tests para reactivar usuario
def test_redirige_si_no_inicio_sesion_reactivar_usuarios(self):
response = self.client.post('/usuarios/reactivar/1')
self.assertEqual(
response.url, '/usuarios/login?next=/usuarios/reactivar/1')
def test_reactivar_usuario_response(self):
self.asigna_permisos_login()
usuario = User(
username='******',
email='*****@*****.**',
password='******',
is_superuser=True,
is_active=False
)
usuario.save()
id = User.objects.first().id
self.client.post('/usuarios/reactivar/'+str(id))
self.assertTrue(User.objects.first().is_active)
def test_reactivar_usuario_ya_activado(self):
self.asigna_permisos_login()
self.guarda_administrativo()
id = User.objects.first().id
self.client.post('/usuarios/reactivar/'+str(id))
self.assertTrue(User.objects.first().is_active)
def test_boton_reactivar_usuario_en_template(self):
# Se crea un usuario inactivo
self.asigna_permisos_login()
usuario = User(
username='******',
email='*****@*****.**',
password='******',
is_superuser=True,
is_active=False
)
usuario.save()
administrativo = Administrativo(
nombre='Jorge',
primer_apellido='Solís',
segundo_apellido='Galván',
telefono='4949412345',
foto='foto.png',
usuario=usuario
)
administrativo.save()
id = usuario.id
response = self.client.get('/usuarios/')
self.assertInHTML('<a href="/usuarios/reactivar/'+str(id) +
'" class="btn btn-success btn-sm">Reactivar</a>',
response.rendered_content)
def login(self):
self.usuario.save()
self.client.login(username='******', password='******')
def guarda_administrativo(self):
self.usuario = User(
username='******',
email='*****@*****.**',
password='******',
is_superuser=True
)
self.usuario.save()
self.administrativo = Administrativo(
nombre='Jorge',
primer_apellido='Solís',
segundo_apellido='Galván',
telefono='4949412345',
foto='foto.png',
usuario=self.usuario
)
self.administrativo.save()
return self.usuario
def asigna_permisos_login(self):
user1 = User.objects.create_user(
username='******',
password='******',
email='*****@*****.**',
is_staff=True
)
new_group, created = Group.objects.get_or_create(
name='director_operativo')
new_subprograma, created = Group.objects.get_or_create(
name='encargado_subprograma')
new_group.permissions.add(Permission.objects.get(codename='view_user'))
new_group.permissions.add(Permission.objects.get(codename='add_user'))
user1.groups.add(new_group)
self.client.login(username='******', password='******')
class SubprogramaModelTests(TestCase):
def setUp(self):
self.programa = Programa(
nombre='Programa para Jóvenes Zacatecanos',
anio_ejercicio_fiscal=2019,
recurso_asignado=600000,
fuente='Gobierno',
tipo='MEN',
status='ACT',
tipo_programa_p='APO',
)
self.programa.save()
self.partida = Partida(
numero_partida=3000,
nombre_partida='Partida 1 de 3000',
monto_partida=6700.00,
programa=self.programa,
)
self.partida.save()
self.usuario = User(username="******",
email="*****@*****.**",
password="******",
is_superuser=True)
self.usuario.save()
self.administrativo = Administrativo(nombre="usuario de prueba",
primer_apellido='Solís',
segundo_apellido='Galván',
telefono='4949412345',
foto='foto.png',
usuario=self.usuario)
self.administrativo.save()
def creaDefaultSubprograma(self):
return Actividad.objects.create(
programa=self.programa,
nombre="Subprograma De Referencia",
presupuesto=20580,
responsable=self.usuario,
estatus="ACT",
)
def creaSubprogramaPersonal(self, nombre='', presupuesto=None, estatus=''):
return Actividad.objects.create(
programa=self.programa,
nombre=nombre,
presupuesto=presupuesto,
responsable=self.usuario,
estatus=estatus,
)
'''
Pruebas del guardado del subprograma
'''
def test_subprograma_bien_guardado(self):
subprograma = self.creaDefaultSubprograma()
subprograma_uno = Actividad.objects.first()
self.assertEqual(subprograma_uno, subprograma)
self.assertEqual(subprograma_uno.nombre, 'Subprograma De Referencia')
self.assertEqual(subprograma_uno.estatus, "ACT")
self.assertEqual(subprograma_uno.presupuesto, 20580)
self.assertEqual(len(Actividad.objects.all()), 1)
def test_subprograma_guardado_con_id(self):
subprograma = self.creaDefaultSubprograma()
self.assertTrue(subprograma.id)
'''
Pruebas del nombre del subprograma
'''
def test_subprograma_nombre_no_nulo(self):
with self.assertRaises(ValidationError):
subprograma = self.creaSubprogramaPersonal('', 5000, 'ACT')
subprograma.full_clean()
def test_subprograma_nombre_no_nulo_mensaje(self):
with self.assertRaisesMessage(ValidationError,
"El nombre no puede estar vacío."):
subprograma = self.creaSubprogramaPersonal('', 5000, 'ACT')
subprograma.full_clean()
def test_subprograma_nombre_letras_especiales_permitidas(self):
subprograma = self.creaSubprogramaPersonal('aksñdlaäáÁàm', 5000, 'ACT')
subprograma.full_clean()
def test_subprograma_nombre_caracteres_especiales_no_permitidos(self):
with self.assertRaises(ValidationError):
subprograma = self.creaSubprogramaPersonal('aksd\'lam', 5000,
'ACT')
subprograma.full_clean()
def test_subp_nombre_caracteres_especiales_no_permitidos_mensaje(self):
with self.assertRaisesMessage(ValidationError,
"Solo se permiten letras."):
subprograma = self.creaSubprogramaPersonal('aksdñlamó_', 5000,
'ACT')
subprograma.full_clean()
def test_subprograma_nombre_numeros_no_permitidos(self):
with self.assertRaises(ValidationError):
subprograma = self.creaSubprogramaPersonal('aksdlam34', 5000,
'ACT')
subprograma.full_clean()
def test_subprograma_nombre_numeros_no_permitidos_mensaje(self):
with self.assertRaisesMessage(ValidationError,
"Solo se permiten letras."):
subprograma = self.creaSubprogramaPersonal('aksdl1am34', 5000,
'ACT')
subprograma.full_clean()
def test_subprograma_nombre_longitud_minima_pasada(self):
with self.assertRaises(ValidationError):
subprograma = self.creaSubprogramaPersonal('hola', 5000, 'ACT')
subprograma.full_clean()
def test_subprograma_nombre_longitud_minima_pasada_mensaje(self):
with self.assertRaisesMessage(
ValidationError,
"El nombre debe ser de por lo menos 5 caracteres."):
subprograma = self.creaSubprogramaPersonal('hola', 5000, 'ACT')
subprograma.full_clean()
def test_subprograma_nombre_longitud_maxima_pasada(self):
with self.assertRaises(ValidationError):
subprograma = Actividad(
nombre="holadfgfffffffffhhhhhhhhhhhhhhhhhhhhhhg" +
"ffffffffffffffffffffffffffhhhhhhhhhhho",
presupuesto=66478,
responsable=self.usuario,
estatus='ACT',
)
subprograma.full_clean()
def test_subprograma_nombre_longitud_maxima_pasada_mensaje(self):
with self.assertRaisesMessage(
ValidationError,
"El nombre no puede pasar los 50 caracteres."):
subprograma = Actividad(
nombre="holadfgfffffffffhhhhhhhhhhhhhhhhhhhhhhg" +
"ffffffffffffffffffffffffffhhhhhhhhhhho",
presupuesto=66478,
responsable=self.usuario,
estatus='ACT',
)
subprograma.full_clean()
'''
Pruebas del programa del subprograma
'''
def test_subprograma_programa_requerido(self):
error = False
try:
subprograma = Actividad.objects.create(
nombre="nombre de ejemplo",
presupuesto=66478,
responsable=self.usuario,
estatus='ACT',
)
subprograma.full_clean()
except Exception as e:
error = True
self.assertTrue(error)
'''
Pruebas del responsable del subprograma
'''
def test_subprograma_responsable_requerido(self):
error = False
try:
subprograma = Actividad.objects.create(
programa=self.programa,
nombre="nombre de ejemplo",
presupuesto=66478,
estatus='ACT',
)
subprograma.full_clean()
except Exception as e:
error = True
self.assertTrue(error)
'''
Pruebas del presupuesto del subprograma
'''
def test_subprograma_presupuesto_requerido(self):
try:
subprograma = Actividad.objects.create(
nombre="nombre",
presupuesto=None,
estatus="ACT",
)
subprograma.full_clean()
except Exception:
self.assertEqual(Exception.__name__, "Exception")
def test_subprograma_presupuesto_caracteres_no_numericos_no_permitidos(
self):
with self.assertRaises(ValidationError):
subprograma = self.creaSubprogramaPersonal('ejemplo', '5000e',
'ACT')
subprograma.full_clean()
def test_subprograma_nombre_caracteres_no_numericos_no_permitidos(self):
with self.assertRaisesMessage(ValidationError,
"El presupuesto debe ser numérico."):
subprograma = self.creaSubprogramaPersonal('ejemplo', '5000e',
'ACT')
subprograma.full_clean()
class SubprogramaViewTests(TestCase):
def setUp(self):
self.programa = Programa(
nombre='Programa para Jóvenes Zacatecanos',
anio_ejercicio_fiscal=2019,
recurso_asignado=600000,
fuente='Gobierno',
tipo='MEN',
status='ACT',
tipo_programa_p='APO',
)
self.programa.save()
self.partida = Partida(
numero_partida=3000,
nombre_partida='Partida 1 de 3000',
monto_partida=6700.00,
programa=self.programa,
)
self.partida.save()
self.usuario = User(username="******",
email="*****@*****.**",
password="******",
is_superuser=True)
self.usuario.save()
self.administrativo = Administrativo(nombre="usuario de prueba",
primer_apellido='LOL',
segundo_apellido='JJ',
telefono='4949412345',
foto='foto.png',
usuario=self.usuario)
self.administrativo.save()
self.subp = test_models.SubprogramaModelTests.creaDefaultSubprograma(
self)
self.asigna_permisos_login()
'''
Vista Agregar subprograma
'''
def test_vistaAgregar_url(self):
response = self.client.get('/subprograma/nuevo')
self.assertEqual(response.status_code, 200)
def test_vistaAgregar_nombre_url(self):
response = self.client.get(reverse('nuevo_subprograma'))
self.assertEqual(response.status_code, 200)
def test_vistaAregar_html_correcto(self):
response = self.client.get('/subprograma/nuevo')
self.assertTemplateUsed(response, 'actividades/actividad_form.html')
def test_vistaAregar_envio_datos_a_lista_subprograma(self):
response = self.client.get('/subprograma/')
self.assertEqual(response.context['object_list'][0].nombre,
'Subprograma De Referencia')
'''
Vista Editar subprograma
'''
def test_vistaEditar_url(self):
response = self.client.get(f'/subprograma/editar/{self.subp.id}')
self.assertEqual(response.status_code, 200)
def test_vistaEditar_nombre_url(self):
response = self.client.get(
reverse('editar_subprograma', args=[self.subp.id]))
self.assertEqual(response.status_code, 200)
def test_vistaEditar_html_correcto(self):
response = self.client.get(f'/subprograma/editar/{self.subp.id}')
self.assertTemplateUsed(response, 'actividades/actividad_form.html')
'''
Vista Detalles/Ver subprograma
'''
def test_vistaVer_url(self):
response = self.client.get(f'/subprograma/ver/{self.subp.id}')
self.assertEqual(response.status_code, 200)
def test_vistaVer_nombre_url(self):
response = self.client.get(
reverse('ver_subprograma', args=[self.subp.id]))
self.assertEqual(response.status_code, 200)
def test_vistaVer_html_correcto(self):
response = self.client.get(f'/subprograma/ver/{self.subp.id}')
self.assertTemplateUsed(response, 'actividades/actividad_detail.html')
'''
Vista lista subprograma
'''
def test_vistaLista_url(self):
response = self.client.get('/subprograma/')
self.assertEqual(response.status_code, 200)
def test_vistaLista_nombre_url(self):
response = self.client.get(reverse('lista_subprograma'))
self.assertEqual(response.status_code, 200)
def test_vistaLista_html_correcto(self):
response = self.client.get('/subprograma/')
self.assertTemplateUsed(response, 'actividades/actividad_list.html')
def test_vistaLista_carga_datos(self):
response = self.client.get('/subprograma/')
self.assertIn('object_list', response.context)
def test_vistaLista_envio_datos_a_Ver_subprograma(self):
response = self.client.get(f'/subprograma/ver/{self.subp.id}')
self.assertEqual(response.context['object'].nombre,
'Subprograma De Referencia')
def test_vistaLista_envio_datos_a_Editar_subprograma(self):
response = self.client.get(f'/subprograma/editar/{self.subp.id}')
self.assertEqual(response.context['object'].nombre,
'Subprograma De Referencia')
def asigna_permisos_login(self):
user = User.objects.create_user(username='******',
password='******',
email='*****@*****.**',
is_staff=True)
new_group, created = Group.objects.get_or_create(
name='director_operativo')
new_subprograma, created = Group.objects.get_or_create(
name='encargado_subprograma')
new_group.permissions.add(
Permission.objects.get(codename='add_subprograma'))
new_group.permissions.add(
Permission.objects.get(codename='view_subprograma'))
new_group.permissions.add(
Permission.objects.get(codename='change_subprograma'))
user.groups.add(new_group)
self.client.login(username='******', password='******')
class TestModels(TestCase):
def setUp(self,
nombre='jorgesolis',
correo='*****@*****.**',
password='******'):
self.usuario = User(username=nombre,
email=correo,
password=password,
is_superuser=True)
self.administrativo = Administrativo(nombre='Jorge',
primer_apellido='Solís',
segundo_apellido='Galván',
telefono='4949412345',
foto='foto.png',
usuario=self.usuario)
def test_return_object_usuario(self):
self.usuario.full_clean()
self.usuario.save()
self.assertEqual(User.objects.first().username, self.usuario.__str__())
def test_nombre_es_requerido(self):
usuario = User(email='*****@*****.**', password='******')
with self.assertRaises(ValidationError):
usuario.full_clean()
def test_nombre_usuario_min_8_char(self):
self.usuario.username = '******'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_nombre_usuario_no_acepta_espacios(self):
self.usuario.username = '******'
with self.assertRaises(ValidationError):
self.usuario.full_clean()
def test_nombre_usuario_no_acepta_caracteres_especiales(self):
self.usuario.username = '******'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_nombre_usuario_no_acepta_numeros(self):
self.usuario.username = '******'
self.administrativo.usuario = self.usuario
try:
self.administrativo.full_clean()
except ValidationError as ex:
msg = str(ex.message_dict['username'][0])
self.assertEqual(
msg, 'El nombre de usuario no sigue el formato solicitado,' +
' favor de verificarlo.')
def test_usuario_duplicado(self):
self.usuario.save()
usuario2 = User(username='******',
email='*****@*****.**',
password='******')
try:
usuario2.full_clean()
except ValidationError as ex:
msg = str(ex.message_dict['username'][0])
self.assertEqual(msg, 'A user with that username already exists.')
def test_correo_es_requerido(self):
usuario = User(username='******', password='******')
self.administrativo.usuario = usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_email_incorrecto(self):
self.usuario.email = 'jasg15@gmail'
with self.assertRaises(ValidationError):
self.usuario.full_clean()
def test_email_incorrecto_espacios(self):
self.usuario.email = 'jasg15@gmail. com'
with self.assertRaises(ValidationError):
self.usuario.full_clean()
def test_email_incorrecto_max_caracteres(self):
self.usuario.email = '*****@*****.**' * 10
with self.assertRaises(ValidationError):
self.usuario.full_clean()
def test_email_incorrecto_min_caracteres(self):
self.usuario.email = 'j@g'
with self.assertRaises(ValidationError):
self.usuario.full_clean()
def test_email_duplicado(self):
self.usuario.save()
usuario2 = User(username='******',
email='*****@*****.**',
password='******')
try:
usuario2.full_clean()
except ValidationError as ex:
msg = str(ex.message_dict['email'][0])
self.assertEqual(
msg,
'El correo electrónico ingresado ya se encuentra registrado' +
' en el sistema. Favor de verificarlo.')
def test_password_es_requerido(self):
usuario = User(username='******', email='*****@*****.**')
with self.assertRaises(ValidationError):
usuario.full_clean()
def test_password_incorrecto(self):
self.usuario.password = '******'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_password_correcto(self):
self.usuario.password = '******'
self.usuario.full_clean()
self.usuario.save()
self.assertEqual(User.objects.first().password, self.usuario.password)
def test_password_incorrecto_max_caracteres(self):
self.usuario.password = '******' * 7
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_password_incorrecto_min_caracteres(self):
self.usuario.password = '******'
try:
self.usuario.full_clean()
except ValidationError as ex:
msg = str(ex.message_dict['password'][0])
self.assertEqual(
msg,
'La contraseña no sigue el formato solicitado: Mínimo 8 ' +
'caracteres, máximo 50 caracteres mínimo una mayúscula,' +
' mínimo una minúscula, mínimo un número y mínimo un ' +
'símbolo, favor de verificarla.')
# Tests para modelo Administrativo
def test_return_object_administrativo(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.usuario = self.usuario
self.administrativo.full_clean()
self.administrativo.save()
self.assertEqual(Administrativo.objects.first().__str__(),
self.administrativo.__str__())
def test_nombre_requerido(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.nombre = None
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_nombre_formato_incorrecto_numeros(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.nombre = 'Jorge1'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_nombre_formato_incorrecto_caracteres_especiales(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.nombre = 'Jorge+'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_nombre_max_caracteres(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.nombre = 'a' * 51
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_nombre_max_caracteres_mensaje(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.nombre = 'a' * 51
self.administrativo.usuario = self.usuario
try:
self.administrativo.full_clean()
except ValidationError as ex:
msg = str(ex.message_dict['nombre'][0])
self.assertEqual(
msg, 'La longitud máxima del nombre es de 50 caracteres.')
def test_nombre_min_caracteres(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.nombre = 'jo'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_nombre_espacio_al_inicio(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.nombre = ' Jorge'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_primer_apellido_requerido(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.primer_apellido = None
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_primer_apellido_formato_incorrecto_numeros(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.primer_apellido = 'Solis1'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_primer_apellido_formato_incorrecto_numeros_mensaje(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.primer_apellido = 'Solis1'
self.administrativo.usuario = self.usuario
try:
self.administrativo.full_clean()
except ValidationError as ex:
msg = str(ex.message_dict['primer_apellido'][0])
self.assertEqual(
msg,
'Formato del primer apellido incorrecto, favor de veriicarlo.')
def test_primer_apellido_formato_incorrecto_caracteres_especiales(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.primer_apellido = 'Solis+'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_primer_apellido_max_caracteres(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.primer_apellido = 'a' * 51
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_primer_apellido_min_caracteres(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.primer_apellido = 'so'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_primer_apellido_espacio_al_inicio(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.primer_apellido = ' Solis'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_segundo_apellido_no_requerido(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.segundo_apellido = ''
self.administrativo.usuario = self.usuario
self.administrativo.full_clean()
self.administrativo.save()
self.assertEqual(Administrativo.objects.first().__str__(),
self.administrativo.__str__())
def test_segundo_apellido_formato_incorrecto_numeros(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.segundo_apellido = 'Solis1'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_segundo_apellido_formato_incorrecto_caracteres_especiales(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.segundo_apellido = 'Solis+'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_segundo_apellido_max_caracteres(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.segundo_apellido = 'a' * 51
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_segundo_apellido_min_caracteres(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.segundo_apellido = 'so'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_segundo_apellido_min_caracteres_mensaje(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.segundo_apellido = 'So'
self.administrativo.usuario = self.usuario
try:
self.administrativo.full_clean()
except ValidationError as ex:
msg = str(ex.message_dict['segundo_apellido'][0])
self.assertEqual(
msg,
'La longitud mínima del segundo apellido es de 3 caracteres.')
def test_segundo_apellido_espacio_al_inicio(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.segundo_apellido = ' Solis'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_foto_formato_incorrecto(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.foto = 'foto.gif'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_foto_formato_incorrecto_mensaje(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.foto = 'foto.gif'
self.administrativo.usuario = self.usuario
try:
self.administrativo.full_clean()
except ValidationError as ex:
msg = str(ex.message_dict['foto'][0])
self.assertEqual(msg, 'Formato de imagen inválido.')
def test_foto_formato_correcto(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.usuario = self.usuario
self.administrativo.full_clean()
self.administrativo.save()
self.assertEqual(Administrativo.objects.first().__str__(),
self.administrativo.__str__())
def test_telefono_longitud_minima_incorrecta(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.telefono = '494941234'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_telefono_longitud_maxima_incorrecta(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.telefono = '49494123411'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_telefono_requerido(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.telefono = None
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_telefono_con_caracteres_especiales(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.telefono = '+494941234'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_telefono_con_espacios(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.telefono = '494941234 '
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_telefono_con_letras(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.telefono = '494941234f'
self.administrativo.usuario = self.usuario
with self.assertRaises(ValidationError):
self.administrativo.full_clean()
def test_telefono_formato_incorrecto_mensaje(self):
self.usuario.full_clean()
self.usuario.save()
self.administrativo.telefono = '492121234g'
self.administrativo.usuario = self.usuario
try:
self.administrativo.full_clean()
except ValidationError as ex:
msg = str(ex.message_dict['telefono'][0])
self.assertEqual(msg, 'Formato del número de teléfono incorrecto.')
def test_usuario_requerido(self):
administrativo = Administrativo(
nombre='Jorge',
primer_apellido='Solís',
segundo_apellido='Galván',
telefono='4949412345',
foto='foto.png',
)
with self.assertRaises(ValidationError):
administrativo.full_clean()