def dispersion_notas(cod_materia): transformer = DataTransformer() provider = DataProvider() token = get_token(request) # Saco el token del request df = get_alumnos_de_materia_periodo(request, cod_materia) carrera = request.args.get('carrera') if carrera: alumnos_carrera_json = provider.get_alumnos_de_carrera(token, carrera) else: alumnos_carrera_json = provider.getCareerStudents(token) alumnos_carrera_df = transformer.transform_to_dataframe( alumnos_carrera_json) data = transformer.merge_materias_con_promedio(df, alumnos_carrera_df) # Itero para generar el json final resultado = [] for row in data.itertuples(): nota = getattr(row, 'nota') if nota: resultado.append({ "Promedio": getattr(row, 'promedio'), "Alumno": getattr(row, 'alumno'), "Nota": nota }) return json.dumps(resultado)
def get_materiascursadas(request, cod_carrera=None, inicio=None, fin=None, subjectCode=None): provider = DataProvider() transformer = DataTransformer() manipulator = DataManipulator() # Saco el token del request token = get_token(request) # Formateo los args fecha_inicio = inicio or request.args.get('inicio') fecha_fin = fin or request.args.get('fin') # Tiene que ser una sola carrera y un solo plan para calcular creditos carrera = cod_carrera or request.args.get('carrera') plan = request.args.get('plan') # Traigo las cursadas if carrera: cursadas_json = provider.get_materiascursadas(token, carrera) else: cursadas_json = provider.getTakenSubjects(token, subjectCode) cursadas_data = transformer.transform_materiascursadas_to_dataframe( cursadas_json) # Filtro periodo df = manipulator.filtrar_periodo(cursadas_data, fecha_inicio, fecha_fin) return df
def recursantes_materia(cod_materia): token = get_token(request) cod_materia = cod_materia.zfill(5) carrera = request.args.get('carrera') fecha_fin = request.args.get('fecha') anio = fecha_fin.split('-')[0] if fecha_fin else None mes = fecha_fin.split('-')[1] if fecha_fin else None semestre = 1 if mes and int(mes) <= 6 else 2 dm = DataManipulator() # Filtro los inscriptos de la carrera y materia if carrera: inscriptos = DataProvider().get_inscriptos(token, carrera, anio, semestre) else: inscriptos = DataProvider().getEnrolled(token, cod_materia, anio, semestre) inscriptos_df = DataTransformer().transform_materiascursadas_to_dataframe( inscriptos) # Filtro las cursadas de la carrera y materia if carrera: cursadas = DataProvider().get_materiascursadas(token, carrera) else: cursadas = DataProvider().getTakenSubjects(token, cod_materia) cursadas_df = DataTransformer().transform_materiascursadas_to_dataframe( cursadas) recursantes = dm.get_recursantes(cursadas_df, inscriptos_df, cod_materia) return json.dumps([{ "Legajo": key, "Cantidad": value } for key, value in recursantes.items()])
def get_cantidad_materias_necesarias(request): provider = DataProvider() # Saco el token del request token = get_token(request) carrera = request.args.get('carrera') plan = request.args.get('plan') return provider.get_cantidad_materias_necesarias(token, carrera, plan)["cantidad"]
def cantidad_ingresantes_actual(carrera): token = get_token(request) provider = DataProvider() anio = date.today().year cursantes = provider.get_ingresantes(token, carrera, anio) return json.dumps({ 'nombre': 'Ingresantes del año actual', 'valor': cursantes["cantidad"] })
def cantidades_ingresantes_carrera(carrera): ''' Deberia retornar una lista del tipo [{"anio": 2015, "Ingresantes": 100}] ''' token = get_token(request) provider = DataProvider() ingresantes = provider.get_ingresantes(token, carrera) return json.dumps([{ "Cohorte": dato["anio"], "Ingresantes": dato["cantidad"] } for dato in ingresantes])
def getStudent(studentNumber): token = get_token(request) provider = DataProvider() student = provider.getStudent(token, studentNumber) studentFirstName = student.get("nombre") if student.get("nombre") else '' studentLastName = student.get("apellido") if student.get( "apellido") else '' return json.dumps({ 'nombre': 'Estudiante', 'valor': (studentFirstName + ' ' + studentLastName).strip() })
def cantidades_alumnos_carrera(carrera): ''' Deberia retornar una lista del tipo [{"Cohorte": 2015, "Graduados": 2, "Cursantes": 200, "Ingresantes": 100, "postulantes": 500}] ''' token = get_token(request) provider = DataProvider() graduados = provider.get_graduados(token, carrera) ingresantes = provider.get_ingresantes(token, carrera) cursantes = provider.get_cursantes(token, carrera) return json.dumps([{ "Cohorte": cursantes[i]["anio"], "Graduados": graduados[i]["cantidad"], "Cursantes": cursantes[i]["cantidad"], "Ingresantes": ingresantes[i]["cantidad"] } for i in range(0, len(cursantes))])
def get_plan(request, carrera=None): provider = DataProvider() transformer = DataTransformer() # Saco el token del request token = get_token(request) # Formateo los args fecha_inicio = request.args.get('inicio') fecha_fin = request.args.get('fin') # Tiene que ser una sola carrera y un solo plan para calcular creditos carrera = carrera or request.args.get('carrera') plan = request.args.get('plan') # Traigo el plan plan_json = provider.get_plan(token, carrera, plan) plan_data = transformer.transform_to_dataframe(plan_json) return plan_data
def alumnos_carrera(carrera): token = get_token(request) transformer = DataTransformer() json_data = DataProvider().get_alumnos_de_carrera(token, carrera) data = transformer.transform_to_dataframe(json_data) inscriptos = DataManipulator().inscriptos_por_carrera(data)['alumno'] return json.dumps([{ "nombre": transformer.transform_timestamp_to_semester(key), "cantidad": value } for key, value in inscriptos.items()])
def get_materiascursadas_promedio(request, carrera, inicio=None, fin=None): cursadas_data = get_materiascursadas(request, carrera, inicio, fin) transformer = DataTransformer() # Obtengo los alumnos de la carrera token = get_token(request) # Saco el token del request alumnos_carrera_json = DataProvider().get_alumnos_de_carrera( token, carrera) alumnos_carrera_df = transformer.transform_to_dataframe( alumnos_carrera_json) data = transformer.merge_materias_con_promedio(cursadas_data, alumnos_carrera_df) return data
def setUp(self): self.provider = DataProvider() self.mock_app = mock_app self.url = "localhost" self.port = 8008
class ProviderTest(unittest.TestCase): def setUp(self): self.provider = DataProvider() self.mock_app = mock_app self.url = "localhost" self.port = 8008 def test_get_alumnos_de_carrera(self): with self.mock_app.run(self.url, self.port): token = self.provider.retrieve_token() alumnos = self.provider.get_alumnos_de_carrera(token, 'TEST') self.assertEqual(len(alumnos), 10) def test_get_cantidad_materias_necesarias(self): with self.mock_app.run(self.url, self.port): token = self.provider.retrieve_token() materias_necesarias = self.provider.get_cantidad_materias_necesarias(token, 'TEST', 2019) self.assertEqual(materias_necesarias['cantidad'], 40) def test_get_plan(self): with self.mock_app.run(self.url, self.port): token = self.provider.retrieve_token() materias = self.provider.get_plan(token, 'TEST', 2019) self.assertEqual(len(materias), 59) def test_get_inscriptos(self): with self.mock_app.run(self.url, self.port): token = self.provider.retrieve_token() inscriptos = self.provider.get_inscriptos(token, 'TEST') self.assertEqual(len(inscriptos), 10) def test_get_graduados(self): with self.mock_app.run(self.url, self.port): token = self.provider.retrieve_token() graduados = self.provider.get_graduados(token, 'TEST') self.assertEqual(len(graduados), 10) def test_get_graduados_anio(self): with self.mock_app.run(self.url, self.port): token = self.provider.retrieve_token() graduados = self.provider.get_graduados(token, 'TEST', 2019) self.assertEqual(graduados['cantidad'], 1) def test_get_ingresantes(self): with self.mock_app.run(self.url, self.port): token = self.provider.retrieve_token() ingresantes = self.provider.get_ingresantes(token, 'TEST') self.assertEqual(len(ingresantes), 10) def test_get_ingresantes_anio(self): with self.mock_app.run(self.url, self.port): token = self.provider.retrieve_token() ingresantes = self.provider.get_ingresantes(token, 'TEST', 2019) self.assertEqual(ingresantes['cantidad'], 2) def test_get_cursantes(self): with self.mock_app.run(self.url, self.port): token = self.provider.retrieve_token() cursantes = self.provider.get_cursantes(token, 'TEST') self.assertEqual(len(cursantes), 10) def test_get_cursantes_anio(self): with self.mock_app.run(self.url, self.port): token = self.provider.retrieve_token() cursantes = self.provider.get_cursantes(token, 'TEST', 2019) self.assertEqual(cursantes['cantidad'], 10) def test_get_postulantes(self): with self.mock_app.run(self.url, self.port): token = self.provider.retrieve_token() postulantes = self.provider.get_postulantes(token, 'TEST') self.assertEqual(len(postulantes), 10) def test_get_postulantes_anio(self): with self.mock_app.run(self.url, self.port): token = self.provider.retrieve_token() postulantes = self.provider.get_postulantes(token, 'TEST', 2019) self.assertEqual(postulantes['cantidad'], 3)
def setUp(self): self.provider = DataProvider() self.mock_app = mock_app self.mock_url = "0.0.0.0" self.mock_port = 8008
class AppTest(unittest.TestCase): def setUp(self): self.provider = DataProvider() self.mock_app = mock_app self.mock_url = "0.0.0.0" self.mock_port = 8008 def test_recursantes_unauthorized(self): """ Hago un request sin el token, y deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: response = client.get( '/materias/90028/recursantes?carrera=TEST') self.assertEqual(response.status_code, 401) def test_recursantes(self): """ Hago un request con token, deberia darme los recursantes Chequeo que el alumno con legajo 1 haya recursado 2 veces """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/materias/90028/recursantes?carrera=TEST', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) self.assertEqual(data[0]["Legajo"], '1') self.assertEqual(data[0]["Cantidad"], 2) def test_detalle_aprobados_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/materias/90028/detalle-aprobados?carrera=TEST') self.assertEqual(response.status_code, 401) def test_detalle_aprobados(self): """ Hago un request con token Deberia darme un solo resultado, el alumno con legajo 10 Que promociono en otra carrera """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/materias/90028/detalle-aprobados?carrera=TEST', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) self.assertEqual(data[0]['Promocion en otra carrera'], 1) def test_basicos_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get('/materias/90028/basicos?carrera=TEST') self.assertEqual(response.status_code, 401) def test_basicos_aprobados(self): """ Hago un request con token Segun los datos, hay un solo aprobado """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/materias/90028/basicos?carrera=TEST', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) self.assertEqual(data[0]['Aprobados'], 1) def test_basicos_ausentes(self): """ Hago un request con token Segun los datos, no hay ausentes """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/materias/90028/basicos?carrera=TEST', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) self.assertEqual(data[0]['Ausentes'], 0) def test_basicos_desaprobados(self): """ Hago un request con token Segun los datos, hay 4 desaprobados """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/materias/90028/basicos?carrera=TEST', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) self.assertEqual(data[0]['Desaprobados'], 4) def test_basicos_faltantes(self): """ Hago un request con token Segun los datos, hay 9 faltantes """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/materias/90028/basicos?carrera=TEST', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) self.assertEqual(data[0]['Faltantes'], 9) def test_dispersion_notas_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/materias/90028/dispersion-notas?carrera=TEST') self.assertEqual(response.status_code, 401) def test_dispersion_notas(self): """ Hago un request con token Devuelvo la primer nota, que deberia ser 2 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/materias/90028/dispersion-notas?carrera=TEST', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) self.assertEqual(data[0]['Nota'], '2') def test_porcentajes_areas_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/alumnos/1/porcentajes-areas?carrera=TEST&plan=2019') self.assertEqual(response.status_code, 401) def test_porcentajes_areas(self): """ Hago un request con token Deberia tener un 50 de ingles """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/alumnos/1/porcentajes-areas?carrera=TEST&plan=2019', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) for materia in data: if materia['nombre'] == 'Inglés': self.assertEqual("%.2f" % materia['valor'], '50.00') def test_porcentajes_nucleos_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/alumnos/1/porcentajes-nucleos?carrera=TEST&plan=2019') self.assertEqual(response.status_code, 401) def test_porcentajes_nucleos(self): """ Hago un request con token Deberia tener un 33.33 del ingreso """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/alumnos/1/porcentajes-nucleos?carrera=TEST&plan=2019', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) for nucleo in data: if nucleo['nombre'] == 'I': self.assertEqual("%.2f" % nucleo['valor'], '33.33') def test_alumnos_carrera_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get('/carreras/TEST/alumnos?plan=2019') self.assertEqual(response.status_code, 401) def test_alumnos_carrera(self): """ Hago un request con token Deberia darme 10 alumnos """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/carreras/TEST/alumnos?plan=2019', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) self.assertEqual(data[0]['cantidad'], 10) def test_cantidades_alumnos_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/carreras/TEST/cantidades-alumnos?plan=2019') self.assertEqual(response.status_code, 401) def test_cantidades_alumnos_graduados(self): """ Hago un request con token Deberia recibir [..., {'Cohorte': 2019, 'Graduados': 1, 'Cursantes': 10, 'Ingresantes': 2}] """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/carreras/TEST/cantidades-alumnos?plan=2019', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) for cohorte in data: if cohorte['Cohorte'] == 2019: self.assertEqual(cohorte['Graduados'], 1) def test_cantidades_alumnos_ingresantes(self): """ Hago un request con token Deberia recibir [..., {'Cohorte': 2019, 'Graduados': 1, 'Cursantes': 10, 'Ingresantes': 2}] """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/carreras/TEST/cantidades-alumnos', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) for cohorte in data: if cohorte['Cohorte'] == 2019: self.assertEqual(cohorte['Ingresantes'], 2) def test_cantidades_alumnos_cursantes(self): """ Hago un request con token Deberia recibir [..., {'Cohorte': 2019, 'Graduados': 1, 'Cursantes': 10, 'Ingresantes': 2}] """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/carreras/TEST/cantidades-alumnos', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) for cohorte in data: if cohorte['Cohorte'] == 2019: self.assertEqual(cohorte['Cursantes'], 10) def test_cantidades_ingresantes_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get('/carreras/TEST/cantidades-ingresantes') self.assertEqual(response.status_code, 401) def test_cantidades_ingresantes(self): """ Hago un request con token Deberia recibir [..., {'Cohorte': 2019, 'Ingresantes': 2}] """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/carreras/TEST/cantidades-ingresantes', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) for cohorte in data: if cohorte['Cohorte'] == 2019: self.assertEqual(cohorte['Ingresantes'], 2) def test_cursantes_actual_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get('/carreras/TEST/cursantes-actual') self.assertEqual(response.status_code, 401) def test_cursantes_actual(self): """ Hago un request con token Deberia recibir {'nombre': 'Cursantes del año actual', 'valor': 10} """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/carreras/TEST/cursantes-actual', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) self.assertEqual(data['valor'], 10) def test_ingresantes_actual_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get('/carreras/TEST/ingresantes-actual') self.assertEqual(response.status_code, 401) def test_ingresantes_actual(self): """ Hago un request con token Deberia recibir {'nombre': 'Ingresantes del año actual', 'valor': 2} """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/carreras/TEST/ingresantes-actual', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) self.assertEqual(data['valor'], 2) def test_graduados_total_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get('/carreras/TEST/graduados-total') self.assertEqual(response.status_code, 401) def test_graduados_total(self): """ Hago un request con token Deberia recibir {'nombre': 'Graduados', 'valor': 1} """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/carreras/TEST/graduados-total', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) self.assertEqual(data['valor'], 1) def test_notas_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/alumnos/1/notas?carrera=TEST&plan=2019') self.assertEqual(response.status_code, 401) ''' def test_notas(self): """ Hago un request con token Deberia recibir [... {'Fecha': '2018-02-07', 'Materia': 'Inglés II', 'Plan': 2019, 'Nota': '3'}] """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get('/alumnos/1/notas?carrera=TEST&plan=2019', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) for materia in data: if materia['Materia'] == 'Inglés II' and materia['Fecha'] == '2018-02-07': self.assertEqual(materia['Nota'], '3') ''' def test_scores_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/alumnos/1/scores?carrera=TEST&plan=2019') self.assertEqual(response.status_code, 401) def test_scores(self): """ Hago un request con token Deberia recibir [{'nombre': '2017-S2', 'valor': 3.0}, {'nombre': '2018-S2', 'valor': 5.666666666666667}] """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/alumnos/1/scores?carrera=TEST&plan=2019', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) print(data) for score in data: if score['nombre'] == '2017-S2': self.assertEqual(score['valor'], 3) def test_porcentaje_carrera_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/alumnos/1/porcentaje-carrera?carrera=TEST&plan=2019') self.assertEqual(response.status_code, 401) def test_porcentaje_carrera(self): """ Hago un request con token Deberia recibir {"nombre": "Porcentaje de avance", "valor": 5.0} porque tiene aprobadas 2 de 40 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/alumnos/1/porcentaje-carrera?carrera=TEST&plan=2019', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) self.assertEqual(data['valor'], '5.0') def test_dispersion_score_unauthorized(self): """ Hago un request sin token, deberia darme 401 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/carreras/TEST/dispersion-score-promedio?dias=18250') self.assertEqual(response.status_code, 401) def test_dispersion_score_carrera(self): """ Hago un request con token Si hay datos de los ultimos 365 dias, deberia recibir [... {'Promedio': '7', 'Alumno': '9', 'Score': 2.0}] Como los datos son fijos, este test dejaria de andar en el año 2070 """ with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/carreras/TEST/dispersion-score-promedio?dias=18250', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) for alumno in data: if alumno['Alumno'] == '9': self.assertEqual(alumno['Score'], 2) def test_getStudent(self): with self.mock_app.run(self.mock_url, self.mock_port): with test_app.test_client() as client: token = self.provider.retrieve_token() response = client.get( '/alumno/16921', headers={"Authorization": f"Bearer {token}"}) data = json.loads(response.data) self.assertEqual(data.get('nombre'), 'Estudiante') self.assertEqual(data.get('valor'), 'Nestor Munoz')
def main(): gmaps = googlemaps.Client(key='AIzaSyC9Jw099A_9uXyK8KFQPxR93-cg3ks5E40') p = DataProvider(mapClient=gmaps) p.makeData(refresh=False)
def cantidad_graduados(carrera): token = get_token(request) provider = DataProvider() anio = date.today().year cursantes = provider.get_graduados(token, carrera, anio) return json.dumps({'nombre': 'Graduados', 'valor': cursantes["cantidad"]})