class seguridadTestCase(unittest.TestCase):
def setUp(self):
self.seguridad = Seguridad()
#(1) Verifica que exista la clase self.seguridad.
def test_seguridad(self):
valid = self.seguridad
self.assertNotEqual(valid, None)
#(2) Verifica que exista el metodo registrarUsuario.
def test_registrar(self):
valid = self.seguridad.registrarUsuario("*****@*****.**",
"X7SJus62h7AHv",
"X7SJus62h7AHv")
self.assertNotEqual(valid, None)
#(4) Verifica que la clave tenga longitud mayor que 7.
def test_PasswordMin(self):
valid = self.seguridad.registrarUsuario("[email protected]", "X7SJ",
"X7SJ")
self.assertEqual(valid, False)
#(6) Verifica que la clave no tenga caracteres no alfanumericos.
def test_PasswordAlphaNum(self):
valid = self.seguridad.registrarUsuario("[email protected]",
"X7SJus62h7AHv?",
"X7SJus62h7AHv?")
self.assertEqual(valid, False)
#(8) Verifica que la clave tenga al menos una mayuscula.
def test_PasswordKeyMax(self):
valid = self.seguridad.registrarUsuario("*****@*****.**",
"x781dd3pru3hv",
"x781dd3pru3hv")
self.assertEqual(valid, False)
#(10) Verifica que la clave tenga al menos un digito.
def test_PasswordDigit(self):
valid = self.seguridad.registrarUsuario("*****@*****.**",
"probandoPass", "probandoPass")
self.assertEqual(valid, False)
#(12) Verifica que se agrega el usuario al diccionario.
def test_AddUser(self):
diccionario = len(self.seguridad.users)
valid = self.seguridad.registrarUsuario("*****@*****.**",
"X7SJus62h7AHv",
"X7SJus62h7AHv")
diccionarioAdd = len(self.seguridad.users)
self.assertNotEqual(diccionario, diccionarioAdd)
#Verifica que el id de correo sea valido segun el estandar RFC 822.
def test_EmailValid(self):
valid = self.seguridad.registrarUsuario("[email protected]",
"X7SJus62h7AHv",
"X7SJus62h7AHv")
self.assertEqual(valid, False)
#Verifica que la clave tenga longitud menor que 17.
def test_PasswordMax(self):
valid = self.seguridad.registrarUsuario("[email protected]",
"X7SJus62h7AHvxxxx",
"X7SJus62h7AHvxxxx")
self.assertEqual(valid, False)
#Verifica que la clave tenga al menos tres letras.
def test_Password3(self):
valid = self.seguridad.registrarUsuario("[email protected]",
"9999163121A66o",
"9999163121A66o")
self.assertEqual(valid, False)
#Verifica que la clave tenga al menos una minuscula.
def test_PasswordKeyMin(self):
valid = self.seguridad.registrarUsuario("*****@*****.**",
"X781DD3PRU3HV",
"X781DD3PRU3HV")
self.assertEqual(valid, False)
#Verifica que las claves dadas como parametros sean iguales.
def test_SamePassword(self):
valid = self.seguridad.registrarUsuario("*****@*****.**",
"X7SJus62h7AHv",
"X7SJus62h7AHf")
self.assertEqual(valid, False)
def setUp(self):
self.seguridad = Seguridad()
class TestSeguridad(unittest.TestCase):
def setUp(self):
self.seguridad = Seguridad()
def tearDown(self):
self.seguridad = None
# Prueba 1. Caso interior. Se llama la funcion registrarUsuario()
# con un correo electronico valido y dos claves iguales.
# Caso interior. El valor esperado es que la funcion retorne True
# y almacene en el diccionario de Seguridad el usuario y la contraseña.
def test_registrar_usuario_1(self):
self.assertTrue(self.seguridad.registrarUsuario("*****@*****.**","mmM123MJ","mmM123MJ"))
# Resultado de primera ejecucion: Falla porque la funcion no esta definida.
# Resultado posterior: Retorna True, la funcion fue definida para retornar el valor
# Prueba 2. Caso frontera. Se llama la funcion registrarUsuario con un
# correo electronico invalido, y dos claves validas e iguales.
# El valor esperado es que la funcion retorne False y no almacene nada.
def test_registrar_usuario_correo_invalido(self):
self.assertFalse(self.seguridad.registrarUsuario("andresitorresm", "mmM123MJ", "mmM123MJ"))
# Resultado de primera ejecucion: Falla porque retorna True y no False
# Resultado de siguiente ejecucion: Retorna False, ahora se verifican los correos
# Prueba 2.5. Casos frontera. Se llama a la funcion es_correo_valido
# con dos correo electronico validos, uno invalido y uno vacio, para verificar
# que la funcion auxiliar programada es correcta.
# Los valores esperados son True, True, False y False
def test_es_correo_valido(self):
self.assertTrue(self.seguridad.es_correo_valido("*****@*****.**"))
self.assertTrue(self.seguridad.es_correo_valido("*****@*****.**"))
self.assertFalse(self.seguridad.es_correo_valido("14-11082"))
self.assertFalse(self.seguridad.es_correo_valido(""))
# Resultado de la primera ejecucion: La prueba pasa, se verifica que la funcion auxiliar es correcta
# Prueba 3. Caso frontera. Se llama la funcion registrarUsuario con un correo electronico
# valido pero con dos claves que no coinciden. Se espera que la funcion
# retorne False ya que las claves no son la misma.
def test_registrar_usuario_claves_distintas(self):
self.assertFalse(self.seguridad.registrarUsuario("*****@*****.**", "mmM123MK", "mmM132MJ"))
# Resultado de primera ejecucion: Falla porque la funcion solo verifica si el correo
# es valido o no
# Resultado de la siguiente ejecucion: Pasa, porque ahora se verifica
# que ambas claves sean la misma
# Prueba 3.5. Casos frontera. Se llama a la funcion claves_coinciden con
# dos pares de claves que coinciden, un par que no coincide, y dos pares de claves que
# alternan una estar vacia y la otra no, para verificar que la funcion
# auxiliar programada es correcta.
# Los valores esperados son True, True, False, False, False.
def test_claves_coinciden(self):
self.assertTrue(self.seguridad.claves_coinciden("clave1", "clave1"))
self.assertTrue(self.seguridad.claves_coinciden("4m1g0LDC", "4m1g0LDC"))
self.assertFalse(self.seguridad.claves_coinciden("clave1", "clave2"))
self.assertFalse(self.seguridad.claves_coinciden("clave1", ""))
self.assertFalse(self.seguridad.claves_coinciden("", "clave2"))
# Resultado de la primera ejecucion: Las pruebas pasan, y se verifica que la
# funcion auxiliar claves_coinciden cumplen con su cometido
# Prueba 4. Caso interior. Verificacion de longitud. Se llama la funcion
# con un correo electronico valido y dos claves que coinciden pero
# que estan por debajo o por encima del tamano permitido. Los valores esperados
# en las dos pruebas a realizar son False y False.
def test_registrar_usuario_longitud_claves(self):
self.assertFalse(self.seguridad.registrarUsuario("*****@*****.**", "m1", "m1"))
self.assertFalse(self.seguridad.registrarUsuario("*****@*****.**", "mmmmmJJJJJ1111133333", "mmmmmJJJJJ1111133333"))
# Resultado de primera ejecucion: Falla porque las claves coinciden y eso es todo lo
# que se valida hasta este punto.
# Resultado de siguiente ejecucion: Pasa, ya se valida la longitud de las
# claves.
# Prueba 4.5. Casos frontera. Se verifica el correcto funcionamiento de la
# funcion auxiliar tiene_longitud_correcta para conocer si la funcion labora
# de la manera correcta, con dos pares de contraseñas de longitud correcta,
# y dos pares de contraseñas de longitud incorrecta.
# Los resultados esperados son True, True y False, False
def test_longitud_correcta(self):
self.assertTrue(self.seguridad.clave_tiene_longitud_correcta("holaAmigo"))
self.assertTrue(self.seguridad.clave_tiene_longitud_correcta("hola12345687"))
self.assertFalse(self.seguridad.clave_tiene_longitud_correcta("clave"))
self.assertFalse(self.seguridad.clave_tiene_longitud_correcta("hola_estaes_una_clave_muy_larga"))
# Resultado de la primera ejecucion: las pruebas pasan porque la funcion se desempeña
# de la manera correcta
# Prueba 5. Caso interior. Verificacion de caracteres especiales. Se llama la funcion
# registrarUsuario con un correo electronico valido y claves que coinciden de igual longitud
# pero que incluyen simbolos especiales.
# El valor esperado es False, ya que solo se permiten numeros y letras en la clave.
def test_claves_caracteres_especiales(self):
self.assertFalse(self.seguridad.registrarUsuario("*****@*****.**", "hola1234_", "hola1234_"))
self.assertFalse(self.seguridad.registrarUsuario("*****@*****.**", "@m_g1.-_{", "@m_g1.-_{"))
# Resultado de la primera ejecucion: la prueba falla porque devuelve True, no se verifica
# que solo se permitan utilizar letras y numeros en las claves
# Resultado de la siguiente ejecucion: la prueba pasa porque ya verifica
# si la clave tiene simbolos permitidos
# Prueba 5.5. Verificacion de simbolos permitidos. Se llama la funcion
# clave_tiene_simbolos_permitidos con dos claves con simbolos validos y dos claves
# con simbolos invalidos para conocer si la funcion creada se comporta
# como deberia. Los resultados esperados son True, True, False, False.
def test_simbolos_especiales(self):
self.assertTrue(self.seguridad.clave_tiene_simbolos_permitidos("amigo"))
self.assertTrue(self.seguridad.clave_tiene_simbolos_permitidos("jfgnr1574"))
self.assertFalse(self.seguridad.clave_tiene_simbolos_permitidos("amigo-"))
self.assertFalse(self.seguridad.clave_tiene_simbolos_permitidos("4_$/#$%&1"))
# Resultado de la primera ejecucion: las pruebas pasan, por lo que la funcion
# verifica correctamente que solo se tengan simbolos del conjunto permitido
# Prueba 6. Se verifica que la clave debe contener ciertos patrones en las
# letras, a saber: al menos tres letras, de esas al menos una minuscula y una mayuscula.
# Se ejecuta la funcion con una clave que cumple con estos parametros y
# tres pares que no cumplen. El valor esperado es True para el primer caso y False para los
# otros tres. Esta prueba seria de interior y frontera.
def test_requerimientos_en_letras(self):
self.assertTrue(self.seguridad.registrarUsuario("*****@*****.**", "aAama1234", "aAama1234"))
self.assertFalse(self.seguridad.registrarUsuario("*****@*****.**", "aA123456", "aA123456"))
self.assertFalse(self.seguridad.registrarUsuario("*****@*****.**", "aa11bb22", "aa11bb22"))
self.assertFalse(self.seguridad.registrarUsuario("*****@*****.**", "12345678", "12345678"))
# Resultado de la primera ejecucion: La prueba falla porque todo retorna True, no se validan las
# condiciones de letras.
# Resultado de la segunda ejecucion: La prueba pasa ya que se verifican las
# cantidades de letras segun lo establecido.
# Prueba 6.5. Verificacion de funcion de letras minimas. Se ejecutan pruebas
# varias para la funcion clave_tiene_letras_minimas, con tres casos de claves que
# tienen las letras validas y tres que no las tienen. Se espera como resultado
# True, True, True, False, False, False. Estas pruebas son de frontera.
def test_letras_minimas(self):
self.assertTrue(self.seguridad.clave_tiene_letras_minimas("aaB"))
self.assertTrue(self.seguridad.clave_tiene_letras_minimas("amiGote1234"))
self.assertTrue(self.seguridad.clave_tiene_letras_minimas("BBr"))
self.assertFalse(self.seguridad.clave_tiene_letras_minimas("aa"))
self.assertFalse(self.seguridad.clave_tiene_letras_minimas("a1234124"))
self.assertFalse(self.seguridad.clave_tiene_letras_minimas("Ax12581879"))
# Resultado de la primera ejecucion: La prueba se ejecuta correctamente verificando que la
# funcion de verificacion de letras minimas esta correcta.
# Prueba 7. Se ejecuta la funcion registrarUsuario con una clave que no
# tiene digitos, conociendo que las claves deben tener al menos un digito como
# condicion minima de validez. Se llama con dos casos de prueba, uno que cumple con
# tener al menos un digito y otro que no lo tiene pero que cumplen con el
# resto de criterios. La prueba seria de interior y de frontera. Se espera que
# los valores sean True, False.
def test_tiene_digitos_minimos(self):
self.assertTrue(self.seguridad.registrarUsuario("*****@*****.**", "1amiGuito", "1amiGuito"))
self.assertFalse(self.seguridad.registrarUsuario("*****@*****.**", "amiGOami", "amiGOami"))
# Resultado de la primera ejecucion: La prueba se ejecuta y falla, ya que acepta todas las claves
# a pesar de que uan no tiene digitos.
# Resultado de la siguiente ejecucion: la prueba pasa tras refactorizar la funcion.
# Prueba 7.5. Se realizan pruebas varias de frontera e interior para
# verificar la validez de la funcion auxilizar clave_tiene_digitos_minimos,
# con dos casos validos y dos invalidos. Se esperan como resultados True, True,
# False, False.
def test_digitos_minimos(self):
self.assertTrue(self.seguridad.clave_tiene_digitos_minimos("12asdf"))
self.assertTrue(self.seguridad.clave_tiene_digitos_minimos("1"))
self.assertFalse(self.seguridad.clave_tiene_digitos_minimos("asdfgaewfaw"))
self.assertFalse(self.seguridad.clave_tiene_digitos_minimos("holaClave"))
# Resultado de la primera ejecucion: La prueba se ejecuta correctamente verificando que la
# funcion de verificacion de digitos minimos esta correcta.
# Prueba 8. Se llama la funcion para verificar que, si se inserta correctamente un
# email y un par de claves validas, se guarda en el diccinario el reverso de la clave
# asociada al mail. Esta prueba es de interior. El resultado esperado es que
# se retorne el reverso de la clave al acceder al diccionario.
def test_guardar_datos(self):
self.assertTrue(self.seguridad.registrarUsuario("*****@*****.**", "CLave1234", "CLave1234"))
self.assertEquals(self.seguridad.usuarios["*****@*****.**"], "4321evaLC")
# Resultado de la primera ejecucion: La prueba falla ya que no existe el diccionario,
# porque no hay flujo de almacenamiento de datos.
# Prueba 9. Se llama la funcion ingresarUsuarios con un correo de usuario y
# una clave registradas, para verificar que la funcion se ejecute correctamente.
# El caso esperado es que retorne True para hacer login. Al momento de escribir
# la prueba, la funcion no esta definida.
def test_ingresar_usuarios1(self):
self.assertTrue(self.seguridad.registrarUsuario("*****@*****.**", "mmM12345", "mmM12345"))
self.assertTrue(self.seguridad.ingresarUsuario("*****@*****.**", "mmM12345"))
# Resultado de la priemra ejecucion: la funcion falla porque no esta definida.
# El resultado de la siguien ejecucion: la prueba pasa porque la funcion esta definida y retorna True.
# Prueba 10. Se llama la funcion ingresarUsuarios con un correo de usuario invalido,
# esperando que la funcion falle al verificar si el correo es valido.
# El resultado esperado es que retorne False. Es una prueba frontera.
def test_ingresar_correo_invalido(self):
self.assertFalse(self.seguridad.ingresarUsuario("usuario.com", "mmM12345"))
# Resultado de la priemra ejecucion: la funcion falla porque siempre devuelve True.
# Resultado de la segunda ejecucion: la funcion retorna False y pasa la prueba.
# Prueba 11. Se llama la funcion ingresarUsuarios con un correo de usuario valido
# pero con contraseñas invalidas, esperando que la funcion falle al verificar
# la contraseña. El resutlado esperado es que retorne False. Es una prueba frontera.
def test_ingresar_clave_invalida(self):
self.assertFalse(self.seguridad.ingresarUsuario("*****@*****.**", "amigo"))
self.assertFalse(self.seguridad.ingresarUsuario("*****@*****.**", "233565465456"))
self.assertFalse(self.seguridad.ingresarUsuario("*****@*****.**", "!!aAami1234"))
# Resultado de la primera ejecucion: La funcion falla porque solo verifica la validez del correo.
# Resultado de la segunda ejecucion: La funcion retorna False en todos los casos
# porque ahora verifica la validez de la contraseña.
# Prueba 12. Se llama la funcion ingresarUsuario con un correo de usuario valido y
# una clave valida pero que no han sido registrados antes, esperando que la funcin
# falle el login. Es una prueba interior. El resultado esperado es que retorne False.
def test_ingresar_datos_correctos(self):
self.assertFalse(self.seguridad.ingresarUsuario("*****@*****.**", "aaA123456"))
# El resulatdo de la primera ejecucion: La funcion falla poqrue solo verifica que los formatos
# de correo y contraseña sean correctos.
# El resultado de la siguien ejecucion: La prueba pasa poqrue ya se verifica si la clave
# esta en el diccionario
# Prueba 12.5. Se verifica el funcionamiento de la funcion esta_en_diccionario
# que fue agregada de manera auxiliar para pasar la prueba 12. La prueba es de interior y
# de frontera. El resultado esperado, para los cuatro casos, son True, True, False
def test_esta_en_diccionario(self):
self.seguridad.usuarios['*****@*****.**'] = "amigo"[::-1]
self.seguridad.usuarios['*****@*****.**'] = "aaAa1234"[::-1]
self.assertTrue(self.seguridad.esta_en_diccionario("*****@*****.**", "amigo"))
self.assertTrue(self.seguridad.esta_en_diccionario("*****@*****.**", "aaAa1234"))
self.assertFalse(self.seguridad.esta_en_diccionario("*****@*****.**", "asdf15858"))
self.assertFalse(self.seguridad.esta_en_diccionario("*****@*****.**", "claveinvalida"))
class TestSeguridad(unittest.TestCase):
def setUp(self):
self.seguridad = Seguridad()
def tearDown(self):
self.seguridad = None
######################### PARTICION 1: LOS USUARIOS SE REGISTRAN SATISFACTORIAMENTE
######################### TIPO DE PRUEBA: FRONTERA
# FRONTERA MINIMA DE LONGITUD ACEPTABLE: 8 CARACTERES
'''
PRUEBA 1: Formato de contrasena
Tipo: Frontera
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Exactamente 3 letras
2) Exactamente una letra mayuscula
3) Nuemero de digitos 5
4) Longitud de 8 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_frontera_registrarUsuarioP1(self):
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "Maa15678",
"Maa15678"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "1And5200",
"1And5200"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "0Myf5430",
"0Myf5430"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "Ang00000",
"Ang00000"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "11Pmj111",
"11Pmj111"))
'''
PRUEBA 2: Formato de contrasena
Tipo: Frontera
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Exactamente 3 letras
2) Exactamente una letra minuscula
3) Nuemero de digitos 5
4) Longitud de 8 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_frontera_registrarUsuarioP2(self):
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "mAA15678",
"mAA15678"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "1aND5200",
"1aND5200"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "0mYF5430",
"0mYF5430"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "aNG00000",
"aNG00000"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "11pMJ111",
"11pMJ111"))
'''
PRUEBA 3: Formato de contrasena
Tipo: Frontera
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Numero de letras 7
2) Exactamente un digito
3) Numero de mayus/minus indeterminado
4) Longitud de 8 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_frontera_registrarUsuarioP3(self):
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "mAAaaaa8",
"mAAaaaa8"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "maNDmmm0",
"maNDmmm0"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "AmY1FFFf",
"AmY1FFFf"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "aNG0NGNG",
"aNG0NGNG"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "1MpMJMJM",
"1MpMJMJM"))
# FRONTERA MAXIMA DE LONGITUD ACEPTABLE: 16 CARACTERES
'''
PRUEBA 4: Formato de contrasena
Tipo: Frontera
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Exactamente 3 letras
2) Exactamente una letra mayuscula
3) Nuemero de digitos 13
4) Longitud de 16 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_frontera_registrarUsuarioP4(self):
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"Maa1567811111111",
"Maa1567811111111"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"1And520000000000",
"1And520000000000"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"0Myf543000000000",
"0Myf543000000000"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"Ang0000000000000",
"Ang0000000000000"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"11Pmj11111111111",
"11Pmj11111111111"))
'''
PRUEBA 5: Formato de contrasena
Tipo: Frontera
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Exactamente 3 letras
2) Exactamente una letra minuscula
3) Nuemero de digitos 13
4) Longitud de 16 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_frontera_registrarUsuarioP5(self):
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"mAA1567811111111",
"mAA1567811111111"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"1aND520000000000",
"1aND520000000000"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"0mYF543000000000",
"0mYF543000000000"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"aNG0000000000000",
"aNG0000000000000"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"11pMJ11111111111",
"11pMJ11111111111"))
'''
PRUEBA 6: Formato de contrasena
Tipo: Frontera
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Numero de letras 15
2) Exactamente un digito
3) Numero de mayus/minus indeterminado
4) Longitud de 16 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_frontera_registrarUsuarioP6(self):
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"mAAaaaa8aaaaaaaa",
"mAAaaaa8aaaaaaaa"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"maNDmmm0mmmmmmmm",
"maNDmmm0mmmmmmmm"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"AmY1FFFfmmmmmmmm",
"AmY1FFFfmmmmmmmm"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"aNG0NGNGaaaaaaaa",
"aNG0NGNGaaaaaaaa"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"1MpMJMJMpppppppp",
"1MpMJMJMpppppppp"))
######################### PARTICION 2: LOS USUARIOS No SE PUEDEN REGISTRAN error en formato de contrasena
######################### TIPO DE PRUEBA: FRONTERA
# TAMANO DE CONTRASENA FRONTERA NO ACEPTADO 7 CARACTERES / 17 CARACTERES
'''
PRUEBA 7: Formato de contrasena
Tipo: Frontera
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Exactamente 3 letras
2) Exactamente 1 letra mayuscula
3) Nuemero de digitos 4
4) Longitud de 7 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_frontera_registrarUsuarioP7(self):
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "Maa5678",
"Maa5678"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "And5200",
"And5200"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "Myf5430",
"Myf5430"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "Ang0000",
"An00000"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "1Mmj111",
"1Mmj111"))
'''
PRUEBA 8: Formato de contrasena
Tipo: Frontera
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Exactamente 3 letras
2) Exactamente una letra minuscula
3) Nuemero de digitos 4
4) Longitud de 7 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_frontera_registrarUsuarioP8(self):
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "mAA5678",
"mAA5678"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "aND5200",
"aND5200"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "mYF5430",
"mYF5430"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "aNG0000",
"aNG0000"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "11pMJ11",
"11pMJ11"))
'''
PRUEBA 9: Formato de contrasena
Tipo: Frontera
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Numero de letras 6
2) Exactamente un digito
3) Numero de mayus/minus indeterminado
4) Longitud de 7 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_frontera_registrarUsuarioP9(self):
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "mAAaaa8",
"mAAaaa8"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "maNDmm0",
"maNDmm0"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "AmY1FFF",
"AmY1FFF"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "aNG0NGN",
"aNG0NGN"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "1MpMJMJ",
"1MpMJMJ"))
# LONGITUD EN FRONTERA INVALIDA DE CONTRASENA 17 CARACTERES
'''
PRUEBA 10: Formato de contrasena
Tipo: Frontera
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Exactamente 3 letras
2) Exactamente una letra mayuscula
3) Nuemero de digitos 14
4) Longitud de 17 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_frontera_registrarUsuarioP10(self):
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"Maa15678111111111",
"Maa15678111111111"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"1And5200000000000",
"1And5200000000000"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"0Myf5430000000000",
"0Myf5430000000000"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"Ang00000000000000",
"Ang00000000000000"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"11Pmj111111111111",
"11Pmj111111111111"))
'''
PRUEBA 11: Formato de contrasena
Tipo: Frontera
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Exactamente 3 letras
2) Exactamente una letra minuscula
3) Nuemero de digitos 14
4) Longitud de 17 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_frontera_registrarUsuarioP11(self):
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"mAA15678111111111",
"mAA15678111111111"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"1aND5200000000000",
"1aND5200000000000"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"0mYF5430000000000",
"0mYF5430000000000"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"aNG00000000000000",
"aNG00000000000000"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"11pMJ111111111111",
"11pMJ111111111111"))
'''
PRUEBA 12: Formato de contrasena
Tipo: Frontera
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Numero de letras 16
2) Exactamente un digito
3) Numero de mayus/minus indeterminado
4) Longitud de 17 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_frontera_registrarUsuarioP12(self):
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"mmAAaaaa8aaaaaaaa",
"mmAAaaaa8aaaaaaaa"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"mmaNDmmm0mmmmmmmm",
"mmaNDmmm0mmmmmmmm"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"AmmY1FFFfmmmmmmmm",
"AmmY1FFFfmmmmmmmm"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"aNG0nNGNGaaaaaaaa",
"aNG0nNGNGaaaaaaaa"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"1MpMJMJMppppppppp",
"1MpMJMJMppppppppp"))
################################# PRUEBAS DE ESQUINA
########################## PARTICION 1: los usuarios se registran satisfactoriamente
# Tamano 8 y 16 caracteres y con tamano 7 y 17
##### PRUEBA 1 CON PRUEBA 3
##### EXACTAMENTE 1 DIGITO
##### EXACTAMENTE UNA LETRA MAYUSCULA
##### AL MENOS 3 LETRAS
##### PRUEBA 2 CON PRUEBA 3
##### EXACTAMENTE 1 DIGITO
##### EXACRAMENTE UNA LETRA MINUSCULA
##### EXACTAMENTE 3 LETRAS
##### Con frontera 8 caracteres #####
'''
PRUEBA 13: Formato de contrasena
Tipo: Esquina
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Al menos 3 letras
2) Exactamente una letra mayuscula
3) Nuemero de digitos 1
4) Longitud de 8 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_esquina_registrarUsuarioP13(self):
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "Maaaaaa8",
"Maaaaaa8"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "1Anddddd",
"1Anddddd"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "0Myfffff",
"0Myfffff"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "Ang0gggg",
"Ang0gggg"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "1pPmjjjj",
"1pPmjjjj"))
'''
PRUEBA 14: Formato de contrasena
Tipo: Esquina
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Al menos 3 letras
2) Exactamente una letra minuscula
3) Exactamente 1 digito
4) Longitud de 8 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_esquina_registrarUsuarioP14(self):
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "mAA1AAAA",
"mAA1AAAA"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "1aNDDDDD",
"1aNDDDDD"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "0mYFFFFF",
"0mYFFFFF"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "aNG0NNNN",
"aNG0NNNN"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**", "1pMJMJMJ",
"1pMJMJMJ"))
##### CON FRONTERA 16 CARACTERES. RESULTADO ESPERADO: el usuario se registra satisfactoriamente #####
##### PRUEBA 4 CON PRUEBA 6
##### EXACTAMENTE 1 DIGITO
##### EXACTAMENTE UNA LETRA MAYUSCULA
##### AL MENOS 3 LETRAS
##### PRUEBA 5 CON PRUEBA 6
##### EXACTAMENTE 1 DIGITO
##### EXACRAMENTE UNA LETRA MINUSCULA
##### AL MENOS 3 LETRAS
'''
PRUEBA 15: Formato de contrasena
Tipo: Esquina
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Al menos 3 letras
2) Exactamente una letra mayuscula
3) Exactamente un digito
4) Longitud de 16 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_esquina_registrarUsuarioP15(self):
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"Maa1aaaaaaaaaaaa",
"Maa1aaaaaaaaaaaa"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"1Anddddddddddddd",
"1Anddddddddddddd"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"0Myfffffffffffff",
"0Myfffffffffffff"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"Ang0gggggggggggg",
"Ang0gggggggggggg"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"1pPmjjjjjjjjjjjj",
"1pPmjjjjjjjjjjjj"))
'''
PRUEBA 16: Formato de contrasena
Tipo: Esquina
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Al menos 3 letras
2) Exactamente una letra minuscula
3) Exactamente un digito
4) Longitud de 16 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_esquina_registrarUsuarioP16(self):
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"mAA1AAAAAAAAAAAA",
"mAA1AAAAAAAAAAAA"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"1aNDDDDDDDDDDDDD",
"1aNDDDDDDDDDDDDD"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"0mYFFFFFFFFFFFFF",
"0mYFFFFFFFFFFFFF"))
self.assertTrue(
self.seguridad.registrarUsuario("*****@*****.**",
"1aNGJJJJJJJJJJJJ",
"1aNGJJJJJJJJJJJJ"))
##### CON FRONTERA NO VALIDA CON 7 CARACTERES. RESULTADO ESPERADO: el usuario NO se registra satisfactoriamente #####
##### PRUEBA 7 CON PRUEBA 9
##### EXACTAMENTE 1 DIGITO
##### EXACTAMENTE UNA LETRA MAYUSCULA
##### AL MENOS 3 LETRAS
##### PRUEBA 8 CON PRUEBA 9
##### EXACTAMENTE 1 DIGITO
##### EXACRAMENTE UNA LETRA MINUSCULA
##### AL MENOS 3 LETRAS
'''
PRUEBA 17: Formato de contrasena
Tipo: Esquina
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Al menos 3 letras
2) Exactamente 1 letra mayuscula
3) Exactamente 1 digito
4) Longitud de 7 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_esquina_registrarUsuarioP17(self):
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "Maaaaa8",
"Maaaaa8"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "Andddd5",
"Andddd5"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "Myffff0",
"Myffff0"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "Angggg0",
"Angggg0"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "1Mmjjjj",
"1Mmjjjj"))
'''
PRUEBA 18: Formato de contrasena
Tipo: Esquina
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Al menos 3 letras
2) Exactamente una letra minuscula
3) Exactamente un digito
4) Longitud de 7 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_malicia_registrarUsuarioP18(self):
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "mAA5AAA",
"mAA5AAA"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "aND5DDD",
"aND5DDD"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "mYF5FFF",
"mYF5FFF"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "aNG0GGG",
"aNG0GGG"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "1ppMJMJ",
"1ppMJMJ"))
##### CON FRONTERA NO VALIDA CON 17 CARACTERES. RESULTADO ESPERADO: el usuario NO se registra satisfactoriamente #####
##### PRUEBA 10 CON PRUEBA 12
##### EXACTAMENTE 1 DIGITO
##### EXACTAMENTE UNA LETRA MAYUSCULA
##### AL MENOS 3 LETRAS
##### PRUEBA 11 CON PRUEBA 12
##### EXACTAMENTE 1 DIGITO
##### EXACRAMENTE UNA LETRA MINUSCULA
##### AL MENOS 3 LETRAS
'''
PRUEBA 19: Formato de contrasena
Tipo: Esquina
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Al menos 3 letras
2) Exactamente una letra mayuscula
3) Exactamente 1 digito
4) Longitud de 17 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_esquina_registrarUsuarioP19(self):
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"Maa1aaaaaaaaaaaaa",
"Maa1aaaaaaaaaaaaa"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"1Andddddddddddddd",
"1Andddddddddddddd"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"0Myffffffffffffff",
"0Myffffffffffffff"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"Ang0ggggggggggggg",
"Ang0ggggggggggggg"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"1pPmjjjjjjjjjjjjj",
"1pPmjjjjjjjjjjjjj"))
'''
PRUEBA 20: Formato de contrasena
Tipo: Esquina
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que se registre el usuario de forma correcta con una contrasena
con:
Caracteristicas de contrasena:
1) Al menos 3 letras
2) Exactamente una letra minuscula
3) Exactamente un digito
4) Longitud de 17 caracteres
Caracteristicas de email:
1) email cumple con RFC 822
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_esquina_frontera_registrarUsuarioP20(self):
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"mAA1AAAAAAAAAAAAA",
"mAA1AAAAAAAAAAAAA"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"1aNDDDDDDDDDDDDDD",
"1aNDDDDDDDDDDDDDD"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"0mYFFFFFFFFFFFFFF",
"0mYFFFFFFFFFFFFFF"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**",
"1aNGJJJJJJJJJJJJJ",
"1aNGJJJJJJJJJJJJJ"))
########################################### CASOS DE PRUEBA DE MALICIA ####################################
########### PRUEBA MALICIOSA: correo invalido ##############
########### PROBAMOS FUNCION registrarUsuario ##############
'''
PRUEBA 21: Formato de correo
Tipo: Malicia
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que el usuario que se registre use como correo alguno
que cumpla el formato RFC 822. En este caso: Falta de ., com y @
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_malicia_registrarUsuarioP21(self):
self.assertFalse(
self.seguridad.registrarUsuario("mjgf@gmail", "Maa15678",
"Maa15678"))
self.assertFalse(
self.seguridad.registrarUsuario("andrescom", "1And5200",
"1And5200"))
self.assertFalse(
self.seguridad.registrarUsuario("mariafeixgmail.com", "0Myf5430",
"0Myf5430"))
self.assertFalse(
self.seguridad.registrarUsuario("angProco@gmailcom", "Ang00000",
"Ang00000"))
self.assertFalse(
self.seguridad.registrarUsuario("josegp.com", "11Pmj111",
"11Pmj111"))
'''
PRUEBA 22: Formato de correo
Tipo: Malicia
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que el usuario que se registre use como correo alguno
que cumpla el formato RFC 822. En este caso: caracteres especiales no aceptados
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_malicia_registrarUsuarioP22(self):
self.assertFalse(
self.seguridad.registrarUsuario("mjg##[email protected]", "Maa15678",
"Maa15678"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "1And5200",
"1And5200"))
self.assertFalse(
self.seguridad.registrarUsuario("mariafe^[email protected]", "0Myf5430",
"0Myf5430"))
self.assertFalse(
self.seguridad.registrarUsuario("angProco&&&@gmail.com",
"Ang00000", "Ang00000"))
self.assertFalse(
self.seguridad.registrarUsuario("[email protected]", "11Pmj111",
"11Pmj111"))
'''
PRUEBA 23: Formato de contrasena
Tipo: Malicia
Funcion a probar: registrarUsuario en seguridad.py
Descripcion del caso: se pone a prueba que el usuario que se registre use una contrasena
aceptada por el mecanismo de seguridad. En este caso: caracteres especiales (que no son
aceptados)
Resultado de la prueba: el usuario se registra satisfactoriamente
'''
def test_malicia_registrarUsuarioP23(self):
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "Maa$$15678",
"Maa$$15678"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "1And5200###",
"1And5200###"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "0Myf5430&",
"0Myf5430&"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "Ang*00000",
"Ang*00000"))
self.assertFalse(
self.seguridad.registrarUsuario("*****@*****.**", "11Pmj1!!11",
"11Pmj1!!11"))
def test_Seguridad_existe(self) -> 'void':
valid = Seguridad()
self.assertNotEqual(valid, None)
def setUp(self) -> 'void':
self.seguridad = Seguridad()
class SeguridadTestCase(unittest.TestCase):
def setUp(self) -> 'void':
self.seguridad = Seguridad()
def tearDown(self) -> 'void':
self.seguridad = None
#Verifica que exista la clase Seguridad.
def test_Seguridad_existe(self) -> 'void':
valid = Seguridad()
self.assertNotEqual(valid, None)
#Verifica que exista el metodo registrarUsuario.
def test_Seguridad_existe_metodo_registrar(self) -> 'void':
email = "*****@*****.**"
pswd1 = "U581Dd3pRu384"
pswd2 = "U581Dd3pRu384"
valid = self.seguridad.registrarUsuario(email, pswd1, pswd2)
self.assertNotEqual(valid, None)
#Verifica que el id de correo sea valido segun el estandar RFC 822.
def test_Seguridad_email_valido(self) -> 'void':
email = "[email protected]"
pswd1 = "U581Dd3pRu384"
pswd2 = "U581Dd3pRu384"
valid = self.seguridad.registrarUsuario(email, pswd1, pswd2)
self.assertEqual(valid, False)
#Verifica que la clave tenga longitud mayor que 7.
def test_Seguridad_clave_long_ocho_min(self) -> 'void':
email = "*****@*****.**"
pswd1 = "U5d3"
pswd2 = "U5d3"
valid = self.seguridad.registrarUsuario(email, pswd1, pswd2)
self.assertEqual(valid, False)
#Verifica que la clave tenga longitud menor que 17.
def test_Seguridad_clave_long_dieciseis_max(self) -> 'void':
email = "*****@*****.**"
pswd1 = "U581Dd3pRu384largo"
pswd2 = "U581Dd3pRu384largo"
valid = self.seguridad.registrarUsuario(email, pswd1, pswd2)
self.assertEqual(valid, False)
#Verifica que la clave no tenga caracteres no alfanumericos.
def test_Seguridad_clave_solo_alfanumericos(self) -> 'void':
email = "*****@*****.**"
pswd1 = "U581Dd3pRu384!"
pswd2 = "U581Dd3pRu384!"
valid = self.seguridad.registrarUsuario(email, pswd1, pswd2)
self.assertEqual(valid, False)
#Verifica que la clave tenga al menos tres letras.
def test_Seguridad_clave_min_tres_letras(self) -> 'void':
email = "*****@*****.**"
pswd1 = "1211163121o66o"
pswd2 = "1211163121o66o"
valid = self.seguridad.registrarUsuario(email, pswd1, pswd2)
self.assertEqual(valid, False)
#Verifica que la clave tenga al menos una mayuscula.
def test_Seguridad_clave_min_una_mayuscula(self) -> 'void':
email = "*****@*****.**"
pswd1 = "u581dd3pru384"
pswd2 = "u581dd3pru384"
valid = self.seguridad.registrarUsuario(email, pswd1, pswd2)
self.assertEqual(valid, False)
#Verifica que la clave tenga al menos una minuscula.
def test_Seguridad_clave_min_una_minuscula(self) -> 'void':
email = "*****@*****.**"
pswd1 = "U581DD3PRU384"
pswd2 = "U581DD3PRU384"
valid = self.seguridad.registrarUsuario(email, pswd1, pswd2)
self.assertEqual(valid, False)
#Verifica que la clave tenga al menos un digito.
def test_Seguridad_clave_min_un_digito(self) -> 'void':
email = "*****@*****.**"
pswd1 = "UsbiDdepRueba"
pswd2 = "UsbiDdepRueba"
valid = self.seguridad.registrarUsuario(email, pswd1, pswd2)
self.assertEqual(valid, False)
#Verifica que las claves dadas como parametros sean iguales.
def test_Seguridad_claves_iguales(self) -> 'void':
email = "*****@*****.**"
pswd1 = "U581Dd3pRu384"
pswd2 = "u581Dd3pRu384"
valid = self.seguridad.registrarUsuario(email, pswd1, pswd2)
self.assertEqual(valid, False)
#Verifica que se actualiza el diccionario, cuando los datos ingresados son
#correctos.
def test_Seguridad_se_actualiza_diccionario(self) -> 'void':
bfore = len(self.seguridad.users)
email = "*****@*****.**"
pswd1 = "U581Dd3pRu384"
pswd2 = "U581Dd3pRu384"
self.seguridad.registrarUsuario(email, pswd1, pswd2)
after = len(self.seguridad.users)
self.assertNotEqual(bfore, after)
#Verifica que exista un metodo ingresarUsuario.
def test_Seguridad_existe_metodo_ingresar(self) -> 'void':
self.seguridad.users["*****@*****.**"] = "U581Dd3pRu384"
email = "*****@*****.**"
pswd1 = "U581Dd3pRu384"
valid = self.seguridad.ingresarUsuario(email, pswd1)
self.assertEqual(valid, True)
#Verifica que se manejen los datos errados en el metodo ingresarUsuario.
def test_Seguridad_ingreasar_datos_incorrectos(self) -> 'void':
self.seguridad.users["*****@*****.**"] = "U581Dd3pRu384"
email = "*****@*****.**"
pswd1 = "U581Dd3xRu384"
valid = self.seguridad.ingresarUsuario(email, pswd1)
self.assertEqual(valid, False)
#Verifica que no se pueda registrar un usuario con un email existente.
def test_Seguridad_registrar_email_usado(self) -> 'void':
self.seguridad.users["*****@*****.**"] = "U581Dd3pRu384"
email = "*****@*****.**"
pswd1 = "U581Dd3xRu384"
pswd2 = "U581Dd3xRu384"
valid = self.seguridad.registrarUsuario(email, pswd1, pswd2)
self.assertEqual(valid, False)