def pruebas():
    # alta
    datos = DatosSocio()
    socio = datos.alta(Socio(dni=12345678, nombre='Juan', apellido='Perez'))
    assert socio.id > 0

    # baja
    assert datos.baja(socio.id) == True

    # buscar
    socio_2 = datos.alta(Socio(dni=12345679, nombre='Carlos',
                               apellido='Perez'))
    assert datos.buscar(socio_2.id) == socio_2

    # modificacion
    socio_3 = datos.alta(
        Socio(dni=12345680, nombre='Susana', apellido='Gimenez'))
    socio_3.nombre = 'Moria'
    socio_3.apellido = 'Casan'
    socio_3.dni = 13264587
    datos.modificacion(socio_3)
    socio_3_modificado = datos.buscar(socio_3.id)
    assert socio_3_modificado.id == socio_3.id
    assert socio_3_modificado.nombre == 'Moria'
    assert socio_3_modificado.apellido == 'Casan'
    assert socio_3_modificado.dni == 13264587

    # todos
    assert len(datos.todos()) == 2

    # borrar todos
    datos.borrar_todos()
    assert len(datos.todos()) == 0
    def test_regla_2_apellido_menor_3(self):
        # valida regla
        valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
        self.assertTrue(self.ns.regla_2(valido))

        # nombre menor a 3 caracteres
        invalido = Socio(dni=12345678, nombre='Manuel', apellido='B')
        self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
    def test_regla_2_apellido_mayor_15(self):
        # valida regla
        valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
        self.assertTrue(self.ns.regla_2(valido))

        # nombre menor a 3 caracteres
        invalido = Socio(dni=12345678,
                         nombre='Jose',
                         apellido='de San Martin y Matorras')
        self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
    def test_regla_2_nombre_mayor_15(self):
        # valida regla
        valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
        self.assertTrue(self.ns.regla_2(valido))

        # nombre menor a 3 caracteres
        invalido = Socio(dni=12345678,
                         nombre='Manuel Jose Joaquin',
                         apellido='Belgrano')
        self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
    def test_regla_1(self):
        #precondicion socio existente
        socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
        exito = self.ns.alta(socio)

        self.assertTrue(exito)
        #válido
        valido = Socio(dni=111222333, nombre='Jane', apellido='Doe')
        self.assertTrue(self.ns.regla_1(valido))

        #inválido
        invalido = Socio(dni=12345678, nombre='Jane', apellido='Doe')
        with self.assertRaises(DniRepetido):
            self.ns.regla_1(invalido)
    def test_regla_3(self):
        for i in range(0, 200):
            socio = Socio(dni=i, nombre='Juan', apellido='Perez')
            self.ns.alta(socio)

        with self.assertRaises(MaximoAlcanzado):
            self.ns.regla_3()
    def test_buscar(self):
        #socio existente
        socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
        exito = self.ns.alta(socio)
        self.assertTrue(self.ns.buscar(exito.id))

        #socio inexistente
        self.ns.baja(exito.id)
        self.assertFalse(self.ns.buscar(exito.id))
    def test_buscar_dni(self):
        #socio existente
        #socio existente
        socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
        exito = self.ns.alta(socio)
        self.assertTrue(self.ns.buscar_dni(exito.dni))

        #socio inexistente
        self.assertFalse(self.ns.buscar_dni(98765432))
    def test_todos(self):
        #precondición: 1 socio registrado
        self.ns.borrar_todos()
        socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
        exito = self.ns.alta(socio)
        self.assertTrue(exito)

        #logica
        cant = self.ns.todos()
        self.assertEqual(len(cant), 1)
    def test_alta(self):
        # pre-condiciones: no hay socios registrados
        self.assertEqual(len(self.ns.todos()), 0)

        # ejecuto la logica
        socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
        exito = self.ns.alta(socio)

        # post-condiciones: 1 socio registrado
        self.assertTrue(exito)
        self.assertEqual(len(self.ns.todos()), 1)
    def test_modificacion(self):
        # pre-condiciones: socio existe
        socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
        res = self.ns.alta(socio)
        self.assertTrue(res)

        # ejecuto la logica
        socio.nombre = 'Juan Carlos'
        exito = self.ns.modificacion(socio)
        self.assertTrue(exito)

        #inválido por longitud de nombre
        socio.nombre = 'Jose Manuel del corazon de Jesus'
        invalido = self.ns.modificacion(socio)
        self.assertFalse(invalido)

        #inválido por longitud de apellido
        socio.apellido = 'de San Martin y Matorras'
        invalido = self.ns.modificacion(socio)
        self.assertFalse(invalido)
Beispiel #12
0
    def guardarDatos(self):
        socio = Socio()
        socio.id = self.entryID.get()
        socio.dni = self.entryDNI.get()
        socio.apellido = self.entryApellido.get()
        socio.nombre = self.entryNombre.get()
        if self.tipo == 'alta':
            resp = self.master.agregar(socio)
            if type(resp) != Socio:
                self.error.set(resp)
            else:
                self.root.destroy()
                self.master.refresh_treeview()

        elif self.tipo == 'modificacion':
            resp = self.master.modificar(socio)
            if type(resp) != Socio:
                self.error.set(resp)
            else:
                self.root.destroy()
                self.master.refresh_treeview()