class Crear_Actividad_test_case(unittest.TestCase):
def setUp(self):
'''Crea una colección para hacer las pruebas'''
self.cuentas_claras = Cuentas_claras()
'''Abre la sesión'''
self.session = Session()
self.data_factory = Faker()
Faker.seed(1000)
# crear actividades random
self.actividades = []
for _ in range(10):
actividad = Actividad(self.data_factory.unique.name())
self.actividades.append(actividad)
self.session.close()
def tearDown(self):
'''Abre la sesión'''
self.session = Session()
'''Consulta todas las actividades'''
actividades = self.session.query(Actividad).all()
'''Borra todas las actividades'''
for actividad in actividades:
self.session.delete(actividad)
self.session.commit()
self.session.close()
def test_listar_actividades_caso_vacio(self):
actividades = self.cuentas_claras.dar_actividad_por_id(2)
self.assertIsNot(actividades, 0)
def test_agregar_actividad_con_exito(self):
"""Validar que se agregue actividad nueva"""
rand_act1 = self.actividades[0]
res1 = self.cuentas_claras.agregar_actividad(rand_act1.dar_nombre())
actividad1 = self.session.query(Actividad).filter(
Actividad.nombre == rand_act1.dar_nombre()).first()
nombre_actividad = actividad1.dar_nombre()
self.assertIsNotNone(actividad1)
self.assertTrue(res1)
self.assertEqual(nombre_actividad, rand_act1.dar_nombre())
def test_actividad_duplicada(self):
"""Validar que no se agregue actividad cuando este ya exista"""
rand_act1 = self.actividades[0]
self.cuentas_claras.agregar_actividad(rand_act1.dar_nombre())
res = self.cuentas_claras.agregar_actividad(rand_act1.dar_nombre())
self.assertIsNone(res)
class AlbumTestCase(unittest.TestCase):
def setUp(self):
self.session = Session()
self.coleccion = Coleccion()
def testAgregarAlbum(self):
self.coleccion.agregar_album("Mio", 2000, "Sin descripción", "CD")
self.coleccion.agregar_album("Clara luna", 1992, "Sin descripción",
"CASETE")
self.consulta1 = self.session.query(Album).filter(
Album.titulo == "Mio").first()
self.consulta2 = self.session.query(Album).filter(
Album.id == 2).first()
self.assertEqual(self.consulta1.titulo, "Mio")
self.assertIsNotNone(self.consulta2)
def testEditarAlbum(self):
self.coleccion.editar_album(2, "Clara luna-Mix", 1982,
"Sin descripción", "DISCO")
self.consulta = self.session.query(Album).filter(Album.id == 2).first()
self.assertIsNot(self.consulta.titulo, "Clara luna")
def testDarAlbumPorId(self):
self.coleccion.agregar_album("Infinito arcoiris", 1990,
"Sin descripción", "CASETE")
self.album_id = self.session.query(Album).filter(
Album.titulo == "Infinito arcoiris").first().id
self.consulta = self.coleccion.dar_album_por_id(
self.album_id)["titulo"]
self.assertEqual(self.consulta, "Infinito arcoiris")
def eliminar_actividad(self, indice_actividad):
"""
Esta función elimina una actividad en la lógica (debe modificarse cuando se construya la lógica)
"""
session = Session() # Ivan
session.query(Actividad).filter(
Actividad.id == indice_actividad).delete() # Ivan
session.commit() # Ivan
session.close() # Ivan
self.logica = Logica_mock() # Ivan
self.vista_lista_actividades.mostrar_actividades(
self.logica.actividades)
class InterpreteTestCase(unittest.TestCase):
def setUp(self):
self.session = Session()
self.coleccion = Coleccion()
def testAgregarInterprete(self):
self.coleccion.agregarInterprete("Adele", "La artista tenia gripa..." , -1)
self.consulta = self.session.query(Interprete).filter(Interprete.nombre == "Adele").first().nombre
self.assertEqual(self.consulta, "Adele")
def testEditarInterprete(self):
self.coleccion.agregarInterprete("Lady Gaga", "Los trajes usados...", -1)
self.consulta1 = self.session.query(Interprete).filter(Interprete.nombre == "Lady Gaga").first().id
self.consulta2 = self.coleccion.editarInterprete(self.consulta1, "Lady Gaga", "Los trajes usados fueron elaborados...")
self.assertTrue(self.consulta2)
def testEliminarInterprete(self):
self.coleccion.eliminarInterprete(1)
self.consulta = self.session.query(Interprete).filter(Interprete.id == 1).first()
self.assertIsNone(self.consulta)
def testBuscarCancionesPorInterprete(self):
self.consulta1 = self.session.query(Interprete).filter(Interprete.nombre == "Pipe Pelaez").first()
if self.consulta1 is None:
self.coleccion.agregarInterprete("Pipe Pelaez", "Primera canción vallenata...", -1)
self.coleccion.agregarCancion("Tan natural", 2, 53, "Manuel Julian", -1,
[{'id':'n', 'nombre': 'Pipe Pelaez', 'texto_curiosidades': 'Primera canción vallenata...'}])
self.consulta2 = self.coleccion.buscarCancionesPorInterprete("pipe")
self.assertEqual(len(self.consulta2), 1)
def testBuscarInterpretesPorNombre(self):
self.coleccion.agregarInterprete("Freddie Mercury", "Primera canción como solista", -1)
self.coleccion.agregarInterprete("Freddy Burbano", "Canción que lo catapultó al éxito", -1)
self.consulta = self.coleccion.buscarInterpretesPorNombre("fredd")
self.assertEqual(len(self.consulta), 2)
def testDarInterpretes(self):
self.coleccion.agregarInterprete("Juan Gabriel", "Al finalizar el concierto en...", -1)
self.consulta = self.coleccion.darInterpretes()
self.assertGreater(len(self.consulta), 0)
def testDarInterpretePorId(self):
self.coleccion.agregarInterprete("Shakira", "La artista tenía el cabello color rojo", -1)
self.interprete_id = self.session.query(Interprete).filter(Interprete.nombre == "Shakira").first().id
self.consulta = self.coleccion.darInterpretePorId(self.interprete_id)["nombre"]
self.assertEqual(self.consulta, "Shakira")
class ActividadTestCase(unittest.TestCase):
def tearDown(self):
'''Abrir la session'''
self.session = Session()
'''Consulta todas las actividades'''
busqueda = self.session.query(Actividad).all()
'''Borrar todos los albums'''
for actividad in busqueda:
self.session.delete(actividad)
self.session.commit()
self.session.close()
def setUp(self):
'''crear la coleccion de funcionalidades a probar'''
self.coleccion = Coleccion()
'''abrir la sesion'''
self.session = Session()
'''crea una instancia de la clase Faker'''
self.data_factory = Faker()
'''semilla para datos pseudo-aleatorios'''
Faker.seed(10)
'''Genera 5 datos pseudo-aleatorios de actividades'''
self.data = []
self.actividades = []
for i in range(0, 10):
self.data.append(self.data_factory.unique.name())
self.actividades.append(Actividad(nombre=self.data[-1]))
self.session.add(self.actividades[-1])
self.session.commit()
def test_constructor(self):
for actividad, dato in zip(self.actividades, self.data):
self.assertEqual(actividad.nombre, dato)
def test_insertar_la_actividad(self):
'''Prueba la adicion de una actividad'''
self.data.append(self.data_factory.unique.name())
resultado = self.coleccion.insertar_la_actividad(nombre=self.data[-1])
self.assertEqual(resultado, True)
def test_editar_la_actividad(self):
'''Prueba la edicion de una actividad'''
self.nombre_repetido = random.choice(self.data)
self.data.append(self.data_factory.unique.name())
resultado = self.coleccion.editar_la_actividad(self.nombre_repetido,
self.data[-1])
self.assertEqual(resultado, True)
def test_eliminar_la_actividad(self):
'''Prueba la eliminacion de una actividad'''
self.actividad_repetida = random.choice(self.data)
resultado = self.coleccion.eliminar_la_actividad(
self.actividad_repetida)
self.assertEqual(resultado, True)
class Listar_actividades_test_case(unittest.TestCase):
def setUp(self):
'''Crea una colección para hacer las pruebas'''
self.cuentas_claras = Cuentas_claras()
'''Abre la sesión'''
self.session = Session()
'''Crear Faker '''
self.data_factory = Faker()
Faker.seed(1000)
'''Crea las actividades'''
# crear actividades random
self.actividades = []
for _ in range(3):
actividad = Actividad(nombre=self.data_factory.text())
self.session.add(actividad)
self.actividades.append(actividad)
'''Persiste los objetos y cierra la sesión'''
self.session.commit()
def tearDown(self):
'''Abre la sesión'''
self.session = Session()
'''Consulta todas las actividades'''
actividades = self.session.query(Actividad).all()
'''Borra todas las actividades'''
for actividad in actividades:
self.session.delete(actividad)
self.session.commit()
self.session.close()
def test_listar_actividades_caso_vacio(self):
self.tearDown()
actividades = self.cuentas_claras.listar_actividades()
self.assertIsNone(actividades)
def test_validar_numero_actividades(self):
actividades = self.cuentas_claras.listar_actividades()
self.assertEqual(len(actividades), 3)
for actividad in actividades:
self.assertIsInstance(actividad, str)
def test_validar_orden_actividades(self):
actividades = self.cuentas_claras.listar_actividades()
actividades_ordena = []
for actividad in self.actividades:
actividades_ordena.append(actividad.dar_nombre())
for i, actividad in enumerate(sorted(actividades_ordena)):
self.assertEqual(actividad, actividades[i])
class AlbumTestCase(unittest.TestCase):
def setUp(self):
self.session = Session()
self.coleccion = Coleccion()
def testAgregarAlbum(self):
self.coleccion.agregarAlbum("Mio", 2000, "Sin descripción", "CD")
self.coleccion.agregarAlbum("Clara luna", 1992, "Sin descripción", "CASETE")
self.consulta1 = self.session.query(Album).filter(Album.titulo == "Mio").first()
self.consulta2 = self.session.query(Album).filter(Album.id == 2).first()
self.assertEqual(self.consulta1.titulo, "Mio")
self.assertIsNotNone(self.consulta2)
def testEditarAlbum(self):
self.coleccion.editarAlbum(2, "Clara luna-Mix", 1982, "Sin descripción", "DISCO")
self.consulta = self.session.query(Album).filter(Album.id == 2).first()
self.assertIsNot(self.consulta.titulo, "Clara luna")
def testEliminarAlbum(self):
self.coleccion.eliminarAlbum(1)
self.consulta = self.session.query(Album).filter(Album.id == 1).first()
self.assertIsNone(self.consulta)
def testBuscarAlbumesPorTitulo(self):
self.consulta1 = self.coleccion.buscarAlbumesPorTitulo("clara luna")
self.coleccion.agregarAlbum("Clara luna-Instrumental", 1992, "Sin descripción", "CD")
self.consulta2 = self.coleccion.buscarAlbumesPorTitulo("clara luna")
self.assertGreater(len(self.consulta2), len(self.consulta1))
def testDarAlbumPorId(self):
self.coleccion.agregarAlbum("Infinito arcoiris", 1990, "Sin descripción", "CASETE")
self.album_id = self.session.query(Album).filter(Album.titulo == "Infinito arcoiris").first().id
self.consulta = self.coleccion.darAlbumPorId(self.album_id)["titulo"]
self.assertEqual(self.consulta, "Infinito arcoiris")
def testDarAlbumes(self):
self.consulta1 = self.coleccion.darAlbumes()
self.coleccion.agregarAlbum("New life", 2018, "Album escrito para...", "CD")
self.consulta2 = self.coleccion.darAlbumes()
self.assertGreater(len(self.consulta2), len(self.consulta1))
class ActividadTestCases(unittest.TestCase):
def setUp(self):
'''Crea un listado de actividades para hacer las pruebas'''
self.listado = Listado()
'''Abre la sesión'''
self.session = Session()
'''Crea los objetos'''
self.actividad1 = Actividad(nombre='Actividad 1')
self.actividad2 = Actividad(nombre='Actividad 2')
self.gasto1 = Gasto(concepto="Comida",
valor=100,
fecha=51000,
actividad='Actividad 1',
viajero='Juan Perez')
self.gasto2 = Gasto(concepto="Transporte",
valor=200,
fecha=51001,
actividad='Actividad 2',
viajero='Rosa Gomez')
'''Adiciona los objetos a la sesión'''
self.session.add(self.actividad1)
self.session.add(self.actividad2)
self.session.add(self.gasto1)
self.session.add(self.gasto2)
'''Persiste los objetos y cierra la sesión'''
self.session.commit()
self.session.close()
def tearDown(self):
'''Abre la sesión'''
self.session = Session()
'''Consulta todas las actividades'''
busqueda = self.session.query(Actividad).all()
'''Borra todas las actividades'''
for actividad in busqueda:
self.session.delete(actividad)
self.session.commit()
self.session.close()
def test_elemento_en_conjunto(self):
'''Prueba que un elemento se encuentre en un conjunto'''
conjunto = [self.actividad1, self.actividad2]
self.assertIn(self.actividad1, conjunto)
# self.assertNotIn(self.actividad4, conjunto)
def test_instancia_clase(self):
'''Prueba que un elemento sea de una clase'''
self.assertIsInstance(self.actividad1, Actividad)
self.assertNotIsInstance(self.listado, Actividad)
def test_prueba(self):
self.assertEqual(0, 0)
class ViajeroTestCase(unittest.TestCase):
def tearDown(self):
'''Abrir la session'''
self.session = Session()
'''Consulta todas las actividades'''
busqueda = self.session.query(Viajero).all()
'''Borrar todos los albums'''
for viajero in busqueda:
self.session.delete(viajero)
self.session.commit()
self.session.close()
def setUp(self):
'''crear la coleccion de funcionalidades a probar'''
self.coleccion = Coleccion()
'''abrir la sesion'''
self.session = Session()
'''crea una instancia de la clase Faker'''
self.data_factory = Faker()
'''semilla para datos pseudo-aleatorios'''
Faker.seed(10)
'''Genera 5 datos pseudo-aleatorios de viajeros'''
self.data = []
self.viajeros = []
for i in range(0, 10):
self.data.append((self.data_factory.unique.name(), self.data_factory.unique.name()))
self.viajeros.append(
Viajero(nombre=self.data[-1][0], apellido=self.data[-1][1]))
self.session.add(self.viajeros[-1])
self.session.commit()
def test_constructor(self):
for viajero, dato in zip(self.viajeros, self.data):
self.assertEqual(viajero.nombre, dato[0])
self.assertEqual(viajero.apellido, dato[1])
def test_insertar_el_viajero(self):
'''Prueba la adicion de viajero'''
self.data.append((self.data_factory.unique.name(), self.data_factory.unique.name()))
resultado = self.coleccion.insertar_el_viajero(nombre=self.data[-1][0], apellido=self.data[-1][1])
self.assertEqual(resultado, True)
def editar_actividad(self, indice_actividad, nombre):
"""
Esta función editar una actividad en la lógica (debe modificarse cuando se construya la lógica)
"""
session = Session() # Ivan
nombre_a_editar = session.query(Actividad).get(
indice_actividad) # Ivan
nombre_a_editar.nombre = nombre # Ivan
session.commit() # Ivan
session.close() # Ivan
self.logica = Logica_mock() # Ivan
self.vista_lista_actividades.mostrar_actividades(
self.logica.actividades)
class ActividadTestCase(unittest.TestCase):
def tearDown(self):
self.session = Session()
'''Abrir la session'''
self.session = Session()
'''Consulta todas las actividades'''
busqueda = self.session.query(Actividad).all()
'''Borrar todos los albums'''
for actividad in busqueda:
self.session.delete(actividad)
self.session.commit()
self.session.close()
def setUp(self):
'''Crea una coleccion de funcionalidades sobre las cuales se van hacer los test'''
self.coleccion = Coleccion()
'''Abrir la sesion'''
self.session = Session()
'''Crear los objetos'''
self.actividad1 = Actividad(nombre="Ir al mar")
self.actividad2 = Actividad(nombre='Ir al museo')
self.actividad3 = Actividad(nombre="Ir al cine")
'''Adiciona los objetos de la sesion'''
self.session.add(self.actividad1)
self.session.add(self.actividad2)
self.session.add(self.actividad3)
'''Persistir la informacion y cerrar la sesion'''
self.session.commit()
self.session.close()
def test_insertar_la_actividad(self):
'''Prueba la adicion de una actividad'''
resultado = self.coleccion.insertar_la_actividad(nombre="Ir a bailar")
self.assertEqual(resultado, True)
def test_editar_la_actividad(self):
'''Prueba la edicion de una actividad'''
resultado = self.coleccion.editar_la_actividad(
"Ir al mar", "Ir al parque de diversiones")
self.assertEqual(resultado, True)
def test_eliminar_la_actividad(self):
resultado = self.coleccion.eliminar_la_actividad("Ir al cine")
self.assertEqual(resultado, True)
class ViajeroTestCase(unittest.TestCase):
def tearDown(self):
'''Abrir la session'''
self.session = Session()
'''Consulta todas las actividades'''
busqueda = self.session.query(Viajero).all()
'''Borrar todos los albums'''
for viajero in busqueda:
self.session.delete(viajero)
self.session.commit()
self.session.close()
def setUp(self):
'''Crea una coleccion de funcionalidades sobre las cuales se van hacer los test'''
self.coleccion = Coleccion()
'''Abrir la sesion'''
self.session = Session()
'''Crear los objetos'''
self.viajero1 = Viajero(nombre="Juan", apellido="Gutierrez")
self.viajero2 = Viajero(nombre='Natalia', apellido="Camargo")
self.viajero3 = Viajero(nombre="Fabian", apellido="Gonzalez")
'''Adiciona los objetos de la sesion'''
self.session.add(self.viajero1)
self.session.add(self.viajero2)
self.session.add(self.viajero3)
'''Persistir la informacion y cerrar la sesion'''
self.session.commit()
self.session.close()
def test_insertar_el_viajero(self, nombre = "Gloria", apellido = "Cardenas"):
'''Prueba la adicion del viajero'''
resultado = self.coleccion.insertar_el_viajero(nombre=nombre, apellido=apellido)
self.assertEqual(resultado, True)
class tests_gastos(unittest.TestCase):
def setUp(self):
self.session = Session()
self.cuentas_claras = Logica_mock()
self.data_factory = Faker()
def tearDown(self):
self.session = Session()
busqueda_gastos = self.session.query(Gasto).all()
busqueda_viajeros = self.session.query(Viajero).all()
busqueda_actividad = self.session.query(Actividad).all()
for gasto in busqueda_gastos:
self.session.delete(gasto)
for viajero in busqueda_viajeros:
self.session.delete(viajero)
for actividad in busqueda_actividad:
self.session.delete(actividad)
self.session.commit()
self.session.close()
def test_agregar_gasto_actividad(self):
"""
Prueba agregar un gasto a una actividad especifica
"""
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.cuentas_claras.asociar_viajero_a_actividad(
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id,
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
prueba_gasto = self.cuentas_claras.crear_gasto_para_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id,
self.data_factory.name(), self.data_factory.random_int(1, 1000),
self.data_factory.date(),
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
gastos_actividad = self.cuentas_claras.dar_gastos_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
self.assertEqual(prueba_gasto, True)
self.assertEqual(len(gastos_actividad), 1)
def test_agregar_gasto_actividad_con_viajero_no_asociado_a_actividad(self):
"""
Prueba agregar un gasto a una actividad especifica cuando el viajero solicitado no hace parte de la misma
"""
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
prueba_gasto = self.cuentas_claras.crear_gasto_para_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id,
self.data_factory.name(), self.data_factory.random_int(1, 1000),
self.data_factory.date(),
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
gastos_actividad = self.cuentas_claras.dar_gastos_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
self.assertEqual(prueba_gasto, False)
self.assertEqual(gastos_actividad, None)
def test_agregar_gasto_igual_cero_a_actividad(self):
"""
Prueba agregar un gasto que tenga valor igual a 0 a una actividad especifica
"""
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.cuentas_claras.asociar_viajero_a_actividad(
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id,
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
prueba_gasto = self.cuentas_claras.crear_gasto_para_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id,
self.data_factory.name(), 0, self.data_factory.date(),
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
gastos_actividad = self.cuentas_claras.dar_gastos_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
self.assertEqual(prueba_gasto, False)
self.assertEqual(gastos_actividad, None)
def test_agregar_gasto_negativo_a_actividad(self):
"""
Prueba agregar un gasto que tenga valor negativo a 0 a una actividad especifica
"""
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.cuentas_claras.asociar_viajero_a_actividad(
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id,
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
prueba_gasto = self.cuentas_claras.crear_gasto_para_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id,
self.data_factory.name(),
self.data_factory.random_int(1, 1000) * -1,
self.data_factory.date(),
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
gastos_actividad = self.cuentas_claras.dar_gastos_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
self.assertEqual(prueba_gasto, False)
self.assertEqual(gastos_actividad, None)
def test_agregar_gasto_repetido_actividad(self):
"""
Prueba agregar un gasto con nombre repetido una actividad especifica
"""
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
concepto_gasto = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.cuentas_claras.asociar_viajero_a_actividad(
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id,
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
prueba_gasto1 = self.cuentas_claras.crear_gasto_para_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id,
concepto_gasto, self.data_factory.random_int(1, 1000),
self.data_factory.date(),
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
prueba_gasto2 = self.cuentas_claras.crear_gasto_para_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id,
concepto_gasto, self.data_factory.random_int(1, 1000),
self.data_factory.date(),
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
gastos_actividad = self.cuentas_claras.dar_gastos_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
self.assertEqual(prueba_gasto1, True)
self.assertEqual(prueba_gasto2, False)
self.assertEqual(len(gastos_actividad), 1)
def test_agregar_gasto_actividad_con_concepto_fecha_igual_none(self):
"""
Prueba agregar un gasto a una actividad especifica con concepto o fecho vacios
"""
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.cuentas_claras.asociar_viajero_a_actividad(
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id,
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
prueba_gasto = self.cuentas_claras.crear_gasto_para_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id, None,
self.data_factory.random_int(1, 1000), None,
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
gastos_actividad = self.cuentas_claras.dar_gastos_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
self.assertEqual(prueba_gasto, False)
self.assertEqual(gastos_actividad, None)
def test_editar_gasto(self):
"""
Prueba editar el concepto, valor o fecha de un gasto manteniendo el viajero
"""
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
concepto_anterior = self.data_factory.name()
valor_anterior = self.data_factory.random_int(1, 1000)
fecha_anterior = self.data_factory.date()
nuevo_concepto = self.data_factory.name()
nuevo_valor = self.data_factory.random_int(1, 1000)
nueva_fecha = self.data_factory.date()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.cuentas_claras.asociar_viajero_a_actividad(
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id,
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
self.cuentas_claras.crear_gasto_para_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id,
concepto_anterior, valor_anterior, fecha_anterior,
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
gasto_id = self.session.query(Gasto).filter(
Gasto.concepto == concepto_anterior).first().id
prueba_editar = self.cuentas_claras.editar_gasto(
gasto_id, nuevo_concepto, nuevo_valor, nueva_fecha,
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
gasto = self.session.query(Gasto).filter(Gasto.id == gasto_id).first()
self.assertEqual(prueba_editar, True)
self.assertEqual(gasto.concepto, nuevo_concepto)
self.assertEqual(gasto.valor, nuevo_valor)
self.assertEqual(gasto.fecha, nueva_fecha)
def test_editar_gasto_con_valor_igual_cero(self):
"""
Prueba editar el gasto con valor igual a cero
"""
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
concepto_anterior = self.data_factory.name()
valor_anterior = self.data_factory.random_int(1, 1000)
fecha_anterior = self.data_factory.date()
nuevo_concepto = self.data_factory.name()
nueva_fecha = self.data_factory.date()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.cuentas_claras.asociar_viajero_a_actividad(
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id,
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
self.cuentas_claras.crear_gasto_para_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id,
concepto_anterior, valor_anterior, fecha_anterior,
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
gasto_id = self.session.query(Gasto).filter(
Gasto.concepto == concepto_anterior).first().id
prueba_editar = self.cuentas_claras.editar_gasto(
gasto_id, nuevo_concepto, 0, nueva_fecha,
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
gasto = self.session.query(Gasto).filter(Gasto.id == gasto_id).first()
self.assertEqual(prueba_editar, False)
self.assertEqual(gasto.concepto, concepto_anterior)
self.assertEqual(gasto.valor, valor_anterior)
self.assertEqual(gasto.fecha, fecha_anterior)
def test_editar_gasto_con_valor_negativo(self):
"""
Prueba editar el gasto con valor negativo
"""
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
concepto_anterior = self.data_factory.name()
valor_anterior = self.data_factory.random_int(1, 1000)
fecha_anterior = self.data_factory.date()
nuevo_concepto = self.data_factory.name()
nuevo_valor = self.data_factory.random_int(1, 1000) * -1
nueva_fecha = self.data_factory.date()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.cuentas_claras.asociar_viajero_a_actividad(
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id,
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
self.cuentas_claras.crear_gasto_para_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id,
concepto_anterior, valor_anterior, fecha_anterior,
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
gasto_id = self.session.query(Gasto).filter(
Gasto.concepto == concepto_anterior).first().id
prueba_editar = self.cuentas_claras.editar_gasto(
gasto_id, nuevo_concepto, nuevo_valor, nueva_fecha,
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
gasto = self.session.query(Gasto).filter(Gasto.id == gasto_id).first()
self.assertEqual(prueba_editar, False)
self.assertEqual(gasto.concepto, concepto_anterior)
self.assertEqual(gasto.valor, valor_anterior)
self.assertEqual(gasto.fecha, fecha_anterior)
def test_editar_gasto_con_concepto_o_fecha_vacios(self):
"""
Prueba editar el gasto con concepto o fecha vacios
"""
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
concepto_anterior = self.data_factory.name()
valor_anterior = self.data_factory.random_int(1, 1000)
fecha_anterior = self.data_factory.date()
nuevo_valor = self.data_factory.random_int(1, 1000)
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.cuentas_claras.asociar_viajero_a_actividad(
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id,
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
self.cuentas_claras.crear_gasto_para_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id,
concepto_anterior, valor_anterior, fecha_anterior,
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
gasto_id = self.session.query(Gasto).filter(
Gasto.concepto == concepto_anterior).first().id
prueba_editar = self.cuentas_claras.editar_gasto(
gasto_id, None, nuevo_valor, None,
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id)
gasto = self.session.query(Gasto).filter(Gasto.id == gasto_id).first()
self.assertEqual(prueba_editar, False)
self.assertEqual(gasto.concepto, concepto_anterior)
self.assertEqual(gasto.valor, valor_anterior)
self.assertEqual(gasto.fecha, fecha_anterior)
def test_editar_gasto_asociandolo_a_un_nuevo_viajero(self):
"""
Prueba editar el gasto asociandolo a un nuevo viajero
"""
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
nombre_viajero2 = self.data_factory.first_name()
apellido_viajero2 = self.data_factory.last_name()
concepto_anterior = self.data_factory.name()
valor_anterior = self.data_factory.random_int(1, 1000)
fecha_anterior = self.data_factory.date()
nuevo_concepto = self.data_factory.name()
nuevo_valor = self.data_factory.random_int(1, 1000)
nueva_fecha = self.data_factory.date()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.cuentas_claras.agregar_viajero(nombre_viajero2, apellido_viajero2)
self.cuentas_claras.asociar_viajero_a_actividad(
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id,
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
self.cuentas_claras.asociar_viajero_a_actividad(
self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero2
and Viajero.apellido == apellido_viajero2).first().id,
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id)
viajero1_id = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first().id
viajero2_id = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero2
and Viajero.apellido == apellido_viajero2).first().id
self.cuentas_claras.crear_gasto_para_actividad(
self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id,
concepto_anterior, valor_anterior, fecha_anterior, viajero1_id)
gasto_id = self.session.query(Gasto).filter(
Gasto.concepto == concepto_anterior).first().id
prueba_editar = self.cuentas_claras.editar_gasto(
gasto_id, nuevo_concepto, nuevo_valor, nueva_fecha, viajero2_id)
gasto = self.session.query(Gasto).filter(Gasto.id == gasto_id).first()
gastos_viajero1 = self.session.query(Gasto).filter(
Gasto.viajero == viajero1_id).all()
gastos_viajero2 = self.session.query(Gasto).filter(
Gasto.viajero == viajero2_id).all()
self.assertEqual(prueba_editar, True)
self.assertEqual(gasto.concepto, nuevo_concepto)
self.assertEqual(gasto.valor, nuevo_valor)
self.assertEqual(gasto.fecha, nueva_fecha)
self.assertEqual(len(gastos_viajero2), 1)
self.assertEqual(len(gastos_viajero1), 0)
class Listar_gastos_test_case(unittest.TestCase):
def setUp(self):
'''Crea una colección para hacer las pruebas'''
self.cuentas_claras = Cuentas_claras()
'''Abre la sesión'''
self.session = Session()
'''Crear Faker '''
self.data_factory = Faker()
Faker.seed(1000)
'''Crea las actividades'''
# crear actividades random
self.actividades = []
for _ in range(2):
actividad = Actividad(nombre=self.data_factory.unique.name())
self.session.add(actividad)
self.actividades.append(actividad)
# crear viajeros random
self.viajeros = []
for _ in range(2):
viajero = Viajero(self.data_factory.unique.first_name(),
self.data_factory.unique.last_name())
self.session.add(viajero)
self.viajeros.append(viajero)
self.actividades[0].agregar_viajero_en_actividad(self.viajeros[0])
self.actividades[0].agregar_viajero_en_actividad(self.viajeros[1])
# crear gastos random
self.gastos = []
for _ in range(2):
gasto = Gasto(concepto=self.data_factory.text(),
valor=random.uniform(1, 1000),
fecha_gasto=datetime.strptime(
self.data_factory.date(), '%Y-%m-%d'))
self.session.add(gasto)
self.gastos.append(gasto)
self.viajeros[0].agregar_gasto(self.gastos[0])
self.viajeros[1].agregar_gasto(self.gastos[1])
self.actividades[0].agregar_gasto(self.gastos[0])
self.actividades[0].agregar_gasto(self.gastos[1])
'''Persiste los objetos y cierra la sesión'''
self.session.commit()
self.session.close()
def tearDown(self):
'''Abre la sesión'''
self.session = Session()
'''Consulta todas las actividades'''
actividades = self.session.query(Actividad).all()
'''Borra todas las actividades'''
for actividad in actividades:
self.session.delete(actividad)
'''Consulta todas las actividades'''
viajeros = self.session.query(Viajero).all()
'''Borra todas las actividades'''
for viajero in viajeros:
self.session.delete(viajero)
self.session.commit()
self.session.close()
def test_listar_gastos_caso_vacio(self):
gastos = self.cuentas_claras.listar_gastos_actividad(2)
self.assertIsInstance(gastos, list)
self.assertEqual(len(gastos), 0)
def test_validar_contenido_gastos(self):
gastos = self.cuentas_claras.listar_gastos_actividad(1)
for gasto in gastos:
self.assertIn("Concepto", gasto)
self.assertIn("Valor", gasto)
self.assertIn("Nombre", gasto)
self.assertIn("Fecha", gasto)
self.assertIn("Apellido", gasto)
def test_validar_tipo_info_gastos(self):
gastos = self.cuentas_claras.listar_gastos_actividad(1)
for gasto in gastos:
self.assertIsInstance(gasto["Concepto"], str)
self.assertIsInstance(gasto["Valor"], float)
self.assertIsInstance(gasto["Nombre"], str)
self.assertIsInstance(gasto["Fecha"], str)
self.assertIsInstance(gasto["Apellido"], str)
def test_validar_formato_fecha_gastos(self):
gastos = self.cuentas_claras.listar_gastos_actividad(1)
regex = re.compile(
r'^([0-2][0-9]|(3)[0-1])(\-)(((0)[0-9])|((1)[0-2]))(\-)\d{4}$')
for gasto in gastos:
self.assertTrue(regex.match(
gasto["Fecha"])) # se desea formato dd-mm-yyyy
class AlbumTestCase(unittest.TestCase):
def setUp(self):
self.session = Session()
self.coleccion = Coleccion()
# Generación de datos con libreria Faker
self.data_factory = Faker()
def test_agregar_album(self):
# Nombre aleatorio
titulo_album1 = self.data_factory.name()
# Año aleatorio
anio_album1 = self.data_factory.year()
# Frase aleatoria
descripcion_album1 = self.data_factory.sentence()
self.coleccion.agregar_album(titulo_album1, anio_album1, descripcion_album1, "CD")
descripcion_album2 = self.data_factory.sentence()
self.coleccion.agregar_album("Live Killers", 2013, descripcion_album2, "CASETE")
anio_album3 = self.data_factory.year()
descripcion_album3 = self.data_factory.sentence()
self.coleccion.agregar_album("Clara luna", anio_album3, descripcion_album3, "CASETE")
consulta1 = self.session.query(Album).filter(Album.titulo == titulo_album1).first()
consulta2 = self.session.query(Album).filter(Album.id == 2).first()
self.assertEqual(consulta1.titulo, titulo_album1)
self.assertIsNotNone(consulta2)
# self.assertIsNotNone(None)
def test_editar_album(self):
nueva_descripcion_album = self.data_factory.sentence()
self.coleccion.editar_album(2, "Clara luna-Mix", 2013, nueva_descripcion_album, "DISCO")
consulta = self.session.query(Album).filter(Album.id == 2).first()
self.assertIsNot(consulta.titulo, "Live Killers")
def test_eliminar_album(self):
self.coleccion.eliminar_album(1)
consulta = self.session.query(Album).filter(Album.id == 1).first()
self.assertIsNone(consulta)
def test_dar_albumes(self):
consulta1 = self.coleccion.dar_albumes()
titulo_album = self.data_factory.name()
anio_album = self.data_factory.year()
descripcion_album = self.data_factory.sentence()
self.coleccion.agregar_album(titulo_album, anio_album, descripcion_album, "CD")
consulta2 = self.coleccion.dar_albumes()
self.assertGreaterEqual(len(consulta2), len(consulta1))
def test_dar_album_por_id(self):
titulo_album = self.data_factory.name()
anio_album = self.data_factory.year()
descripcion_album = self.data_factory.sentence()
self.coleccion.agregar_album(titulo_album, anio_album, descripcion_album, "CASETE")
album_id = self.session.query(Album).filter(Album.titulo == titulo_album).first().id
consulta = self.coleccion.dar_album_por_id(album_id)["titulo"]
self.assertEqual(consulta, titulo_album)
def test_buscar_albumes_por_titulo(self):
consulta1 = self.coleccion.buscar_albumes_por_titulo("clara luna")
anio_album = self.data_factory.year()
descripcion_album = self.data_factory.sentence()
self.coleccion.agregar_album("Clara luna-Instrumental", anio_album, descripcion_album, "CD")
consulta2 = self.coleccion.buscar_albumes_por_titulo("clara luna")
self.assertLessEqual(len(consulta1), len(consulta2))
class MostrarGastosActividadTestCase(unittest.TestCase):
def setUp(self):
''' Se puebla la base de datos para las pruebas'''
self.session = Session()
busqueda_actividad = self.session.query(Actividad).all()
for actividad in busqueda_actividad:
self.session.delete(actividad)
busqueda_viajero = self.session.query(Viajero).all()
for viajero in busqueda_viajero:
self.session.delete(viajero)
busqueda_gasto = self.session.query(Gasto).all()
for gasto in busqueda_gasto:
self.session.delete(gasto)
busqueda_av = self.session.query(ActividadViajero).all()
for av in busqueda_av:
self.session.delete(av)
self.session.commit()
# Crear actividades y agregarlas a la base de datos con add y commit
self.actividad_1 = Actividad("Paseo a la Playa")
self.actividad_2 = Actividad("Caminata")
self.session.add(self.actividad_1)
self.session.add(self.actividad_2)
self.session.commit()
# Crear los viajeros y agregarlos a la base de datos con add y commit
self.viajero_1 = Viajero("Juan", "Perez")
self.viajero_2 = Viajero("Rosa", "Garcia")
self.viajero_3 = Viajero("Luis", "Mora")
self.viajero_4 = Viajero("Ana", "Zavala")
self.session.add(self.viajero_1)
self.session.add(self.viajero_2)
self.session.add(self.viajero_3)
self.session.add(self.viajero_4)
self.session.commit()
# Crear los gastos. Note que el atributo fecha en este momento es String.
self.gasto_1 = Gasto("Transporte", 100, '21-01-2021')
self.gasto_2 = Gasto("Comida", 200, '22-01-2021')
self.gasto_3 = Gasto("Bebida", 90, '23-01-2021')
self.gasto_4 = Gasto("Fiesta",120,'24-01-2021')
self.gasto_5 = Gasto("Transporte", 150, '28-01-2021')
self.session.add(self.gasto_1)
self.session.add(self.gasto_2)
self.session.add(self.gasto_3)
self.session.add(self.gasto_4)
self.session.add(self.gasto_5)
self.session.commit()
# Crea las relaciones entre actividad y viajero (cuales son los viajeros asociados a cada actividad)
self.actividad_1.viajeros = [self.viajero_1, self.viajero_2, self.viajero_3, self.viajero_4]
self.actividad_2.viajeros = [self.viajero_2]
# Crea las relaciones entre actividad y gasto *(cuales son los gastos de cada actividad)
self.actividad_1.gastos = [self.gasto_1, self.gasto_2, self.gasto_3, self.gasto_4]
self.actividad_2.gastos = [self.gasto_5]
# Crea las relaciones entre viajero y gastos (que viajero realizo cada gasto)
self.viajero_1.gastos = [self.gasto_1, self.gasto_3]
self.viajero_2.gastos = [self.gasto_2, self.gasto_5]
self.viajero_3.gastos = [self.gasto_4]
self.viajero_4.gastos = []
self.session.commit()
# Cierra la sesion
self.session.close()
def test_mostrar_gastos_actividad(self):
self.session = Session()
self.act_id = 1
self.viajeross = self.session.query(Viajero).all()
self.viajeros1 = []
for viajero in self.viajeross:
self.viajeros1.append(object_as_dict(viajero))
self.gastos1 = self.session.query(Gasto).join(Actividad).filter(Gasto.actividad == self.act_id).all()
self.gastos = []
for gasto in self.gastos1:
self.gastos.append(object_as_dict(gasto))
for g in self.gastos:
vid = g.get("viajero")
for viajero in self.viajeros1:
if viajero['id'] == vid:
g["Nombre"] = viajero['nombre']
g["Apellido"] = viajero['apellido']
# Mostrar que la lista en la base de datos es la misma que fue insertada
self.lista_gastos = [{'id': 1, 'concepto': 'Transporte', 'valor': 100, 'fecha': '21-01-2021', 'actividad': 1, 'viajero': 1, 'Nombre': 'Juan', 'Apellido': 'Perez'}, {'id': 2, 'concepto': 'Comida', 'valor': 200, 'fecha': '22-01-2021', 'actividad': 1, 'viajero': 2, 'Nombre': 'Rosa', 'Apellido': 'Garcia'}, {'id': 3, 'concepto': 'Bebida', 'valor': 90, 'fecha': '23-01-2021', 'actividad': 1, 'viajero': 1, 'Nombre': 'Juan', 'Apellido': 'Perez'}, {'id': 4, 'concepto': 'Fiesta', 'valor': 120, 'fecha': '24-01-2021', 'actividad': 1, 'viajero': 3, 'Nombre': 'Luis', 'Apellido': 'Mora'}]
self.assertListEqual(self.lista_gastos, self.gastos)
def tearDown(self):
session = Session()
session.close()
class Reporte_compensacion_test_case(unittest.TestCase):
def setUp(self):
'''Crea una colección para hacer las pruebas'''
self.cuentas_claras = Cuentas_claras()
'''Abre la sesión'''
self.session = Session()
'''Crear Faker '''
self.data_factory = Faker()
Faker.seed(1000)
'''Crea las actividades'''
# crear actividades random
self.actividades = []
for _ in range(1):
actividad = Actividad(nombre=self.data_factory.unique.name())
self.session.add(actividad)
self.actividades.append(actividad)
# crear viajeros random
self.viajeros = []
for _ in range(4):
viajero = Viajero(self.data_factory.unique.first_name(),
self.data_factory.unique.last_name())
self.session.add(viajero)
self.viajeros.append(viajero)
for i in range(len(self.viajeros)):
self.actividades[0].agregar_viajero_en_actividad(self.viajeros[i])
# crear gastos random
self.gastos = []
for _ in range(8):
gasto = Gasto(concepto=self.data_factory.unique.name(),
valor=random.uniform(1, 1000),
fecha_gasto=datetime.strptime(
self.data_factory.date(), '%Y-%m-%d'))
self.session.add(gasto)
self.gastos.append(gasto)
# se asigna aleatoriamente los gastos a los viajeros
for i in range(len(self.gastos)):
viajero_id = random.randrange(len(self.viajeros))
self.viajeros[viajero_id].agregar_gasto(self.gastos[i])
for i in range(len(self.gastos)):
self.actividades[0].agregar_gasto(self.gastos[i])
'''Persiste los objetos y cierra la sesión'''
self.session.commit()
def tearDown(self):
'''Abre la sesión'''
self.session = Session()
'''Consulta todas las actividades'''
actividades = self.session.query(Actividad).all()
'''Borra todas las actividades'''
for actividad in actividades:
self.session.delete(actividad)
'''Consulta todas las actividades'''
viajeros = self.session.query(Viajero).all()
'''Borra todas las actividades'''
for viajero in viajeros:
self.session.delete(viajero)
self.session.commit()
self.session.close()
def test_validar_matriz_diagonal(self):
reporte = self.cuentas_claras.generar_reporte_compensacion_por_actividad(
1)
for i in range(1, len(reporte)):
self.assertEqual(reporte[i][i], -1)
def test_validar_reporte(self):
reporte_por_viajero = self.cuentas_claras.generar_reporte_por_viajeros_por_actividad(
1)
reporte = self.cuentas_claras.generar_reporte_compensacion_por_actividad(
1)
promedio = sum([viajero["Valor"] for viajero in reporte_por_viajero
]) / len(reporte_por_viajero)
for viajero in reporte_por_viajero:
valor = viajero["Valor"]
nombre_apellido = viajero["Nombre"] + " " + viajero["Apellido"]
ind = reporte[0].index(nombre_apellido) # camilo , pedro , 0
if promedio > valor: # debe compensar
acum = valor + 1 # se suma 1 por el offset del -1
for i in range(1, len(reporte)):
acum += reporte[i][ind]
self.assertEqual(round(promedio, 5), round(acum, 5))
else: # debe ser compensado
acum = 1 # se suma 1 por el offset del -1
for i in range(1, len(reporte)):
acum += reporte[i][ind]
# se revisa que el viajero no haya tenido que compensar
self.assertEqual(0, round(acum, 5))
for i in range(1, len(reporte)):
if nombre_apellido == reporte[i][0]:
ind_fil = i # encontramos donde esta el viajero en las filas
break
acum = valor - 1
for i in range(1, len(reporte)):
acum -= reporte[ind_fil][i]
self.assertEqual(round(promedio, 5), round(acum, 5))
from src.modelo.actividad import Actividad
from src.modelo.gasto import Gasto
from src.modelo.viajero import Viajero
from src.modelo.declarative_base import Session
#if __name__ == '__main__':
session = Session()
# actividades_lista = session.query(Actividad).all()
# print(actividades_lista)
# activities= []
#
# for actividad in actividades_lista:
# activities.append(actividad.nombre)
actividades = [a.nombre for a in session.query(Actividad.nombre).all()]
gastos = [session.query(Gasto).asdict()]
# def dar_actividades():
# actividades_lista = session.query(Actividad.nombre).all()
# activities = []
# for actividad in actividades_lista:
# activities.append(actividad.nombre)
# return activities
# print('Las actividades almacenadas son:')
# actividades=dar_actividades()
# activities = []
# for actividad in actividades:
# activities.append(actividad.nombre)
print(actividades)
class CancionTestCase(unittest.TestCase):
def setUp(self):
self.session = Session()
self.coleccion = Coleccion()
def testAgregarCancionSinAlbum(self):
self.coleccion.agregarInterprete("Vicente Fernandez",
"Grabado en 3 potrillos", -1)
self.coleccion.agregarInterprete("Alejandro Fernandez",
"En honor al aniversario...", -1)
self.coleccion.agregarCancion(
"Felicidad", 3, 10, "Desconocido", -1,
[{
'nombre': 'Vicente Fernandez',
'texto_curiosidades': 'Grabado en 3 potrillos'
}, {
'nombre': 'Alejandro Fernandez',
'texto_curiosidades': 'En honor al aniversario...'
}])
self.consulta1 = self.session.query(Cancion).filter(
Cancion.titulo == "Felicidad").first()
self.assertIsNotNone(self.consulta1)
def testAgregarCancionConAlbum(self):
self.coleccion.agregarAlbum("Renacer", 2005, "Sin descripción", "CD")
self.consulta1 = self.session.query(Album).filter(
Album.titulo == "Renacer").first().id
self.coleccion.agregarInterprete("Alejandra Guzman",
"Canción dedicada a su ...", -1)
self.coleccion.agregarCancion(
"Bye mamá", 1, 48, "Desconocido", self.consulta1,
[{
'nombre': 'Alejandra Guzman',
'texto_curiosidades': 'Canción dedicada a su ...'
}])
self.consulta2 = self.session.query(Cancion).filter(
Cancion.titulo == "Bye mamá").first()
self.assertIsNotNone(self.consulta2)
def testEditarCancionSinCambiarInterpretes(self):
self.coleccion.editarCancion(
1, "Bye mamá", 2, 54, "J.R.Florez",
[{
'id': '2',
'nombre': 'Alejandra Guzman',
'texto_curiosidades': 'Canción dedicada a su ...'
}])
self.consulta = self.session.query(Cancion).filter(
Cancion.id == 1).first()
self.assertEqual(self.consulta.compositor, "J.R.Florez")
def testEditarCancionInterpretes(self):
self.consulta1 = self.session.query(Cancion).filter(
Cancion.id == 1).first().compositor
self.consulta2 = self.session.query(Interprete).filter(
Interprete.nombre == "Franco de Vita").first()
if self.consulta2 is None:
self.coleccion.agregarInterprete("Franco de Vita",
"Duo con más likes en redes", 1)
self.coleccion.editarCancion(
1, "Bye mamá", 4, 23, "J.R.Florez y Difelisatti",
[{
'id': '2',
'nombre': 'Alejandra Guzman',
'texto_curiosidades': 'Canción dedicada a su ...'
}, {
'id': 'n',
'nombre': 'Franco de Vita',
'texto_curiosidades': 'Duo con más likes en redes'
}])
else:
self.coleccion.editarCancion(
1, "Bye bye", 4, 23, "J.R.Florez y Difelisatti",
[{
'id': '2',
'nombre': 'Alejandra Guzman',
'texto_curiosidades': 'Canción dedicada a su ...'
}, {
'id': '9',
'nombre': 'Franco de Vita',
'texto_curiosidades': 'Duo con más likes en redes'
}])
self.consulta3 = self.session.query(Cancion).filter(
Cancion.id == 1).first()
self.assertEqual(self.consulta3.compositor, "J.R.Florez y Difelisatti")
def testEliminarCancion(self):
self.coleccion.eliminarCancion(2)
self.consulta = self.session.query(Cancion).filter(
Cancion.id == 2).first()
self.assertIsNone(self.consulta)
def testBuscarCancionesPorTitulo(self):
self.coleccion.agregarAlbum("Amapola azul", 2020, "Instrumental", "CD")
self.consulta1 = self.session.query(Album).filter(
Album.titulo == "Amapola azul").first().id
self.coleccion.agregarInterprete("Andrea Echeverri",
"En ese año nacio su hijo...", -1)
self.coleccion.agregarCancion(
"Baby blues", 3, 20, "Andrea Echeverri", self.consulta1,
[{
'nombre': 'Andrea Echeverri',
'texto_curiosidades': 'En ese año nacio su hijo...'
}])
self.consulta = self.coleccion.buscarCancionesPorTitulo("Baby")
self.assertGreater(len(self.consulta), 0)
def testDarCancionPorId(self):
self.consulta = self.coleccion.darCancionPorId(1)
self.assertEqual(self.consulta["titulo"], "Bye mamá")
def testDarCanciones(self):
self.consulta = self.coleccion.darCanciones()
self.assertNotEqual(self.consulta, [])
class Listar_actividades_test_case(unittest.TestCase):
def setUp(self):
'''Crea una colección para hacer las pruebas'''
self.cuentas_claras = Cuentas_claras()
'''Abre la sesión'''
self.session = Session()
self.data_factory = Faker()
Faker.seed(1000)
# crear nombres y apellidos random invalidos
self.nombres_invalidos= []
for _ in range(10):
self.nombres_invalidos.append(self.data_factory.bothify(text='#?#?##?',letters='!"#$%&/()='))
# crear viajeros random
self.viajeros = []
for _ in range(10):
viajero = Viajero(self.data_factory.unique.first_name(),self.data_factory.unique.last_name())
self.viajeros.append(viajero)
self.session.close()
def tearDown(self):
'''Abre la sesión'''
self.session = Session()
'''Consulta todos los viajeros'''
viajeros = self.session.query(Viajero).all()
'''Borra todos los viajeros'''
for viajero in viajeros:
self.session.delete(viajero)
self.session.commit()
self.session.close()
def test_validar_campos_nombre_apellidos_solo_alfabetico_viajero(self):
"""Validar que tanto el campo del nombre como del apellido no tengan carácteres especiales"""
res1 = self.cuentas_claras.agregar_viajero(random.choice(self.nombres_invalidos),random.choice(self.nombres_invalidos))
res2 = self.cuentas_claras.agregar_viajero(self.data_factory.unique.first_name(),random.choice(self.nombres_invalidos))
res3 = self.cuentas_claras.agregar_viajero(random.choice(self.nombres_invalidos),self.data_factory.unique.last_name())
self.assertIsNone(res1)
self.assertIsNone(res2)
self.assertIsNone(res3)
def test_validar_campos_nombre_apellidos_no_nulos_viajero(self):
"""Validar que tanto el campo del nombre como del apellido no estén vacios"""
res1 = self.cuentas_claras.agregar_viajero("","")
res2 = self.cuentas_claras.agregar_viajero(self.data_factory.unique.first_name(),"")
res3 = self.cuentas_claras.agregar_viajero("",self.data_factory.unique.last_name())
self.assertIsNone(res1)
self.assertIsNone(res2)
self.assertIsNone(res3)
def test_agregar_viajero_con_exito(self):
"""Validar agregar viajero con éxito"""
rand_viajero1 = self.viajeros[0]
rand_viajero2 = self.viajeros[1]
res1 = self.cuentas_claras.agregar_viajero(rand_viajero1.dar_nombre(),rand_viajero1.dar_apellido())
self.cuentas_claras.agregar_viajero(rand_viajero2.dar_nombre(),rand_viajero2.dar_apellido())
viajero1 = self.session.query(Viajero).filter(Viajero.nombre==rand_viajero1.dar_nombre(),Viajero.apellido==rand_viajero1.dar_apellido()).first()
viajero2 = self.session.query(Viajero).filter(Viajero.id == 2).first()
self.assertTrue(res1)
self.assertIsNotNone(viajero1)
self.assertEqual(viajero1.dar_nombre(),rand_viajero1.dar_nombre())
self.assertEqual(viajero1.dar_apellido(),rand_viajero1.dar_apellido())
self.assertIsNotNone(viajero2)
def test_no_agregar_viajero_duplicado(self):
"""Validar que no se agregue viajero cuando este ya exista"""
rand_viajero3 = self.viajeros[2]
self.cuentas_claras.agregar_viajero(rand_viajero3.dar_nombre(),rand_viajero3.dar_apellido())
res = self.cuentas_claras.agregar_viajero(rand_viajero3.dar_nombre(),rand_viajero3.dar_apellido())
self.assertIsNone(res)
class Cuentas_claras:
def __init__(self):
Base.metadata.create_all(engine)
self.session = Session()
def listar_actividades(self):
actividades = self.session.query(Actividad).all()
if len(actividades) == 0:
return None
actividades = [actividad.dar_nombre() for actividad in actividades]
return sorted(actividades)
def dar_actividad_por_id(self, id):
actividad = self.session.query(Actividad).get(id)
return actividad
def agregar_viajero(self, nombre, apellido):
if nombre == "" or apellido == "":
return None
if not nombre.isalpha() or not apellido.isalpha():
return None
viajeros = self.session.query(Viajero).filter(
Viajero.nombre == nombre, Viajero.apellido == apellido).all()
if len(viajeros) > 0:
return None
viajero = Viajero(nombre, apellido)
self.session.add(viajero)
self.session.commit()
return True
def agregar_actividad(self, nombre):
if nombre == "":
return None
actividades = self.session.query(Actividad).filter(
Actividad.nombre == nombre).all()
if len(actividades) > 0:
return None
actividad = Actividad(nombre)
self.session.add(actividad)
self.session.commit()
return True
def dar_viajero_por_id(self, id):
viajero = self.session.query(Viajero).get(id)
return viajero
def listar_gastos_actividad(self, id):
actividad = self.dar_actividad_por_id(id)
gastos = actividad.dar_gastos()
gastos_final = []
for gasto in gastos:
gasto_dic = {}
gasto_dic["Concepto"] = str(gasto.dar_concepto())
gasto_dic["Valor"] = float(gasto.dar_valor())
gasto_dic["Fecha"] = str(gasto.dar_fecha_gasto())
gasto_dic["Nombre"] = str(
self.dar_viajero_por_id(gasto.dar_viajero()).dar_nombre())
gasto_dic["Apellido"] = str(
self.dar_viajero_por_id(gasto.dar_viajero()).dar_apellido())
gastos_final.append(gasto_dic)
return gastos_final
def listar_pasajeros_por_actividad(self, id):
actividad = self.dar_actividad_por_id(id)
viajeros = actividad.dar_viajeros_en_actividad()
viajeros_final = []
for viajero in viajeros:
nombre_apellido = viajero.dar_nombre(
) + " " + viajero.dar_apellido()
viajeros_final.append(nombre_apellido)
return viajeros_final
def generar_reporte_compensacion_por_actividad(self, id):
gastos_consolidados = self.generar_reporte_por_viajeros_por_actividad(
id)
promedio = sum([viajero["Valor"] for viajero in gastos_consolidados
]) / len(gastos_consolidados)
a_compensar = {}
deben_compensar = {}
for gasto in gastos_consolidados:
nombre_apellido = gasto["Nombre"] + " " + gasto["Apellido"]
if promedio > gasto["Valor"]:
deben_compensar[nombre_apellido] = promedio - gasto["Valor"]
else:
a_compensar[nombre_apellido] = gasto["Valor"] - promedio
reporte = [[None for i in range(len(gastos_consolidados) + 1)]
for j in range(len(gastos_consolidados) + 1)]
reporte[0][0] = ""
for i in range(1, len(reporte)):
nombre_apellido = gastos_consolidados[
i - 1]["Nombre"] + " " + gastos_consolidados[i - 1]["Apellido"]
reporte[i][0] = nombre_apellido
reporte[0][i] = nombre_apellido
for i in range(1, len(reporte)): # debe compensar
for j in range(1, len(reporte)): # a compensar
if i == j:
reporte[i][j] = -1
else:
viajero1 = reporte[0][j] # filas
viajero2 = reporte[i][0] # columnas
if (viajero1 in deben_compensar) and (viajero2
in a_compensar):
valor1 = deben_compensar[viajero1]
valor2 = a_compensar[viajero2]
if valor1 > valor2:
reporte[i][j] = valor2
deben_compensar[viajero1] -= valor2
del a_compensar[viajero2]
elif valor2 > valor1:
reporte[i][j] = valor1
a_compensar[viajero2] -= valor1
del deben_compensar[viajero1]
else:
reporte[i][j] = valor1
del deben_compensar[viajero1]
del a_compensar[viajero2]
else:
reporte[i][j] = 0
return reporte
def generar_reporte_por_viajeros_por_actividad(self, id):
viajeros = self.listar_pasajeros_por_actividad(id)
gastos = self.listar_gastos_actividad(id)
gastos_por_viajero = {}
for nom_viajero in viajeros:
gastos_por_viajero[nom_viajero] = 0
for gasto in gastos:
nombre_apellido = gasto["Nombre"] + " " + gasto["Apellido"]
gastos_por_viajero[nombre_apellido] += gasto["Valor"]
gasto_consolidado = []
for nombre_apellido, valor in gastos_por_viajero.items():
viajero = {}
viajero["Nombre"] = nombre_apellido.split(" ")[0]
viajero["Apellido"] = nombre_apellido.split(" ")[1]
viajero["Valor"] = valor
gasto_consolidado.append(viajero)
return gasto_consolidado
class CancionTestCase(unittest.TestCase):
def setUp(self):
self.session = Session()
self.coleccion = Coleccion()
# Generación de datos con libreria Faker
self.data_factory = Faker()
def test_cancion_sin_interpretes(self):
# Nombre aleatorio
titulo_cancion = self.data_factory.name()
# Número aleatorio entre 0 y 60
minutos_cancion = self.data_factory.pyint(0, 60)
segundos_cancion = self.data_factory.pyint(0, 60)
compositor_cancion = self.data_factory.name()
cancion = self.coleccion.agregar_cancion(titulo_cancion, minutos_cancion, segundos_cancion, compositor_cancion, -1, [])
self.assertEqual(cancion, False)
def test_cancion_varios_interpretes(self):
nombre_interprete1 = self.data_factory.name()
# Frase aleatoria
texto_curiosidades1 = self.data_factory.sentence()
self.coleccion.agregar_interprete(nombre_interprete1, texto_curiosidades1, -1)
nombre_interprete2 = self.data_factory.name()
texto_curiosidades2 = self.data_factory.sentence()
self.coleccion.agregar_interprete(nombre_interprete2, texto_curiosidades2, -1)
titulo_cancion = self.data_factory.name()
minutos_cancion = self.data_factory.pyint(0, 60)
segundos_cancion = self.data_factory.pyint(0, 60)
compositor_cancion = self.data_factory.name()
self.coleccion.agregar_cancion(titulo_cancion, minutos_cancion, segundos_cancion, compositor_cancion, -1,
[{'nombre': nombre_interprete1, 'texto_curiosidades': texto_curiosidades1},
{'nombre': nombre_interprete2,
'texto_curiosidades': texto_curiosidades2}])
consulta = self.session.query(Cancion).filter(Cancion.titulo == titulo_cancion).first()
self.assertIsNotNone(consulta)
def test_cancion_con_album(self):
titulo_album = self.data_factory.name()
# Año aleatorio
anio_album = self.data_factory.year()
descripcion_album = self.data_factory.sentence()
self.coleccion.agregar_album(titulo_album, anio_album, descripcion_album, "CD")
consulta1 = self.session.query(Album).filter(Album.titulo == titulo_album).first().id
self.coleccion.agregar_interprete("Alejandra Guzman", "Canción dedicada a su ...", -1)
minutos_cancion = self.data_factory.pyint(0, 60)
segundos_cancion = self.data_factory.pyint(0, 60)
compositor_cancion = self.data_factory.name()
self.coleccion.agregar_cancion("Bye mamá", minutos_cancion, segundos_cancion, compositor_cancion, consulta1,
[{'nombre': 'Alejandra Guzman',
'texto_curiosidades': 'Canción dedicada a su ...'}])
consulta2 = self.session.query(Cancion).filter(Cancion.titulo == "Bye mamá").first()
self.assertNotEqual(len(consulta2.albumes), 0)
def test_cancion_repetida_album(self):
titulo_album = self.data_factory.name()
anio_album = self.data_factory.year()
descripcion_album = self.data_factory.sentence()
self.coleccion.agregar_album(titulo_album, anio_album, descripcion_album, "CD")
consulta1 = self.session.query(Album).filter(Album.titulo == titulo_album).first().id
nombre_interprete1 = self.data_factory.name()
# Texto aleatorio
texto_curiosidades1 = self.data_factory.text()
self.coleccion.agregar_interprete(nombre_interprete1, texto_curiosidades1, -1)
titulo_cancion1 = self.data_factory.name()
minutos_cancion1 = self.data_factory.pyint(0, 60)
segundos_cancion1 = self.data_factory.pyint(0, 60)
compositor_cancion1 = self.data_factory.name()
self.coleccion.agregar_cancion(titulo_cancion1, minutos_cancion1, segundos_cancion1, compositor_cancion1, consulta1,
[{'nombre': nombre_interprete1,
'texto_curiosidades': texto_curiosidades1}])
nombre_interprete2 = self.data_factory.name()
texto_curiosidades2 = self.data_factory.text()
self.coleccion.agregar_interprete(nombre_interprete2, texto_curiosidades2, -1)
minutos_cancion2 = self.data_factory.pyint(0, 60)
segundos_cancion2 = self.data_factory.pyint(0, 60)
compositor_cancion2 = self.data_factory.name()
cancion = self.coleccion.agregar_cancion(titulo_cancion1, minutos_cancion2, segundos_cancion2, compositor_cancion2, consulta1,
[{'nombre': nombre_interprete2,
'texto_curiosidades': texto_curiosidades2}])
self.assertEqual(cancion, False)
def test_editar_cancion(self):
consulta1 = self.session.query(Cancion).filter(Cancion.id == 2).first().compositor
consulta2 = self.session.query(Interprete).filter(Interprete.nombre == "Franco de Vita").first()
texto_curiosidades = self.data_factory.text()
minutos_cancion = self.data_factory.pyint(0, 60)
segundos_cancion = self.data_factory.pyint(0, 60)
if consulta2 is None:
self.coleccion.agregar_interprete("Franco de Vita", texto_curiosidades, 1)
self.coleccion.editar_cancion(2, "Bye mamá", minutos_cancion, segundos_cancion, "J.R.Florez y Difelisatti",
[{'id': '2', 'nombre': 'Alejandra Guzman',
'texto_curiosidades': 'Canción dedicada a su ...'},
{'id': 'n', 'nombre': 'Franco de Vita',
'texto_curiosidades': texto_curiosidades}])
else:
self.coleccion.editar_cancion(2, "Bye bye", minutos_cancion, segundos_cancion, "J.R.Florez y Difelisatti",
[{'id': '2', 'nombre': 'Alejandra Guzman',
'texto_curiosidades': 'Canción dedicada a su ...'},
{'id': '9', 'nombre': 'Franco de Vita',
'texto_curiosidades': texto_curiosidades}])
consulta3 = self.session.query(Cancion).filter(Cancion.id == 2).first()
self.assertEqual(consulta3.compositor, "J.R.Florez y Difelisatti")
def test_eliminar_cancion(self):
self.coleccion.eliminar_cancion(3)
consulta = self.session.query(Cancion).filter(Cancion.id == 3).first()
self.assertIsNone(consulta)
def test_buscar_canciones_por_titulo(self):
titulo_cancion = self.data_factory.name()
anio_cancion = self.data_factory.year()
descripcion_cancion = self.data_factory.sentence()
self.coleccion.agregar_album(titulo_cancion, anio_cancion, descripcion_cancion, "CD")
consulta1 = self.session.query(Album).filter(Album.titulo == titulo_cancion).first().id
nombre_interprete = self.data_factory.name()
texto_curiosidades = self.data_factory.text()
self.coleccion.agregar_interprete(nombre_interprete, texto_curiosidades, -1)
minutos_cancion = self.data_factory.pyint(0, 60)
segundos_cancion = self.data_factory.pyint(0, 60)
compositor_cancion = self.data_factory.name()
self.coleccion.agregar_cancion("Baby blues", minutos_cancion, segundos_cancion, compositor_cancion, consulta1,
[{'nombre': nombre_interprete,
'texto_curiosidades': texto_curiosidades}])
consulta = self.coleccion.buscar_canciones_por_titulo("Baby")
self.assertGreater(len(consulta), 0)
def test_dar_cancion_por_id(self):
consulta = self.coleccion.dar_cancion_por_id(1)
self.assertEqual(consulta["titulo"], "Baby blues")
class tests_actividades(unittest.TestCase):
def setUp(self):
self.session = Session()
self.cuentas_claras = Logica_mock()
self.data_factory = Faker()
def tearDown(self):
self.session = Session()
busqueda_gastos = self.session.query(Gasto).all()
busqueda_viajeros = self.session.query(Viajero).all()
busqueda_actividad = self.session.query(Actividad).all()
for gasto in busqueda_gastos:
self.session.delete(gasto)
for viajero in busqueda_viajeros:
self.session.delete(viajero)
for actividad in busqueda_actividad:
self.session.delete(actividad)
self.session.commit()
self.session.close()
def test_visualizar_lista_actividades_vacia(self):
consulta0 = self.cuentas_claras.dar_actividades()
self.assertIsNone(consulta0)
def test_visualizar_lista_actividades_una_actividad(self):
nombre_actividad = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
consulta1 = self.cuentas_claras.dar_actividades()
self.assertEqual(len(consulta1), 1)
def test_visualizar_lista_actividades_con_mas_de_una_actividad(self):
nombre_actividad0 = self.data_factory.name()
nombre_actividad1 = self.data_factory.name()
nombre_actividad2 = self.data_factory.name()
nombre_actividad3 = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad0)
self.cuentas_claras.insertar_actividad(nombre_actividad1)
self.cuentas_claras.insertar_actividad(nombre_actividad2)
self.cuentas_claras.insertar_actividad(nombre_actividad3)
consulta1 = self.cuentas_claras.dar_actividades()
self.assertGreater(len(consulta1), 1)
def test_visualizar_lista_gastos_por_actividd_vacia(self):
nombre_actividad = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
actividad_id = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id
consulta1 = self.cuentas_claras.dar_gastos_actividad(actividad_id)
self.assertIsNone(consulta1)
def test_visualizar_lista_gastos_por_actividad_con_un_gasto(self):
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.unique.first_name()
apellido_viajero = self.data_factory.last_name()
self.gasto = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 100),
fecha=self.data_factory.text())
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.session.add(self.gasto)
viajero = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first()
actividad = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
actividad.gastos = [self.gasto]
viajero.gastos = [self.gasto]
self.session.commit()
self.cuentas_claras.asociar_viajero_a_actividad(
viajero.id, actividad.id)
consulta1 = self.cuentas_claras.dar_gastos_actividad(actividad.id)
self.assertEqual(len(consulta1), 1)
def test_visualizar_lista_gastos_por_actividad_con_mas_de_un_gasto(self):
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
gasto1 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 100),
fecha=self.data_factory.text())
gasto2 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 100),
fecha=self.data_factory.text())
gasto3 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 100),
fecha=self.data_factory.text())
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.session.add(gasto1)
self.session.add(gasto2)
self.session.add(gasto3)
actividad = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
viajero = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first()
actividad.gastos = [gasto1, gasto2, gasto3]
viajero.gastos = [gasto1, gasto2, gasto3]
self.session.commit()
self.cuentas_claras.asociar_viajero_a_actividad(
viajero.id, actividad.id)
consulta1 = self.cuentas_claras.dar_gastos_actividad(actividad.id)
self.assertGreater(len(consulta1), 1)
def test_reporte_compensacion_actividad_sin_gastos(self):
nombre_actividad = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
actividad_id = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id
matriz = self.cuentas_claras.generar_reporte_compensacion(actividad_id)
total = 0
for i in range(2, len(matriz)):
for j in range(1, len(matriz[i])):
if matriz[i][j] == -1:
pass
else:
total = total + matriz[i][j]
self.assertEqual(total, 0)
def test_reporte_compensacion_actividad_con_un_gasto(self):
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.gasto1 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 1000),
fecha=self.data_factory.date())
self.actividad0 = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
self.viajero0 = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first()
self.session.add(self.gasto1)
self.actividad0.gastos = [self.gasto1]
self.viajero0.gastos = [self.gasto1]
self.session.commit()
self.cuentas_claras.asociar_viajero_a_actividad(
self.viajero0.id, self.actividad0.id)
matriz = self.cuentas_claras.generar_reporte_compensacion(
self.actividad0.id)
total = 0
for i in range(1, len(matriz)):
for j in range(1, len(matriz[i])):
if matriz[i][j] == -1:
pass
else:
total = total + matriz[i][j]
self.assertEqual(total, self.gasto1.valor)
def test_reporte_compensacion_actividad_con_un_viajero_con_n_gastos(self):
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.gasto1 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 1000),
fecha=self.data_factory.date())
self.gasto2 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 1000),
fecha=self.data_factory.date())
self.gasto3 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 1000),
fecha=self.data_factory.date())
self.gasto4 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 1000),
fecha=self.data_factory.date())
self.actividad0 = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
self.viajero0 = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first()
self.session.add(self.gasto1)
self.session.add(self.gasto2)
self.session.add(self.gasto3)
self.session.add(self.gasto4)
self.actividad0.gastos = [
self.gasto1, self.gasto2, self.gasto3, self.gasto4
]
self.viajero0.gastos = [
self.gasto1, self.gasto2, self.gasto3, self.gasto4
]
self.session.commit()
self.cuentas_claras.asociar_viajero_a_actividad(
self.viajero0.id, self.actividad0.id)
matriz = self.cuentas_claras.generar_reporte_compensacion(
self.actividad0.id)
total = 0
for i in range(2, len(matriz)):
for j in range(1, len(matriz[i])):
total = total + matriz[i][j]
self.assertEqual(total, -1)
def test_reporte_compensacion_actividad_con_varios_viajeros_con_n_gastos_sin_compensacion(
self):
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
nombre_viajero1 = self.data_factory.first_name()
apellido_viajero1 = self.data_factory.last_name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.cuentas_claras.agregar_viajero(nombre_viajero1, apellido_viajero1)
self.data_valores = [
self.data_factory.random_int(1, 1000) for i in range(4)
]
self.suma_valores = 0
for valor in self.data_valores:
self.suma_valores += valor
self.gasto1 = Gasto(concepto=self.data_factory.name(),
valor=self.data_valores[0],
fecha=self.data_factory.date())
self.gasto2 = Gasto(concepto=self.data_factory.name(),
valor=self.data_valores[1],
fecha=self.data_factory.date())
self.gasto3 = Gasto(concepto=self.data_factory.name(),
valor=self.data_valores[2],
fecha=self.data_factory.date())
self.gasto4 = Gasto(concepto=self.data_factory.name(),
valor=self.data_valores[3],
fecha=self.data_factory.date())
self.gasto5 = Gasto(concepto=self.data_factory.name(),
valor=self.suma_valores,
fecha=self.data_factory.date())
self.actividad0 = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
self.viajero0 = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first()
self.viajero1 = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero1
and Viajero.apellido == apellido_viajero1).first()
self.session.add(self.gasto1)
self.session.add(self.gasto2)
self.session.add(self.gasto3)
self.session.add(self.gasto4)
self.session.add(self.gasto5)
self.actividad0.gastos = [
self.gasto1, self.gasto2, self.gasto3, self.gasto4, self.gasto5
]
self.viajero0.gastos = [
self.gasto1, self.gasto2, self.gasto3, self.gasto4
]
self.viajero1.gastos = [self.gasto5]
self.session.commit()
self.cuentas_claras.asociar_viajero_a_actividad(
self.viajero0.id, self.actividad0.id)
self.cuentas_claras.asociar_viajero_a_actividad(
self.viajero1.id, self.actividad0.id)
matriz = self.cuentas_claras.generar_reporte_compensacion(
self.actividad0.id)
valores_gastos = [
gasto.valor for gasto in self.session.query(Gasto).filter(
Gasto.actividad == self.actividad0.id).all()
]
total_valores = 0
for valor in valores_gastos:
total_valores = total_valores + valor
total = 0
for i in range(2, len(matriz)):
for j in range(1, len(matriz[i])):
total = total + matriz[i][j]
total_gastos = 0
for j in range(1, len(matriz[1])):
total_gastos = total_gastos + matriz[1][j]
self.assertEqual(total, -2)
self.assertEqual(total_gastos, total_valores)
def test_reporte_compensacion_actividad_con_varios_viajeros_con_n_gastos_con_compensacion(
self):
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.first_name()
apellido_viajero = self.data_factory.last_name()
nombre_viajero1 = self.data_factory.first_name()
apellido_viajero1 = self.data_factory.last_name()
nombre_viajero2 = self.data_factory.first_name()
apellido_viajero2 = self.data_factory.last_name()
nombre_viajero3 = self.data_factory.first_name()
apellido_viajero3 = self.data_factory.last_name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.cuentas_claras.agregar_viajero(nombre_viajero1, apellido_viajero1)
self.cuentas_claras.agregar_viajero(nombre_viajero2, apellido_viajero2)
self.cuentas_claras.agregar_viajero(nombre_viajero3, apellido_viajero3)
self.gasto1 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 1000),
fecha=self.data_factory.date())
self.gasto2 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 1000),
fecha=self.data_factory.date())
self.gasto3 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 1000),
fecha=self.data_factory.date())
self.gasto4 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 1000),
fecha=self.data_factory.date())
self.gasto5 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 1000),
fecha=self.data_factory.date())
self.gasto6 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 1000),
fecha=self.data_factory.date())
self.gasto7 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 1000),
fecha=self.data_factory.date())
self.gasto8 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 1000),
fecha=self.data_factory.date())
self.actividad0 = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
self.viajero0 = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first()
self.viajero1 = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero1
and Viajero.apellido == apellido_viajero1).first()
self.viajero2 = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero2
and Viajero.apellido == apellido_viajero2).first()
self.viajero3 = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero3
and Viajero.apellido == apellido_viajero3).first()
self.session.add(self.gasto1)
self.session.add(self.gasto2)
self.session.add(self.gasto3)
self.session.add(self.gasto4)
self.session.add(self.gasto5)
self.session.add(self.gasto6)
self.session.add(self.gasto7)
self.session.add(self.gasto8)
self.actividad0.gastos = [
self.gasto1, self.gasto2, self.gasto3, self.gasto4, self.gasto5,
self.gasto6, self.gasto7, self.gasto8
]
self.viajero0.gastos = [
self.gasto1, self.gasto2, self.gasto3, self.gasto4
]
self.viajero1.gastos = [self.gasto5, self.gasto6]
self.viajero3.gastos = [self.gasto7, self.gasto8]
self.session.commit()
self.cuentas_claras.asociar_viajero_a_actividad(
self.viajero0.id, self.actividad0.id)
self.cuentas_claras.asociar_viajero_a_actividad(
self.viajero1.id, self.actividad0.id)
self.cuentas_claras.asociar_viajero_a_actividad(
self.viajero2.id, self.actividad0.id)
self.cuentas_claras.asociar_viajero_a_actividad(
self.viajero3.id, self.actividad0.id)
matriz = self.cuentas_claras.generar_reporte_compensacion(
self.actividad0.id)
total_viajeros = len(
self.session.query(Viajero).filter(
Viajero.actividades.any(
Actividad.id == self.actividad0.id)).all())
valores_gastos = [
gasto.valor for gasto in self.session.query(Gasto).filter(
Gasto.actividad == self.actividad0.id).all()
]
total_valores = 0
for valor in valores_gastos:
total_valores = total_valores + valor
total = 0
for i in range(2, len(matriz)):
for j in range(1, len(matriz[i])):
total = total + matriz[i][j]
total_gastos = 0
for j in range(1, len(matriz[1])):
total_gastos = total_gastos + matriz[1][j]
suma_columna = 0
for j in range(1, total_viajeros + 1):
for i in range(1, total_viajeros + 2):
if matriz[1][j] <= (total_valores / total_viajeros):
if matriz[i][j] == -1:
pass
else:
suma_columna = suma_columna + matriz[i][j]
if i == total_viajeros + 1:
self.assertEqual(suma_columna,
total_valores / total_viajeros)
suma_columna = 0
self.assertEqual(total_gastos, total_valores)
def test_insertar_actividad(self):
nombre_actividad1 = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad1)
nombre_actividad2 = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad2)
consulta1 = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad1).first()
consulta2 = self.session.query(Actividad).filter(
Actividad.id == 2).first()
consulta3 = self.session.query(Actividad).all()
self.assertEqual(consulta1.nombre, nombre_actividad1)
self.assertEqual(consulta2.nombre, nombre_actividad2)
self.assertEqual(len(consulta3), 2)
def test_insertar_actividad_con_mismo_nombre(self):
nombre_actividad1 = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad1)
nombre_actividad2 = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad2)
prueba_guardado = self.cuentas_claras.insertar_actividad(
nombre_actividad1)
consulta3 = self.session.query(Actividad).all()
self.assertEqual(len(consulta3), 2)
self.assertEqual(prueba_guardado, False)
def test_asociar_un_viajero_a_una_actividad(self):
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.unique.first_name()
apellido_viajero = self.data_factory.last_name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
actividad = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
viajero = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first()
resultado = self.cuentas_claras.asociar_viajero_a_actividad(
viajero.id, actividad.id)
viajeros_de_actividad = self.session.query(Viajero).filter(
Viajero.actividades.any(Actividad.id == actividad.id)).all()
self.assertEqual(resultado, True)
self.assertGreater(len(viajeros_de_actividad), 0)
def test_asociar_viajero_repetido_a_una_actividad(self):
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.unique.first_name()
apellido_viajero = self.data_factory.last_name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
actividad = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
viajero = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first()
resultado1 = self.cuentas_claras.asociar_viajero_a_actividad(
viajero.id, actividad.id)
resultado2 = self.cuentas_claras.asociar_viajero_a_actividad(
viajero.id, actividad.id)
self.assertEqual(resultado1, True)
self.assertEqual(resultado2, False)
def test_asociar_viajero_a_actividad_inexistente(self):
nombre_viajero = self.data_factory.unique.first_name()
apellido_viajero = self.data_factory.last_name()
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
viajero = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first()
resultado1 = self.cuentas_claras.asociar_viajero_a_actividad(
viajero.id, 1)
self.assertEqual(resultado1, False)
def test_asociar_viajero_inexistente_a_actividad(self):
nombre_actividad = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
actividad = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
resultado1 = self.cuentas_claras.asociar_viajero_a_actividad(
1, actividad.id)
self.assertEqual(resultado1, False)
def test_asociar_n_viajeros_a_actividad(self):
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.unique.first_name()
apellido_viajero = self.data_factory.last_name()
nombre_viajero2 = self.data_factory.unique.first_name()
apellido_viajero2 = self.data_factory.last_name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.cuentas_claras.agregar_viajero(nombre_viajero2, apellido_viajero2)
actividad = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
viajero = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first()
viajero2 = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero2
and Viajero.apellido == apellido_viajero2).first()
resultado1 = self.cuentas_claras.asociar_viajero_a_actividad(
viajero.id, actividad.id)
resultado2 = self.cuentas_claras.asociar_viajero_a_actividad(
viajero2.id, actividad.id)
viajeros_de_actividad = self.session.query(Viajero).filter(
Viajero.actividades.any(Actividad.id == actividad.id)).all()
self.assertEqual(resultado1, True)
self.assertEqual(resultado2, True)
self.assertEqual(viajeros_de_actividad[0].nombre, viajero.nombre)
self.assertEqual(viajeros_de_actividad[1].apellido, viajero2.apellido)
def test_reporte_gastos_actividad_sin_gastos(self):
nombre_actividad = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
actividad = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
matriz = self.cuentas_claras.reporte_gastos_viajero(actividad.id)
self.assertEqual(len(matriz[0]), 0)
def test_reporte_gastos_actividad_con_un_gasto(self):
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.unique.first_name()
apellido_viajero = self.data_factory.last_name()
self.gasto1 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 100),
fecha=self.data_factory.text())
self.session.add(self.gasto1)
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.actividad = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
self.viajero = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first()
self.actividad.gastos = [self.gasto1]
self.viajero.gastos = [self.gasto1]
self.session.commit()
self.cuentas_claras.asociar_viajero_a_actividad(
self.viajero.id, self.actividad.id)
matriz = self.cuentas_claras.reporte_gastos_viajero(self.actividad.id)
total = 0
for i in range(len(matriz)):
for j in range(len(matriz[i])):
if j == 1:
total = total + matriz[i][j]
self.assertEqual(total, self.gasto1.valor)
def test_reporte_n_gastos_con_un_viajero(self):
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.unique.first_name()
apellido_viajero = self.data_factory.last_name()
self.gasto1 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 100),
fecha=self.data_factory.text())
self.gasto2 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 100),
fecha=self.data_factory.text())
self.gasto3 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 500),
fecha=self.data_factory.text())
self.gasto4 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 300),
fecha=self.data_factory.text())
self.session.add(self.gasto1)
self.session.add(self.gasto2)
self.session.add(self.gasto3)
self.session.add(self.gasto4)
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.actividad = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
self.viajero = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first()
self.actividad.gastos = [
self.gasto1, self.gasto2, self.gasto3, self.gasto4
]
self.viajero.gastos = [
self.gasto1, self.gasto2, self.gasto3, self.gasto4
]
self.session.commit()
self.cuentas_claras.asociar_viajero_a_actividad(
self.viajero.id, self.actividad.id)
matriz = self.cuentas_claras.reporte_gastos_viajero(self.actividad.id)
total = 0
for i in range(len(matriz)):
for j in range(len(matriz[i])):
if j == 1:
total = total + matriz[i][j]
self.assertEqual(total, (self.gasto1.valor + self.gasto2.valor +
self.gasto3.valor + self.gasto4.valor))
self.assertEqual(len(matriz), 1)
def test_reporte_n_gastos_con_n_viajer(self):
nombre_actividad = self.data_factory.name()
nombre_viajero = self.data_factory.unique.first_name()
apellido_viajero = self.data_factory.last_name()
nombre_viajero2 = self.data_factory.unique.first_name()
apellido_viajero2 = self.data_factory.last_name()
nombre_viajero3 = self.data_factory.unique.first_name()
apellido_viajero3 = self.data_factory.last_name()
self.gasto1 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 100),
fecha=self.data_factory.text())
self.gasto2 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 100),
fecha=self.data_factory.text())
self.gasto3 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 500),
fecha=self.data_factory.text())
self.gasto4 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 300),
fecha=self.data_factory.text())
self.gasto5 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 300),
fecha=self.data_factory.text())
self.gasto6 = Gasto(concepto=self.data_factory.name(),
valor=self.data_factory.random_int(1, 300),
fecha=self.data_factory.text())
self.session.add(self.gasto1)
self.session.add(self.gasto2)
self.session.add(self.gasto3)
self.session.add(self.gasto4)
self.session.add(self.gasto5)
self.session.add(self.gasto6)
self.cuentas_claras.insertar_actividad(nombre_actividad)
self.cuentas_claras.agregar_viajero(nombre_viajero, apellido_viajero)
self.cuentas_claras.agregar_viajero(nombre_viajero2, apellido_viajero2)
self.cuentas_claras.agregar_viajero(nombre_viajero3, apellido_viajero3)
self.actividad = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
self.viajero = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero
and Viajero.apellido == apellido_viajero).first()
self.viajero2 = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero2
and Viajero.apellido == apellido_viajero2).first()
self.viajero3 = self.session.query(Viajero).filter(
Viajero.nombre == nombre_viajero3
and Viajero.apellido == apellido_viajero3).first()
self.actividad.gastos = [
self.gasto1, self.gasto2, self.gasto3, self.gasto4, self.gasto5,
self.gasto6
]
self.viajero.gastos = [
self.gasto1, self.gasto2, self.gasto3, self.gasto4
]
self.viajero2.gastos = [self.gasto5, self.gasto6]
self.session.commit()
self.cuentas_claras.asociar_viajero_a_actividad(
self.viajero.id, self.actividad.id)
self.cuentas_claras.asociar_viajero_a_actividad(
self.viajero2.id, self.actividad.id)
self.cuentas_claras.asociar_viajero_a_actividad(
self.viajero3.id, self.actividad.id)
matriz = self.cuentas_claras.reporte_gastos_viajero(self.actividad.id)
gastos = [
gasto.valor for gasto in self.session.query(Gasto).filter(
Gasto.actividad == self.actividad.id).all()
]
total_gastos = 0
for gasto in gastos:
total_gastos = total_gastos + gasto
total = 0
for i in range(len(matriz)):
for j in range(len(matriz[i])):
if j == 1:
total = total + matriz[i][j]
self.assertEqual(total, total_gastos)
self.assertEqual(
len(matriz),
len(
self.session.query(Viajero).filter(
Viajero.actividades.any(
Actividad.id == self.actividad.id)).all()))
def test_editar_actividad(self):
nombre_actividad = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
nuevo_nombre_actividad = self.data_factory.name()
actividad_id = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id
resultado = self.cuentas_claras.editar_actividad(
nombre_actividad, nuevo_nombre_actividad)
actividad = self.session.query(Actividad).filter(
Actividad.id == actividad_id).first()
self.assertEqual(resultado, True)
self.assertEqual(actividad.nombre, nuevo_nombre_actividad)
def test_editar_actividad_con_nombre_vacio(self):
nombre_actividad = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
actividad_id = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id
resultado = self.cuentas_claras.editar_actividad(nombre_actividad, " ")
actividad = self.session.query(Actividad).filter(
Actividad.id == actividad_id).first()
self.assertEqual(resultado, False)
self.assertEqual(actividad.nombre, nombre_actividad)
def test_editar_actividad_con_campo_vacio(self):
nombre_actividad = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
actividad_id = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id
resultado = self.cuentas_claras.editar_actividad(
nombre_actividad, None)
actividad = self.session.query(Actividad).filter(
Actividad.id == actividad_id).first()
self.assertEqual(resultado, False)
self.assertEqual(actividad.nombre, nombre_actividad)
def test_editar_actividad_con_nombre_existente(self):
nombre_actividad = self.data_factory.name()
nombre_actividad2 = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad2)
self.cuentas_claras.insertar_actividad(nombre_actividad)
nuevo_nombre_actividad = nombre_actividad2
actividad_id = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first().id
resultado = self.cuentas_claras.editar_actividad(
nombre_actividad, nuevo_nombre_actividad)
actividad = self.session.query(Actividad).filter(
Actividad.id == actividad_id).first()
self.assertEqual(resultado, False)
self.assertEqual(actividad.nombre, nombre_actividad)
def test_eliminar_actividad(self):
nombre_actividad = self.data_factory.name()
self.cuentas_claras.insertar_actividad(nombre_actividad)
actividad = self.session.query(Actividad).filter(
Actividad.nombre == nombre_actividad).first()
resultado = self.cuentas_claras.eliminar_actividad(actividad.id)
consulta = self.session.query(Actividad).filter(
Actividad.id == actividad.id).first()
self.assertEqual(resultado, True)
self.assertIsNone(consulta)
def test_eliminar_actividad_inexistente(self):
resultado = self.cuentas_claras.eliminar_actividad(1)
self.assertEqual(resultado, False)
class GastosViajeroTestCase(unittest.TestCase):
def setUp(self):
''' Se puebla la base de datos para las pruebas'''
self.session = Session()
busqueda_actividad = self.session.query(Actividad).all()
for actividad in busqueda_actividad:
self.session.delete(actividad)
busqueda_viajero = self.session.query(Viajero).all()
for viajero in busqueda_viajero:
self.session.delete(viajero)
busqueda_gasto = self.session.query(Gasto).all()
for gasto in busqueda_gasto:
self.session.delete(gasto)
busqueda_av = self.session.query(ActividadViajero).all()
for av in busqueda_av:
self.session.delete(av)
self.session.commit()
# Crear actividades y agregarlas a la base de datos con add y commit
self.actividad_1 = Actividad("Paseo a la Playa")
self.actividad_2 = Actividad("Caminata")
self.session.add(self.actividad_1)
self.session.add(self.actividad_2)
self.session.commit()
# Crear los viajeros y agregarlos a la base de datos con add y commit
self.viajero_1 = Viajero("Juan", "Perez")
self.viajero_2 = Viajero("Rosa", "Garcia")
self.viajero_3 = Viajero("Luis", "Mora")
self.viajero_4 = Viajero("Ana", "Zavala")
self.session.add(self.viajero_1)
self.session.add(self.viajero_2)
self.session.add(self.viajero_3)
self.session.add(self.viajero_4)
self.session.commit()
# Crear los gastos. Note que el atributo fecha en este momento es String.
self.gasto_1 = Gasto("Transporte", 100, '21-01-2021')
self.gasto_2 = Gasto("Comida", 200, '22-01-2021')
self.gasto_3 = Gasto("Bebida", 90, '23-01-2021')
self.gasto_4 = Gasto("Fiesta", 120, '24-01-2021')
self.gasto_5 = Gasto("Transporte", 150, '28-01-2021')
self.session.add(self.gasto_1)
self.session.add(self.gasto_2)
self.session.add(self.gasto_3)
self.session.add(self.gasto_4)
self.session.add(self.gasto_5)
self.session.commit()
# Crea las relaciones entre actividad y viajero (cuales son los viajeros asociados a cada actividad)
self.actividad_1.viajeros = [
self.viajero_1, self.viajero_2, self.viajero_3, self.viajero_4
]
self.actividad_2.viajeros = [self.viajero_2]
# Crea las relaciones entre actividad y gasto *(cuales son los gastos de cada actividad)
self.actividad_1.gastos = [
self.gasto_1, self.gasto_2, self.gasto_3, self.gasto_4
]
self.actividad_2.gastos = [self.gasto_5]
# Crea las relaciones entre viajero y gastos (que viajero realizo cada gasto)
self.viajero_1.gastos = [self.gasto_1, self.gasto_3]
self.viajero_2.gastos = [self.gasto_2, self.gasto_5]
self.viajero_3.gastos = [self.gasto_4]
self.viajero_4.gastos = []
self.session.commit()
# Cierra la sesion
self.session.close()
def test_gastos_por_viajero(self):
# Caso 1: actividad sin gastos ni viajeros
self.session = Session()
self.actividad_3 = Actividad("Actividad Vacia")
self.session.add(self.actividad_3)
self.session.commit()
self.viajeross = self.session.query(Viajero).all()
self.viajeros1 = []
for viajero in self.viajeross:
self.viajeros1.append(object_as_dict(viajero))
self.activities = []
self.actividades1 = self.session.query(Actividad).all()
for act in self.actividades1:
self.activities.append(object_as_dict(act))
# Consultar los viajeros registrados en la actividad
self.viajeros_actividad = []
q2 = self.session.query(ActividadViajero).all()
for q in q2:
self.viajeros_actividad.append(object_as_dict(q))
# Determinar los gastos totales por viajero
self.gastos_viajero_act = []
self.viajeros_act = []
for item in self.viajeros_actividad:
actid = item.get("actividad")
if actid == 3:
self.gastos_viajero_act.append([item.get("viajero"), 0])
self.viajeros_act.append(item.get("viajero"))
# Consolidar los gastos por viajero
self.gastos_consolidados = []
self.gastos2 = self.session.query(
Gasto.viajero,
func.sum(
Gasto.valor).label('GastoViajero')).join(Actividad).filter(
Gasto.actividad == 3).group_by(Gasto.viajero).all()
k = 0
for id in self.viajeros_act:
for i in range(len(self.gastos2)):
if id == self.gastos2[i][0]:
self.gastos_viajero_act[k][1] = self.gastos2[k][1]
k += 1
for i in range(len(self.viajeros_act)):
for viajero in self.viajeros1:
if self.viajeros_act[i] == viajero['id']:
self.gastos_consolidados.append({
"Nombre":
viajero["nombre"],
"Apellido":
viajero["apellido"]
})
for i in range(len(self.viajeros_act)):
self.gastos_consolidados[i]['Valor'] = self.gastos_viajero_act[i][
1]
self.lista_gastos = self.gastos_consolidados
self.assertListEqual(self.gastos_consolidados, [])
def test_gastos_actividad_sin_gastos(self):
# Caso 2: actividad sin gastos y un viajero
self.session = Session()
self.actividad_4 = Actividad("Actividad sin gastos")
self.actividad_4.viajeros = [self.viajero_2]
# self.session.add(self.actividad_4)
# self.session.add(self.actividad_4.viajeros)
self.session.commit()
self.viajeross = self.session.query(Viajero).all()
self.viajeros1 = []
for viajero in self.viajeross:
self.viajeros1.append(object_as_dict(viajero))
self.activities = []
self.actividades1 = self.session.query(Actividad).all()
for act in self.actividades1:
self.activities.append(object_as_dict(act))
# Consultar los viajeros registrados en la actividad
self.viajeros_actividad = []
q2 = self.session.query(ActividadViajero).all()
for q in q2:
self.viajeros_actividad.append(object_as_dict(q))
# Determinar los gastos totales por viajero
self.gastos_viajero_act = []
self.viajeros_act = []
for item in self.viajeros_actividad:
actid = item.get("actividad")
if actid == 4:
self.gastos_viajero_act.append([item.get("viajero"), 0])
self.viajeros_act.append(item.get("viajero"))
# Consolidar los gastos por viajero
self.gastos_consolidados = []
self.gastos2 = self.session.query(
Gasto.viajero,
func.sum(
Gasto.valor).label('GastoViajero')).join(Actividad).filter(
Gasto.actividad == 4).group_by(Gasto.viajero).all()
k = 0
for id in self.viajeros_act:
for i in range(len(self.gastos2)):
if id == self.gastos2[i][0]:
self.gastos_viajero_act[k][1] = self.gastos2[k][1]
k += 1
for i in range(len(self.viajeros_act)):
for viajero in self.viajeros1:
if self.viajeros_act[i] == viajero['id']:
self.gastos_consolidados.append({
"Nombre":
viajero["nombre"],
"Apellido":
viajero["apellido"]
})
for i in range(len(self.viajeros_act)):
self.gastos_consolidados[i]['Valor'] = self.gastos_viajero_act[i][
1]
self.assertListEqual(self.gastos_consolidados, [])
def test_gastos_actividad_con_gastos(self):
# Caso 3: actividad con gastos y un viajero
self.session = Session()
self.viajeross = self.session.query(Viajero).all()
self.viajeros1 = []
for viajero in self.viajeross:
self.viajeros1.append(object_as_dict(viajero))
self.activities = []
self.actividades1 = self.session.query(Actividad).all()
for act in self.actividades1:
self.activities.append(object_as_dict(act))
# Consultar los viajeros registrados en la actividad
self.viajeros_actividad = []
q2 = self.session.query(ActividadViajero).all()
for q in q2:
self.viajeros_actividad.append(object_as_dict(q))
# Determinar los gastos totales por viajero
self.gastos_viajero_act = []
self.viajeros_act = []
for item in self.viajeros_actividad:
actid = item.get("actividad")
if actid == 2:
self.gastos_viajero_act.append([item.get("viajero"), 0])
self.viajeros_act.append(item.get("viajero"))
# Consolidar los gastos por viajero
self.gastos_consolidados = []
self.gastos2 = []
self.gastos2 = self.session.query(
Gasto.viajero,
func.sum(
Gasto.valor).label('GastoViajero')).join(Actividad).filter(
Gasto.actividad == 2).group_by(Gasto.viajero).all()
k = 0
for id in self.viajeros_act:
for i in range(len(self.gastos2)):
if id == self.gastos2[i][0]:
self.gastos_viajero_act[k][1] = self.gastos2[k][1]
k += 1
for i in range(len(self.viajeros_act)):
for viajero in self.viajeros1:
if self.viajeros_act[i] == viajero['id']:
self.gastos_consolidados.append({
"Nombre":
viajero["nombre"],
"Apellido":
viajero["apellido"]
})
for i in range(len(self.viajeros_act)):
self.gastos_consolidados[i]['Valor'] = self.gastos_viajero_act[i][
1]
self.assertEqual(self.gastos2[0][1], 150)
def test_gastos_actividad_con_varios_gastos(self):
# Caso 3: actividad con gastos y un viajero
self.session = Session()
self.viajeross = self.session.query(Viajero).all()
self.viajeros1 = []
for viajero in self.viajeross:
self.viajeros1.append(object_as_dict(viajero))
self.activities = []
self.actividades1 = self.session.query(Actividad).all()
for act in self.actividades1:
self.activities.append(object_as_dict(act))
# Consultar los viajeros registrados en la actividad
self.viajeros_actividad = []
q2 = self.session.query(ActividadViajero).all()
for q in q2:
self.viajeros_actividad.append(object_as_dict(q))
# Determinar los gastos totales por viajero
self.gastos_viajero_act = []
self.viajeros_act = []
for item in self.viajeros_actividad:
actid = item.get("actividad")
if actid == 1:
self.gastos_viajero_act.append([item.get("viajero"), 0])
self.viajeros_act.append(item.get("viajero"))
# Consolidar los gastos por viajero
self.gastos_consolidados = []
self.gastos2 = []
self.gastos2 = self.session.query(
Gasto.viajero,
func.sum(
Gasto.valor).label('GastoViajero')).join(Actividad).filter(
Gasto.actividad == 1).group_by(Gasto.viajero).all()
k = 0
for id in self.viajeros_act:
for i in range(len(self.gastos2)):
if id == self.gastos2[i][0]:
self.gastos_viajero_act[k][1] = self.gastos2[k][1]
k += 1
for i in range(len(self.viajeros_act)):
for viajero in self.viajeros1:
if self.viajeros_act[i] == viajero['id']:
self.gastos_consolidados.append({
"Nombre":
viajero["nombre"],
"Apellido":
viajero["apellido"]
})
for i in range(len(self.viajeros_act)):
self.gastos_consolidados[i]['Valor'] = self.gastos_viajero_act[i][
1]
print(self.gastos_consolidados)
self.assertEqual(self.gastos_consolidados[0]['Valor'], 190)
self.assertEqual(self.gastos_consolidados[1]['Valor'], 200)
self.assertEqual(self.gastos_consolidados[2]['Valor'], 120)
self.assertEqual(self.gastos_consolidados[3]['Valor'], 0)
class ListaActividadesTestCase(unittest.TestCase):
def setUp(self):
''' Se puebla la base de datos para las pruebas'''
self.session = Session()
busqueda_actividad = self.session.query(Actividad).all()
for actividad in busqueda_actividad:
self.session.delete(actividad)
busqueda_viajero = self.session.query(Viajero).all()
for viajero in busqueda_viajero:
self.session.delete(viajero)
busqueda_gasto = self.session.query(Gasto).all()
for gasto in busqueda_gasto:
self.session.delete(gasto)
busqueda_av = self.session.query(ActividadViajero).all()
for av in busqueda_av:
self.session.delete(av)
self.session.commit()
# Crear actividades y agregarlas a la base de datos con add y commit
self.actividad_1 = Actividad("Paseo a la Playa")
self.actividad_2 = Actividad("Caminata")
self.session.add(self.actividad_1)
self.session.add(self.actividad_2)
self.session.commit()
# Crear los viajeros y agregarlos a la base de datos con add y commit
self.viajero_1 = Viajero("Juan", "Perez")
self.viajero_2 = Viajero("Rosa", "Garcia")
self.viajero_3 = Viajero("Luis", "Mora")
self.viajero_4 = Viajero("Ana", "Zavala")
self.session.add(self.viajero_1)
self.session.add(self.viajero_2)
self.session.add(self.viajero_3)
self.session.add(self.viajero_4)
self.session.commit()
# Crear los gastos. Note que el atributo fecha en este momento es String.
self.gasto_1 = Gasto("Transporte", 100, '21-01-2021')
self.gasto_2 = Gasto("Comida", 200, '22-01-2021')
self.gasto_3 = Gasto("Bebida", 90, '23-01-2021')
self.gasto_4 = Gasto("Fiesta", 120, '24-01-2021')
self.gasto_5 = Gasto("Transporte", 150, '28-01-2021')
self.session.add(self.gasto_1)
self.session.add(self.gasto_2)
self.session.add(self.gasto_3)
self.session.add(self.gasto_4)
self.session.add(self.gasto_5)
self.session.commit()
# Crea las relaciones entre actividad y viajero (cuales son los viajeros asociados a cada actividad)
self.actividad_1.viajeros = [
self.viajero_1, self.viajero_2, self.viajero_3, self.viajero_4
]
self.actividad_2.viajeros = [self.viajero_2]
# Crea las relaciones entre actividad y gasto *(cuales son los gastos de cada actividad)
self.actividad_1.gastos = [
self.gasto_1, self.gasto_2, self.gasto_3, self.gasto_4
]
self.actividad_2.gastos = [self.gasto_5]
# Crea las relaciones entre viajero y gastos (que viajero realizo cada gasto)
self.viajero_1.gastos = [self.gasto_1, self.gasto_3]
self.viajero_2.gastos = [self.gasto_2, self.gasto_5]
self.viajero_3.gastos = [self.gasto_4]
self.viajero_4.gastos = []
self.session.commit()
# Cierra la sesion
self.session.close()
def test_mostrar_lista_actividad(self):
self.session = Session()
self.actividades = [
a.nombre for a in self.session.query(Actividad.nombre).all()
]
# Mostrar que la lista en la base de datos es la misma que fue insertada
self.lista_actividades = ["Paseo a la Playa", "Caminata"]
self.assertListEqual(self.lista_actividades, self.actividades)
def tearDown(self):
session = Session()
session.close()
class ModificarActividadesTestCase(unittest.TestCase):
def setUp(self):
''' Se puebla la base de datos para las pruebas'''
self.session = Session()
busqueda_actividad = self.session.query(Actividad).all()
for actividad in busqueda_actividad:
self.session.delete(actividad)
busqueda_viajero = self.session.query(Viajero).all()
for viajero in busqueda_viajero:
self.session.delete(viajero)
busqueda_gasto = self.session.query(Gasto).all()
for gasto in busqueda_gasto:
self.session.delete(gasto)
busqueda_av = self.session.query(ActividadViajero).all()
for av in busqueda_av:
self.session.delete(av)
self.session.commit()
# Crear actividades y agregarlas a la base de datos con add y commit
self.actividad_1 = Actividad("Paseo a la Playa")
self.actividad_2 = Actividad("Caminata")
self.session.add(self.actividad_1)
self.session.add(self.actividad_2)
self.session.commit()
# Crear los viajeros y agregarlos a la base de datos con add y commit
self.viajero_1 = Viajero("Juan", "Perez")
self.viajero_2 = Viajero("Rosa", "Garcia")
self.viajero_3 = Viajero("Luis", "Mora")
self.viajero_4 = Viajero("Ana", "Zavala")
self.session.add(self.viajero_1)
self.session.add(self.viajero_2)
self.session.add(self.viajero_3)
self.session.add(self.viajero_4)
self.session.commit()
# Crear los gastos. Note que el atributo fecha en este momento es String.
self.gasto_1 = Gasto("Transporte", 100, '21-01-2021')
self.gasto_2 = Gasto("Comida", 200, '22-01-2021')
self.gasto_3 = Gasto("Bebida", 90, '23-01-2021')
self.gasto_4 = Gasto("Fiesta", 120, '24-01-2021')
self.gasto_5 = Gasto("Transporte", 150, '28-01-2021')
self.session.add(self.gasto_1)
self.session.add(self.gasto_2)
self.session.add(self.gasto_3)
self.session.add(self.gasto_4)
self.session.add(self.gasto_5)
self.session.commit()
# Crea las relaciones entre actividad y viajero (cuales son los viajeros asociados a cada actividad)
self.actividad_1.viajeros = [
self.viajero_1, self.viajero_2, self.viajero_3, self.viajero_4
]
self.actividad_2.viajeros = [self.viajero_2]
# Crea las relaciones entre actividad y gasto *(cuales son los gastos de cada actividad)
self.actividad_1.gastos = [
self.gasto_1, self.gasto_2, self.gasto_3, self.gasto_4
]
self.actividad_2.gastos = [self.gasto_5]
# Crea las relaciones entre viajero y gastos (que viajero realizo cada gasto)
self.viajero_1.gastos = [self.gasto_1, self.gasto_3]
self.viajero_2.gastos = [self.gasto_2, self.gasto_5]
self.viajero_3.gastos = [self.gasto_4]
self.viajero_4.gastos = []
self.session.commit()
# Cierra la sesion
self.session.close()
def test_crear_actividad(self):
# Caso 1: actividad con nombre en blanco
self.session = Session()
self.actividad_3 = Actividad("Actividad 3")
self.session.add(self.actividad_3)
self.session.commit()
self.actividades = [
a.nombre for a in self.session.query(Actividad.nombre).all()
]
self.assertIn("Actividad 3", self.actividades)
self.assertEqual(3, len(self.actividades))
def test_editar_actividad(self):
self.session = Session()
self.session.query(Actividad).filter(
Actividad.nombre == "Caminata").update({'nombre': 'Hiking'})
self.actividades = [
a.nombre for a in self.session.query(Actividad.nombre).all()
]
self.assertIn('Hiking', self.actividades)
self.assertEqual(2, len(self.actividades))
def test_eliminar_actividad(self):
self.session = Session()
self.session.query(Actividad).filter(
Actividad.nombre == "Caminata").delete()
self.actividades = [
a.nombre for a in self.session.query(Actividad.nombre).all()
]
class Listar_actividades_test_case(unittest.TestCase):
def setUp(self):
'''Crea una colección para hacer las pruebas'''
self.cuentas_claras = Cuentas_claras()
'''Abre la sesión'''
self.session = Session()
self.data_factory = Faker()
Faker.seed(1000)
# crear actividades random
self.actividades = []
for _ in range(2):
actividad = Actividad(nombre=self.data_factory.text())
self.session.add(actividad)
self.actividades.append(actividad)
# crear viajeros random
self.viajeros = []
for _ in range(2):
viajero = Viajero(self.data_factory.unique.first_name(),
self.data_factory.unique.last_name())
self.session.add(viajero)
self.viajeros.append(viajero)
self.actividades[1].agregar_viajero_en_actividad(self.viajeros[0])
self.actividades[1].agregar_viajero_en_actividad(self.viajeros[1])
# crear gastos random
self.gastos = []
for _ in range(2):
gasto = Gasto(concepto=self.data_factory.text(),
valor=random.uniform(1, 1000),
fecha_gasto=datetime.strptime(
self.data_factory.date(), '%Y-%m-%d'))
self.session.add(gasto)
self.gastos.append(gasto)
self.viajeros[0].agregar_gasto(self.gastos[0])
self.viajeros[0].agregar_gasto(self.gastos[1])
self.actividades[1].agregar_gasto(self.gastos[0])
self.actividades[1].agregar_gasto(self.gastos[1])
self.session.commit()
def tearDown(self):
'''Abre la sesión'''
self.session = Session()
'''Consulta todas las actividades'''
actividades = self.session.query(Actividad).all()
'''Borra todas las actividades'''
for actividad in actividades:
self.session.delete(actividad)
'''Consulta todos los viajeros'''
viajeros = self.session.query(Viajero).all()
'''Borra todos los viajeros'''
for viajero in viajeros:
self.session.delete(viajero)
self.session.commit()
self.session.close()
def test_actividad_sin_gastos(self):
"Validar si la actividad no tiene ningún gasto devuelve una lista vacía"
reporte_por_viajero = self.cuentas_claras.generar_reporte_por_viajeros_por_actividad(
1)
self.assertIsInstance(reporte_por_viajero, list)
self.assertEqual(len(reporte_por_viajero), 0)
def test_viajero_sin_gasto(self):
"Validar si un viajero de una actividad no tiene gastos, debe aparecer en la lista con gasto 0"
reporte_por_viajero = self.cuentas_claras.generar_reporte_por_viajeros_por_actividad(
2)
nombre_apellido = self.viajeros[1].dar_nombre(
) + " " + self.viajeros[1].dar_apellido()
temp_reporte = {
viajero['Nombre'] + " " + viajero['Apellido']: viajero['Valor']
for viajero in reporte_por_viajero
}
self.assertIn(nombre_apellido, temp_reporte)
self.assertEqual(temp_reporte[nombre_apellido], 0)
def test_suma_valores(self):
"Validar que la suma total de los gatos de los viajeros es igual a la suma total de los gastos de la actividad"
reporte_por_viajero = self.cuentas_claras.generar_reporte_por_viajeros_por_actividad(
2)
gasto_total = 0
gastos = self.actividades[1].dar_gastos()
for gasto in gastos:
gasto_total += float(gasto.dar_valor())
gasto_total_reporte = 0
for viajero in reporte_por_viajero:
gasto_total_reporte += float(viajero['Valor'])
self.assertEqual(gasto_total, gasto_total_reporte)
def mostrar_actividades(self, lista_actividades):
"""
Esta función puebla la tabla con las actividades
"""
self.actividades = lista_actividades
#Este pedazo de código borra todo lo que no sean encabezados, es decir, a partir del tercer elemento.
while self.distribuidor_tabla_actividades.count() > 2:
child = self.distribuidor_tabla_actividades.takeAt(2)
if child.widget():
child.widget().deleteLater()
self.distribuidor_tabla_actividades.setColumnStretch(0, 1)
self.distribuidor_tabla_actividades.setColumnStretch(1, 0)
self.distribuidor_tabla_actividades.setColumnStretch(2, 0)
self.distribuidor_tabla_actividades.setColumnStretch(3, 0)
self.distribuidor_tabla_actividades.setColumnStretch(4, 0)
self.distribuidor_tabla_actividades.setColumnStretch(4, 0)
#Ciclo para llenar la tabla
if (self.actividades != None and len(self.actividades) > 0):
self.tabla_actividades.setVisible(True)
#Creación de las etiquetas
etiqueta_actividad = QLabel("Actividad")
etiqueta_actividad.setMinimumSize(QSize(0, 0))
etiqueta_actividad.setMaximumSize(QSize(65525, 65525))
etiqueta_actividad.setAlignment(Qt.AlignCenter)
etiqueta_actividad.setFont(QFont("Times", weight=QFont.Bold))
self.distribuidor_tabla_actividades.addWidget(
etiqueta_actividad, 0, 0, Qt.AlignCenter)
etiqueta_acciones = QLabel("Acciones")
etiqueta_acciones.setMinimumSize(QSize(0, 0))
etiqueta_acciones.setMaximumSize(QSize(65525, 65525))
etiqueta_acciones.setAlignment(Qt.AlignCenter)
etiqueta_acciones.setFont(QFont("Times", weight=QFont.Bold))
self.distribuidor_tabla_actividades.addWidget(
etiqueta_acciones, 0, 1, 1, 5, Qt.AlignCenter)
numero_fila = 0
global actividad_id
lista_id_numero_fila = list() # Ivan semana 07
Base.metadata.create_all(engine) # Ivan semana 07
session = Session() # Ivan semana 07
actividad_id = [x[0] for x in session.query(Actividad.id)
] # Ivan semana 07
session.close()
for item in self.actividades:
numero_fila = numero_fila + 1
lista_id_numero_fila.append(
(numero_fila - 1,
actividad_id[numero_fila - 1])) # Ivan semana 07
etiqueta_actividad = QLabel(item)
etiqueta_actividad.setWordWrap(True)
self.distribuidor_tabla_actividades.addWidget(
etiqueta_actividad, numero_fila, 0)
#Creación de los botones asociados a cada acción
btn_terminar = QPushButton("", self)
btn_terminar.setToolTip("Terminar")
btn_terminar.setFixedSize(40, 40)
btn_terminar.setIcon(QIcon("src/recursos/001-no-stopping.png"))
btn_terminar.clicked.connect(
partial(self.terminar_actividad, numero_fila - 1))
self.distribuidor_tabla_actividades.addWidget(
btn_terminar, numero_fila, 1, Qt.AlignCenter)
btn_ver_actividad = QPushButton("", self)
btn_ver_actividad.setToolTip("Ver")
btn_ver_actividad.setFixedSize(40, 40)
btn_ver_actividad.setIcon(
QIcon(
"src/recursos/002-eye-variant-with-enlarged-pupil.png")
)
btn_ver_actividad.clicked.connect(
partial(self.mostrar_actividad, numero_fila - 1))
self.distribuidor_tabla_actividades.addWidget(
btn_ver_actividad, numero_fila, 2, Qt.AlignCenter)
btn_ver_viajeros = QPushButton("", self)
btn_ver_viajeros.setToolTip("Viajeros")
btn_ver_viajeros.setFixedSize(40, 40)
btn_ver_viajeros.setIcon(
QIcon("src/recursos/003-multiple-users-silhouette.png"))
btn_ver_viajeros.clicked.connect(
partial(self.mostrar_dialogo_insertar_viajeros, item))
self.distribuidor_tabla_actividades.addWidget(
btn_ver_viajeros, numero_fila, 3, Qt.AlignCenter)
btn_editar = QPushButton("", self)
btn_editar.setToolTip("Edit")
btn_editar.setFixedSize(40, 40)
btn_editar.setIcon(QIcon("src/recursos/004-edit-button.png"))
btn_editar.clicked.connect(
partial(self.mostrar_dialogo_editar_actividad,
numero_fila - 1))
self.distribuidor_tabla_actividades.addWidget(
btn_editar, numero_fila, 4, Qt.AlignCenter)
btn_eliminar = QPushButton("", self)
btn_eliminar.setToolTip("Delete")
btn_eliminar.setFixedSize(40, 40)
btn_eliminar.setIcon(QIcon("src/recursos/005-delete.png"))
btn_eliminar.clicked.connect(
partial(self.eliminar_actividad, numero_fila - 1))
self.distribuidor_tabla_actividades.addWidget(
btn_eliminar, numero_fila, 5, Qt.AlignCenter)
print(lista_id_numero_fila) # Ivan
else:
self.tabla_actividades.setVisible(False)
numero_fila = 0
#Elemento para ajustar la forma de la tabla (y evitar que queden muy espaciados)
self.distribuidor_tabla_actividades.layout().setRowStretch(
numero_fila + 2, 1)
