class Cajero_automatico_Test2(unittest.TestCase):
def setUp(self):
self.caj = Cajero_automatico()
self.mil_pesos = Billete_de_1000("pesos", "$")
self.quinientos_pesos = Billete_de_500("pesos", "$")
self.lista = []
for x in range(10):
self.lista.append(self.mil_pesos)
self.lista.append(self.quinientos_pesos)
self.lista.append(self.quinientos_pesos)
self.caj.agregar_dinero(self.lista)
def test_a(self):
contar = self.caj.contar_dinero()
self.assertEqual(
contar, "10 billetes de $1000, parcial $10000\n" +
"20 billetes de $500, parcial $10000\n"
"Total: $20000")
@parameterized.expand([
(5000, "5 billetes de $1000\n"),
(12000, "10 billetes de $1000\n4 billetes de $500\n"),
(12100, "Error. No hay una combinación de billetes que nos permita " +
"extraer ese monto")
])
def test_b(self, monto, respuesta):
extraer = self.caj.extraer_dinero(monto)
self.assertEqual(extraer, respuesta)
@parameterized.expand([(7000, 10,
"2 billetes de $500\n6 billetes de $1000\n")])
def test_e(self, monto, porcentaje, respuesta):
extraer = self.caj.extraer_dinero_cambio(monto, porcentaje)
self.assertEqual(extraer, respuesta)
def setUp(self):
self.caj = Cajero_automatico()
self.mil_pesos = Billete_de_1000("pesos", "$")
self.lista = []
for x in range(10):
self.lista.append(self.mil_pesos)
self.caj.agregar_dinero(self.lista)
class Cajero_automatico_Test4(unittest.TestCase):
def setUp(self):
self.caj = Cajero_automatico()
@parameterized.expand([
(500, 1000, PorcentajeError),
(-200, 25, ValorError),
(200, 10, CajeroVacioError)
])
def test_c(self, monto, porcentaje, error):
with self.assertRaises(error):
self.caj.extraer_dinero_cambio(monto, porcentaje)
def main():
caj = Cajero_automatico()
cien_pesos = Billete_de_100("pesos", "$")
dos_pesos = Billete_de_200("pesos", "$")
quin_pesos = Billete_de_500("pesos", "$")
mil_pesos = Billete_de_1000("pesos", "$")
caj.agregar_dinero([
mil_pesos, mil_pesos, mil_pesos, quin_pesos, mil_pesos, quin_pesos,
dos_pesos, cien_pesos, quin_pesos
])
print(caj.contar_dinero())
print(caj.extraer_dinero(3500))
print(caj.extraer_dinero(1800))
print(caj.extraer_dinero(4800))
print(caj.extraer_dinero(468))
print(caj.extraer_dinero(200))
print(caj.contar_dinero())
class Cajero_automatico_Test1(unittest.TestCase):
def setUp(self):
self.caj = Cajero_automatico()
self.mil_pesos = Billete_de_1000("pesos", "$")
self.lista = []
for x in range(10):
self.lista.append(self.mil_pesos)
self.caj.agregar_dinero(self.lista)
def test_a(self):
contar = self.caj.contar_dinero()
self.assertEqual(contar, "10 billetes de $1000, parcial $10000\n" +
"Total: $10000")
def test_b(self):
extraer = self.caj.extraer_dinero(5000)
self.assertEqual(extraer, "5 billetes de $1000\n")
@parameterized.expand([
(12000, CantidadError),
(5520, MultiplicidadError)
])
def test_c(self, monto, error):
with self.assertRaises(error):
self.caj.extraer_dinero(monto)
class Cajero_automatico_Test1(unittest.TestCase):
def setUp(self):
self.caj = Cajero_automatico()
self.mil_pesos = Billete_de_1000("pesos", "$")
self.lista = []
for x in range(10):
self.lista.append(self.mil_pesos)
self.caj.agregar_dinero(self.lista)
def test_a(self):
contar = self.caj.contar_dinero()
self.assertEqual(
contar, "10 billetes de $1000, parcial $10000\n" + "Total: $10000")
@parameterized.expand([
(5000, "5 billetes de $1000\n"),
(12000, "Error. Quiero sacar mas dinero de lo que puedo"),
(5520, "Error. El monto es incorrecto"),
])
def test_b(self, monto, respuesta):
extraer = self.caj.extraer_dinero(monto)
self.assertEqual(extraer, respuesta)
def setUp(self):
self.caj = Cajero_automatico()
def setUp(self):
self.cajero = Cajero_automatico()
self.billetes = []
class Test_cajero(unittest.TestCase):
def setUp(self):
self.cajero = Cajero_automatico()
self.billetes = []
@parameterized.expand([((0, 0, 0, 10), (0, 0, 0, 10000)),
((0, 0, 20, 10), (0, 0, 10000, 10000)),
((0, 15, 20, 10), (0, 3000, 10000, 10000))])
def test_contar_a(self, cantidades_iniciales, valores_parciales):
# set up
self.llenar_cajero(cantidades_iniciales[0], cantidades_iniciales[1],
cantidades_iniciales[2], cantidades_iniciales[3])
# contar
for idx, tipo_billete in enumerate(['100', '200', '500', '1000']):
self.assertEqual(self.cajero.valores[tipo_billete],
valores_parciales[idx])
self.assertEqual(self.cajero.valor_total, sum(valores_parciales))
@parameterized.expand([
((0, 0, 0, 10), 5000, [0, 0, 0, 5]),
((0, 0, 20, 10), 5000, [0, 0, 0, 5]),
((0, 15, 20, 10), 5000, [0, 0, 0, 5]),
((0, 0, 0, 10), 12000,
"Error. Quiero sacar mas dinero de lo que puedo"),
((0, 0, 20, 10), 12000, [0, 0, 4, 10]),
((0, 15, 20, 10), 12000, [0, 0, 4, 10]),
((0, 0, 0, 10), 5520, "Error. El monto es incorrecto"),
((0, 0, 20, 10), 12100,
"Error. No hay una combinacion de billetes que nos permita extraer ese monto"
),
((0, 15, 20, 10), 12100,
"Error. No hay una combinacion de billetes que nos permita extraer ese monto"
),
])
def test_extraccion(self, cantidades_iniciales, monto_extraer,
ext_esperado):
# set up
self.llenar_cajero(cantidades_iniciales[0], cantidades_iniciales[1],
cantidades_iniciales[2], cantidades_iniciales[3])
# extraer
try:
billetes_ext = self.cajero.extraer_dinero(monto_extraer)
except Monto_incorrecto as context:
self.assertEqual(ext_esperado, context.message)
else:
extraccion = self.contar_extraccion(billetes_ext)
self.assertEqual(extraccion, ext_esperado)
@parameterized.expand([
((0, 0, 20, 10), 7000, 10, [0, 0, 2, 6]),
((0, 15, 20, 10), 7000, 10, [0, 5, 0, 6]),
])
def test_extraer_con_cambio(self, cantidades_iniciales, monto_extraer,
cambio, ext_esperado):
# set up
self.llenar_cajero(cantidades_iniciales[0], cantidades_iniciales[1],
cantidades_iniciales[2], cantidades_iniciales[3])
# extraer
billetes_ext = self.cajero.extraer_dinero_cambio(monto_extraer, cambio)
extraccion = self.contar_extraccion(billetes_ext)
self.assertEqual(extraccion, ext_esperado)
def llenar_cajero(self, billetes_de_100, billetes_de_200, billetes_de_500,
billetes_de_1000):
for _ in range(billetes_de_100):
billete = B.Billete_de_100()
self.billetes.append(billete)
for _ in range(billetes_de_200):
billete = B.Billete_de_200()
self.billetes.append(billete)
for _ in range(billetes_de_500):
billete = B.Billete_de_500()
self.billetes.append(billete)
for _ in range(billetes_de_1000):
billete = B.Billete_de_1000()
self.billetes.append(billete)
self.cajero.agregar_dinero(self.billetes)
def contar_extraccion(self, billetes_ext):
extraccion = [0, 0, 0, 0]
try:
for billete in billetes_ext:
if billete.denominacion == '100':
extraccion[0] += 1
if billete.denominacion == '200':
extraccion[1] += 1
if billete.denominacion == '500':
extraccion[2] += 1
if billete.denominacion == '1000':
extraccion[3] += 1
except AttributeError:
extraccion = billetes_ext
return extraccion
def setUp(self):
self.caj = Cajero_automatico()
self.mil_pesos = Billete_de_1000("pesos", "$")
self.quinientos_pesos = Billete_de_500("pesos", "$")
class Broker_Test(unittest.TestCase):
def setUp(self):
self.caj = Cajero_automatico()
self.mil_pesos = Billete_de_1000("pesos", "$")
self.quinientos_pesos = Billete_de_500("pesos", "$")
@parameterized.expand([
(500, 1000, "Error. El porcentaje es incorrecto"),
(-200, 25, "Error. No se puede extraer cantidades de "
"dinero negativas"),
(200, 10, "Error. No se puede extraer dinero si el cajero esta vacio")
])
def test_errores_de_actividades_porcentaje(self, monto, porcentaje, error):
broker = Broker(
[42670460, "Lucas", "Soria", False],
["Voy a comprar algo con 500 pesos", 2, monto, porcentaje],
self.caj)
broker.registrar_actividad()
actDAO = ActividadDao(broker.db)
actividades = actDAO.buscarTodos()
actividad = actividades[0]
actDAO.borrar(actividades[0])
self.assertEqual(actividad.mensaje, error)
@parameterized.expand([(12000, "Error. No se puede extraer mas dinero del"
" que hay disponible en el cajero"),
(5520, "Error. No se puede extraer dinero que"
" no sea múltiplo de 100")])
def test_errores_de_actividades(self, monto, error):
broker = Broker([42670460, "Lucas", "Soria", False],
["Voy a comprar algo con 500 pesos", 1, monto],
self.caj)
self.lista = []
for x in range(6):
self.lista.append(self.mil_pesos)
self.lista.append(self.quinientos_pesos)
self.caj.agregar_dinero(self.lista)
broker.registrar_actividad()
actDAO = ActividadDao(broker.db)
actividades = actDAO.buscarTodos()
actividad = actividades[0]
actDAO.borrar(actividades[0])
self.assertEqual(actividad.mensaje, error)
@parameterized.expand([(5000, "5 billetes de $1000\n"),
(12000,
"10 billetes de $1000\n4 billetes de $500\n")])
def test_sin_cambio_sin_error(self, monto, respuesta):
broker = Broker([42670460, "Lucas", "Soria", False],
["Voy a comprar algo con 500 pesos", 1, monto],
self.caj)
self.lista = []
for x in range(10):
self.lista.append(self.mil_pesos)
for x in range(4):
self.lista.append(self.quinientos_pesos)
self.caj.agregar_dinero(self.lista)
broker.registrar_actividad()
actDAO = ActividadDao(broker.db)
actividades = actDAO.buscarTodos()
actividad = actividades[0]
actDAO.borrar(actividades[0])
self.assertEqual(actividad.mensaje, respuesta)
@parameterized.expand([(7000, 10,
"2 billetes de $500\n6 billetes de $1000\n")])
def test_con_cambio_sin_error(self, monto, porcentaje, respuesta):
broker = Broker(
[42670460, "Lucas", "Soria", False],
["Voy a comprar algo con 500 pesos", 2, monto, porcentaje],
self.caj)
self.lista = []
for x in range(17):
self.lista.append(self.mil_pesos)
self.lista.append(self.quinientos_pesos)
self.lista.append(self.quinientos_pesos)
self.caj.agregar_dinero(self.lista)
broker.registrar_actividad()
actDAO = ActividadDao(broker.db)
actividades = actDAO.buscarTodos()
actividad = actividades[0]
actDAO.borrar(actividades[0])
self.assertEqual(actividad.mensaje, respuesta)
def test_contar(self):
broker = Broker([42670460, "Lucas", "Soria", False], [
"Voy a comprar algo con 500 pesos",
3,
], self.caj)
broker.registrar_actividad()
actDAO = ActividadDao(broker.db)
actividades = actDAO.buscarTodos()
actividad = actividades[0]
actDAO.borrar(actividades[0])
self.assertEqual(actividad.mensaje, "Total: $0")
def test_error_billetes(self):
broker = Broker([42670460, "Lucas", "Soria", False],
["Voy a comprar algo con 500 pesos", 1, 12100],
self.caj)
self.lista = []
for x in range(17):
self.lista.append(self.mil_pesos)
self.caj.agregar_dinero(self.lista)
broker.registrar_actividad()
actDAO = ActividadDao(broker.db)
actividades = actDAO.buscarTodos()
actividad = actividades[0]
actDAO.borrar(actividades[0])
self.assertEqual(
actividad.mensaje, "Error. No hay una combinación"
" de billetes que nos permita"
" extraer ese monto")
def test_insertar(self):
self.lista = []
for x in range(17):
self.lista.append(self.mil_pesos)
broker = Broker([42670460, "Lucas", "Soria", False],
["Voy a comprar algo con 500 pesos", 4, self.lista],
self.caj)
broker.registrar_actividad()
actDAO = ActividadDao(broker.db)
actividades = actDAO.buscarTodos()
actividad = actividades[0]
actDAO.borrar(actividades[0])
self.assertEqual(actividad.mensaje, "Se ingreso dinero correctamente")