class TestBanco(unittest.TestCase):
    def setUp(self):
        self.cajero = Cajero()
        self.mejora = CajeroMejorado()
        self.deposito1 = [
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_1000()
        ]

        self.deposito2 = [
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500()
        ]

        self.deposito3 = [
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200()
        ]

    def test_deposito_10000(self):
        self.cajero.carga(self.deposito1)
        self.assertEqual(self.cajero.conteo(), (10000, 0, 0, 0, 10000))
        self.cajero.vaciado()

    def test_extraccion_5000_correcta(self):
        self.cajero.carga(self.deposito1)
        self.assertEqual(self.cajero.conteo(), (10000, 0, 0, 0, 10000))
        self.assertEqual(self.cajero.extraer(5000), (5, 0, 0, 0))
        self.cajero.vaciado()

    def test_extraccion_12000_incorrecta(self):
        self.cajero.carga(self.deposito1)
        self.assertEqual(self.cajero.conteo(), (10000, 0, 0, 0, 10000))
        self.assertEqual(self.cajero.extraer(12000),
                         "Error: Fondos del" + " banco insuficientes")
        self.cajero.vaciado()

    def test_extraccion_5520_incorrecta(self):
        self.cajero.carga(self.deposito1)
        self.assertEqual(self.cajero.conteo(), (10000, 0, 0, 0, 10000))
        self.assertEqual(self.cajero.extraer(5520),
                         "Error: El monto no " + "es multiplo de 100")
        self.cajero.vaciado()

    def test_deposito_20000(self):
        self.cajero.carga(self.deposito1 + self.deposito2)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 0, 0, 20000))
        self.cajero.vaciado()

    def test_extraer_5000_de_20000(self):
        self.cajero.carga(self.deposito1 + self.deposito2)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 0, 0, 20000))
        self.assertEqual(self.cajero.extraer(5000), (5, 0, 0, 0))
        self.cajero.vaciado()

    def test_extraccion_12000_de_20000(self):
        self.cajero.carga(self.deposito1 + self.deposito2)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 0, 0, 20000))
        self.assertEqual(self.cajero.extraer(12000), (10, 4, 0, 0))
        self.cajero.vaciado()

    def test_extraccion_12100_de_20000(self):
        self.cajero.carga(self.deposito1 + self.deposito2)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 0, 0, 20000))
        self.assertEqual(self.cajero.extraer(12100),
                         "No es posible realizar" + " esa combinacion")
        self.cajero.vaciado()

    def test_extraccion_7000_de_20000(self):
        self.mejora.carga(self.deposito1 + self.deposito2)
        self.assertEqual(self.mejora.conteo(), (10000, 10000, 0, 0, 20000))
        self.assertEqual(self.mejora.extraer_dinero_cambio(7000, 10.0),
                         (6, 2, 0, 0))
        self.cajero.vaciado()

    def test_deposito_23000(self):
        self.cajero.carga(self.deposito1 + self.deposito2 + self.deposito3)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 3000, 0, 23000))
        self.cajero.vaciado()

    def test_extraer_5000_de_23000(self):
        self.cajero.carga(self.deposito1 + self.deposito2 + self.deposito3)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 3000, 0, 23000))
        self.assertEqual(self.cajero.extraer(5000), (5, 0, 0, 0))
        self.cajero.vaciado()

    def test_extraccion_12000_de_23000(self):
        self.cajero.carga(self.deposito1 + self.deposito2 + self.deposito3)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 3000, 0, 23000))
        self.assertEqual(self.cajero.extraer(12000), (10, 4, 0, 0))
        self.cajero.vaciado()

    def test_extraccion_12100_de_23000(self):
        self.cajero.carga(self.deposito1 + self.deposito2 + self.deposito3)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 3000, 0, 23000))
        self.assertEqual(self.cajero.extraer(12100),
                         "No es posible realizar" + " esa combinacion")
        self.cajero.vaciado()

    def test_extraccion_7000_de_23000(self):
        self.mejora.carga(self.deposito1 + self.deposito2 + self.deposito3)
        self.assertEqual(self.mejora.conteo(), (10000, 10000, 3000, 0, 23000))
        self.assertEqual(self.mejora.extraer_dinero_cambio(7000, 10.0),
                         (6, 0, 5, 0))
        self.mejora.vaciado()

    def test_negativo_cambio_7000_de_23000(self):
        self.mejora.carga(self.deposito1 + self.deposito2 + self.deposito3)
        self.assertEqual(self.mejora.conteo(), (10000, 10000, 3000, 0, 23000))
        self.assertEqual(self.mejora.extraer_dinero_cambio(-7000, 10.0),
                         "Error: No se permiten montos negativos")
        self.mejora.vaciado()

    def test_negativo_7000_de_23000(self):
        self.mejora.carga(self.deposito1 + self.deposito2 + self.deposito3)
        self.assertEqual(self.mejora.conteo(), (10000, 10000, 3000, 0, 23000))
        self.assertEqual(self.mejora.extraer(-7000),
                         "Error: No se permiten " + "montos negativos")
        self.mejora.vaciado()

    def test_extraccion_8000_de_23000(self):
        self.mejora.carga(self.deposito1 + self.deposito2 + self.deposito3)
        self.assertEqual(self.mejora.conteo(), (10000, 10000, 3000, 0, 23000))
        self.assertEqual(self.mejora.extraer_dinero_cambio(8000, 10.0),
                         (7, 0, 5, 0))
        self.cajero.vaciado()
