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 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 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)
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 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)
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 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 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 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 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 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 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 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))
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() ]