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 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 setUp(self):
self.session = Session()
self.cuentas_claras = Logica_mock()
self.data_factory = Faker()
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)
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 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 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()
]
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_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):
'''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 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_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 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 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 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 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()
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")
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 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):
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 insertar_actividad(self, nombre):
"""
Esta función inserta una actividad en la lógica (debe modificarse cuando se construya la lógica)
"""
session = Session() # Ivan
session.add(Actividad(nombre=nombre)) # Ivan
session.commit() # Ivan
session.close() # Ivan
self.logica = Logica_mock() # Ivan
self.vista_lista_actividades.mostrar_actividades(
self.logica.actividades)
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 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 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 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))
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)
def insertar_viajero(self, nombre, apellido):
"""
Esta función inserta un viajero en la lógica (debe modificarse cuando se construya la lógica)
"""
Base.metadata.create_all(engine) # Ivan
session = Session() # Ivan
session.add(Viajero(nombre=nombre, apellido=apellido)) # Ivan
session.commit() # Ivan
self.logica = Logica_mock() # Ivan
self.vista_lista_viajeros.mostrar_viajeros(self.logica.viajeros)
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)
from src.modelo.declarative_base import Session #Ivan
from src.logica.Logica_mock import * # Ivan
session = Session()
class Coleccion():
def __init__(self):
Base.metadata.create_all(engine)
def insertar_la_actividad(self,nombre):
busqueda = session.query(Actividad).filter(Actividad.nombre == nombre).all()
if len(busqueda) ==0:
actividad = Actividad(nombre=nombre)
session.add(actividad)
session.commit()
return True
else:
return False
def editar_la_actividad(self,nombre_a_cambiar, nombre_alternativo):
busqueda = session.query(Actividad).filter(Actividad.nombre == nombre_a_cambiar).all()
if len(busqueda) !=0:
actividad = session.query(Actividad).filter(Actividad.nombre == nombre_a_cambiar).first()
actividad.nombre = nombre_alternativo
session.commit()
return True
else:
return False
def eliminar_la_actividad(self,nombre):