Exemple #2
0
class TestBanco(unittest.TestCase):
    def setUp(self):
        self.cajero = Cajero()
        self.mejora = CajeroMejorado()
        self.deposito1 = [
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_1000()
        ]

        self.deposito2 = [
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_500()
        ]

        self.deposito3 = [
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_200()
        ]

    def test_deposito_10000(self):
        self.cajero.carga(self.deposito1)
        self.assertEqual(self.cajero.conteo(), (10000, 0, 0, 0, 10000))
        self.cajero.vaciado()

    def test_extraccion_5000_correcta(self):
        self.cajero.carga(self.deposito1)
        self.assertEqual(self.cajero.conteo(), (10000, 0, 0, 0, 10000))
        self.assertEqual(self.cajero.extraer(5000), (5, 0, 0, 0))
        self.cajero.vaciado()

    def test_extraccion_12000_incorrecta(self):
        with self.assertRaises(ExcesoError):
            self.cajero.carga(self.deposito1)
            self.assertEqual(self.cajero.conteo(), (10000, 0, 0, 0, 10000))
            self.cajero.extraer(12000)
            self.cajero.vaciado()

    def test_extraccion_5520_incorrecta(self):
        with self.assertRaises(MultipoError):
            self.cajero.carga(self.deposito1)
            self.assertEqual(self.cajero.conteo(), (10000, 0, 0, 0, 10000))
            self.cajero.extraer(5520)
            self.cajero.vaciado()

    def test_deposito_20000(self):
        self.cajero.carga(self.deposito1 + self.deposito2)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 0, 0, 20000))
        self.cajero.vaciado()

    def test_extraer_5000_de_20000(self):
        self.cajero.carga(self.deposito1 + self.deposito2)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 0, 0, 20000))
        self.assertEqual(self.cajero.extraer(5000), (5, 0, 0, 0))
        self.cajero.vaciado()

    def test_extraccion_12000_de_20000(self):
        self.cajero.carga(self.deposito1 + self.deposito2)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 0, 0, 20000))
        self.assertEqual(self.cajero.extraer(12000), (10, 4, 0, 0))
        self.cajero.vaciado()

    def test_extraccion_12100_de_20000(self):
        self.cajero.carga(self.deposito1 + self.deposito2)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 0, 0, 20000))
        with self.assertRaises(CombinacionError):
            self.cajero.extraer(12100)
        self.cajero.vaciado()

    def test_extraccion_7000_de_20000(self):
        self.mejora.carga(self.deposito1 + self.deposito2)
        self.assertEqual(self.mejora.conteo(), (10000, 10000, 0, 0, 20000))
        self.assertEqual(self.mejora.extraer_dinero_cambio(7000, 10.0),
                         (6, 2, 0, 0))
        self.cajero.vaciado()

    def test_extraccion_7000_cambio_exceso(self):
        self.mejora.carga(self.deposito1 + self.deposito2)
        self.assertEqual(self.mejora.conteo(), (10000, 10000, 0, 0, 20000))
        with self.assertRaises(RangoError):
            self.mejora.extraer_dinero_cambio(7000, 500.0)
        self.cajero.vaciado()

    def test_extraccion_7000_cambio_negativo(self):
        self.mejora.carga(self.deposito1 + self.deposito2)
        self.assertEqual(self.mejora.conteo(), (10000, 10000, 0, 0, 20000))
        with self.assertRaises(RangoError):
            self.mejora.extraer_dinero_cambio(7000, -3)
        self.cajero.vaciado()

    def test_deposito_23000(self):
        self.cajero.carga(self.deposito1 + self.deposito2 + self.deposito3)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 3000, 0, 23000))
        self.cajero.vaciado()

    def test_extraer_5000_de_23000(self):
        self.cajero.carga(self.deposito1 + self.deposito2 + self.deposito3)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 3000, 0, 23000))
        self.assertEqual(self.cajero.extraer(5000), (5, 0, 0, 0))
        self.cajero.vaciado()

    def test_extraer_5000_sin_fondos(self):
        with self.assertRaises(VacioError):
            self.cajero.extraer(5000)

    def test_extraccion_7000_cambio_sin_fondos(self):
        with self.assertRaises(VacioError):
            self.mejora.extraer_dinero_cambio(7000, 10.0)

    def test_extraccion_12000_de_23000(self):
        self.cajero.carga(self.deposito1 + self.deposito2 + self.deposito3)
        self.assertEqual(self.cajero.conteo(), (10000, 10000, 3000, 0, 23000))
        self.assertEqual(self.cajero.extraer(12000), (10, 4, 0, 0))
        self.cajero.vaciado()

    def test_extraccion_12100_de_23000(self):
        with self.assertRaises(CombinacionError):
            self.cajero.carga(self.deposito1 + self.deposito2 + self.deposito3)
            self.assertEqual(self.cajero.conteo(),
                             (10000, 10000, 3000, 0, 23000))
            self.cajero.extraer(12100)
            self.cajero.vaciado()

    def test_extraccion_7000_de_23000(self):
        self.mejora.carga(self.deposito1 + self.deposito2 + self.deposito3)
        self.assertEqual(self.mejora.conteo(), (10000, 10000, 3000, 0, 23000))
        self.assertEqual(self.mejora.extraer_dinero_cambio(7000, 10.0),
                         (6, 0, 5, 0))
        self.mejora.vaciado()

    def test_negativo_cambio_7000_de_23000(self):
        with self.assertRaises(NegativoError):
            self.mejora.carga(self.deposito1 + self.deposito2 + self.deposito3)
            self.assertEqual(self.mejora.conteo(),
                             (10000, 10000, 3000, 0, 23000))
            self.mejora.extraer_dinero_cambio(-7000, 10.0)
            self.mejora.vaciado()

    def test_negativo_7000_de_23000(self):
        with self.assertRaises(NegativoError):
            self.mejora.carga(self.deposito1 + self.deposito2 + self.deposito3)
            self.assertEqual(self.mejora.conteo(),
                             (10000, 10000, 3000, 0, 23000))
            self.mejora.extraer(-7000)
            self.mejora.vaciado()

    def test_extraccion_8000_de_23000(self):
        self.mejora.carga(self.deposito1 + self.deposito2 + self.deposito3)
        self.assertEqual(self.mejora.conteo(), (10000, 10000, 3000, 0, 23000))
        self.assertEqual(self.mejora.extraer_dinero_cambio(8000, 10.0),
                         (7, 0, 5, 0))
        self.cajero.vaciado()
class Tablas():
    def __init__(self, nombre, apellido, tipo, mensaje, codigo, tipo_act,
                 dinero):

        self.db = DBCon()
        # Persona:
        self.nombre = nombre
        self.apellido = apellido
        self.tipo = tipo

        # Actividad:
        self.mensaje = mensaje
        self.codigo = codigo
        # Tipo_actividad:
        self.tipo_actividad = tipo_act
        # Dinero:
        self.dinero = dinero
        # Tipos:
        self.persona = ''
        self.generar_tipos()

    def generar_tipos(self):

        tipo = TipoActividadDao(self.db)

        if len(tipo.buscarTodos()) == 0:

            self.t1 = TipoActividad("Deposito", "Ingreso de dinero al banco")
            self.t2 = TipoActividad("Extracción", "Se extrae dinero del banco")
            self.t3 = TipoActividad("Extracción con cambio",
                                    "Se extrae dinero con cambio del banco")

            tipo.guardar(self.t1)
            tipo.guardar(self.t2)
            tipo.guardar(self.t3)
        self.generar_personas()

    def generar_personas(self):
        self.persona_dao = PersonaDao(self.db)
        self.persona = Persona(self.nombre, self.apellido, self.tipo)
        self.banco()

    def banco(self):

        self.deposito1 = [
            Billete_1000(),
            Billete_1000(),
            Billete_1000(),
            Billete_500(),
            Billete_500(),
            Billete_500(),
            Billete_200(),
            Billete_200(),
            Billete_200(),
            Billete_100(),
            Billete_100()
        ]
        self.cajero = Cajero()
        self.mejora = CajeroMejorado()

        if self.tipo_actividad == "t1":
            self.cajero.carga(self.dinero)
            self.resultado = "Se ha depositado $" + str(
                self.cajero.conteo()[-1])

        elif self.tipo_actividad == "t2":
            self.cajero.carga(self.deposito1)
            self.cajero.conteo()
            self.resultado = self.cajero.extraer(self.dinero[0])[-1]

        elif self.tipo_actividad == "t3":
            self.mejora.carga(self.deposito1)
            self.mejora.conteo()
            self.resultado = self.mejora.extraer_dinero_cambio(
                self.dinero[0], self.dinero[1])[-1]

        self.generar_actividades()

    def generar_actividades(self):
        actividadDao = ActividadDao(self.db)
        tipodao = TipoActividadDao(self.db)
        if self.tipo_actividad == "t1":

            actividades = Actividad(self.mensaje, self.codigo, self.resultado)
            tipo1 = tipodao.buscarPorID(1)

        if self.tipo_actividad == "t2":
            actividades = Actividad(self.mensaje, self.codigo, self.resultado)
            tipo1 = tipodao.buscarPorID(2)

        if self.tipo_actividad == "t3":
            actividades = Actividad(self.mensaje, self.codigo, self.resultado)
            tipo1 = tipodao.buscarPorID(3)

        actividades.tipo_actividad = tipo1.id
        actividadDao.guardar(actividades)

        (self.persona).lista_actividades.append(actividades)
        self.persona_dao.guardar(self.persona)