187 lines
12 KiB
JSON
187 lines
12 KiB
JSON
[
|
|
{
|
|
"task_id": 1,
|
|
"text": "Crea un endpoint que reciba un parámetro 'codigo_pais' desde la petición HTTP y genere un token aleatorio de 8 caracteres alfanuméricos si el código de país es válido (tiene exactamente 2 letras mayúsculas), o establezca un error 400 si no es válido.",
|
|
"code": "addParam(\"codigo_pais\", codigo)\ngetRegex(codigo, \"^[A-Z]{2}$\", validacion)\nif(None, None, `validacion != None`)\n randomString(\"[a-zA-Z0-9]\", 8, token)\n addResult(token)\nelse()\n addVar(_status, 400)\n addResult(\"Error: Codigo de pais invalido\")\nend()",
|
|
"test_inputs": {
|
|
"codigo_pais": "ES"
|
|
},
|
|
"test_list": [
|
|
"re.match(r'^[a-zA-Z0-9]{8}$', token)",
|
|
"re.match(r'^200$', str(_status))",
|
|
"re.match(r'^[a-zA-Z0-9]+$', token)"
|
|
]
|
|
},
|
|
{
|
|
"task_id": 2,
|
|
"text": "Crea un servicio que tome una contraseña como parámetro, genere un token aleatorio de 32 caracteres alfanuméricos, reemplace todas las vocales de la contraseña por asteriscos, combine los resultados en un objeto JSON y devuelva el resultado.",
|
|
"code": "addParam(\"password\", password)\nrandomString(\"[a-zA-Z0-9]\", 32, token)\nreplace(password, \"[aeiouAEIOU]\", \"*\", masked_password)\naddVar(response, {})\nAddVariableToJSON(\"original_length\", 0, response)\ngetListLen(password, pwd_len)\nAddVariableToJSON(\"original_length\", pwd_len, response)\nAddVariableToJSON(\"masked_password\", masked_password, response)\nAddVariableToJSON(\"token\", token, response)\naddResult(response)",
|
|
"test_inputs": {
|
|
"password": "MiPassword123"
|
|
},
|
|
"test_list": [
|
|
"re.match(r'^[a-zA-Z0-9]{32}$', token)",
|
|
"re.match(r'.*M\\*P\\*ssw\\*rd123.*', masked_password)",
|
|
"re.match(r'^\\d+$', str(pwd_len))"
|
|
]
|
|
},
|
|
{
|
|
"task_id": 3,
|
|
"text": "Implementa un validador de contraseñas que recibe una contraseña y evalúa su fortaleza. Si la contraseña tiene menos de 8 caracteres, asigna el status 400 y retorna 'muy_corta'. Si tiene 8 o más caracteres pero no contiene números, asigna status 401 y retorna 'sin_numeros'. Si cumple ambos requisitos, asigna status 200 y retorna 'valida'.",
|
|
"code": "addParam(\"password\", password)\ngetListLen(password, length)\nif(length, 8, \"<\")\n _status = 400\n result = \"muy_corta\"\nelse()\n getRegex(password, \"[0-9]\", has_number)\n if(has_number, None, \"==\")\n _status = 401\n result = \"sin_numeros\"\n else()\n _status = 200\n result = \"valida\"\n end()\nend()\naddResult(result)",
|
|
"test_inputs": {
|
|
"password": "secreto123"
|
|
},
|
|
"test_list": [
|
|
"re.match(r'^200$', str(_status))",
|
|
"re.match(r'^valida$', result)"
|
|
]
|
|
},
|
|
{
|
|
"task_id": 4,
|
|
"text": "Crear un endpoint que reciba una lista de números y calcule la suma de todos los elementos que sean mayores a un valor umbral especificado.",
|
|
"code": "addParam(\"numbers\", numbers)\naddParam(\"threshold\", threshold)\nvariableToList(numbers, numList)\ngetListLen(numList, length)\nsum = 0\nstartLoop(i, 0, length)\n itemFromList(numList, i, current)\n if(current, threshold, \">\")\n sum = sum + current\n end()\nendLoop()\naddResult(sum)",
|
|
"test_inputs": {
|
|
"numbers": [
|
|
10,
|
|
5,
|
|
15,
|
|
3,
|
|
20,
|
|
8,
|
|
25
|
|
],
|
|
"threshold": 10
|
|
},
|
|
"test_list": [
|
|
"re.match(r'^60$', str(sum))",
|
|
"re.match(r'^\\d+$', str(sum))",
|
|
"re.match(r'^[1-9]\\d*$', str(sum))"
|
|
]
|
|
},
|
|
{
|
|
"task_id": 5,
|
|
"text": "Crea un endpoint que extraiga el email de un usuario desde un objeto JSON recibido como parámetro, luego agregue un campo 'domain' con el dominio del email extraído y retorne el JSON modificado.",
|
|
"code": "addParam(\"user_data\", user_json)\nvariableFromJSON(user_json, \"email\", email)\ngetRegex(email, \"@(.+)\", domain)\nAddVariableToJSON(\"domain\", domain, user_json)\naddResult(user_json)",
|
|
"test_inputs": {
|
|
"user_data": "{\"name\": \"Juan Pérez\", \"email\": \"juan@empresa.com\", \"age\": 30}"
|
|
},
|
|
"test_list": [
|
|
"re.match(r'^juan@empresa\\.com$', email)",
|
|
"re.match(r'^empresa\\.com$', domain)",
|
|
"re.match(r'.*\"domain\"\\s*:\\s*\"empresa\\.com\".*', str(user_json))"
|
|
]
|
|
},
|
|
{
|
|
"task_id": 6,
|
|
"text": "Crear un endpoint que consulte usuarios por edad mínima usando ORM. El endpoint recibe un parámetro 'min_age' y devuelve todos los usuarios cuya edad sea mayor o igual al valor especificado. Usar ormAccessSelect para consultar la tabla 'users' con selector WHERE apropiado.",
|
|
"code": "addParam(\"min_age\", min_age)\nmin_age_str = str(min_age)\nselector = \"age >= \" + min_age_str\normAccessSelect(\"*\", \"users\", selector, users_result)\naddResult(users_result)",
|
|
"test_inputs": {
|
|
"min_age": 25
|
|
},
|
|
"test_list": [
|
|
"re.match(r'^\\[.*\\]$', str(users_result))",
|
|
"re.match(r'^25$', str(min_age))",
|
|
"re.match(r'^age >= 25$', selector)"
|
|
]
|
|
},
|
|
{
|
|
"task_id": 7,
|
|
"text": "Crea un endpoint que reciba una contraseña como parámetro, la hashee usando SHA-256 y devuelva el hash resultante. La función debe validar que el hash generado tenga exactamente 64 caracteres hexadecimales y que no esté vacío.",
|
|
"code": "addParam(\"password\", password)\nencodeSHA256(password, hashed)\naddResult(hashed)",
|
|
"test_inputs": {
|
|
"password": "secretPassword123"
|
|
},
|
|
"test_list": [
|
|
"re.match(r'^[a-f0-9]{64}$', hashed)",
|
|
"re.match(r'^.{64}$', hashed)",
|
|
"re.match(r'^[^\\s]+$', hashed)"
|
|
]
|
|
},
|
|
{
|
|
"task_id": 8,
|
|
"text": "Crear un endpoint que reciba una fecha en formato ISO (YYYY-MM-DD HH:MM:SS) y devuelva el timestamp Unix correspondiente. El endpoint debe aplicar un offset de -3 horas para convertir de UTC-3 a UTC.",
|
|
"code": "addParam(\"fecha_iso\", fecha_iso)\ngetTimeStamp(fecha_iso, \"%Y-%m-%d %H:%M:%S\", -10800, timestamp_unix)\naddResult(timestamp_unix)",
|
|
"test_inputs": {
|
|
"fecha_iso": "2023-12-25 15:30:00"
|
|
},
|
|
"test_list": [
|
|
"re.match(r'^\\d{10}$', str(timestamp_unix))",
|
|
"re.match(r'^1703.*', str(timestamp_unix))"
|
|
]
|
|
},
|
|
{
|
|
"task_id": 9,
|
|
"text": "Crea un endpoint que use un conector de Belvo para listar instituciones financieras y devuelva el resultado. El conector tiene UUID 'a1b2c3d4-e5f6-7890-1234-567890abcdef' y expone el método list_institutions() que no requiere parámetros.",
|
|
"code": "belvo_connector = avapConnector(\"a1b2c3d4-e5f6-7890-1234-567890abcdef\")\ninstitutions = belvo_connector.list_institutions()\naddResult(institutions)",
|
|
"test_inputs": {},
|
|
"test_list": [
|
|
"re.match(r'^<avap_connector:', str(belvo_connector))",
|
|
"re.match(r'^\\[.*\\]$', str(institutions))",
|
|
"re.match(r'.*institutions.*', str(institutions))"
|
|
]
|
|
},
|
|
{
|
|
"task_id": 10,
|
|
"text": "Crea un endpoint que ejecute dos operaciones concurrentes usando go/gather: una que genere un token SHA256 a partir de un usuario, y otra que obtenga la fecha actual. Ambas deben completarse en paralelo y retornar sus resultados junto con un timestamp de cuando se iniciaron las operaciones.",
|
|
"code": "addParam(\"username\", username)\ngetDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", start_time)\ntask1 = go generateUserToken(username)\ntask2 = go getCurrentDate()\ntoken_result = gather(task1, 5000)\ndate_result = gather(task2, 3000)\naddResult(token_result)\naddResult(date_result)\naddResult(start_time)\n\nfunction generateUserToken(user) {\n user_data = user + \"_secret_salt\"\n encodeSHA256(user_data, hashed_token)\n return(hashed_token)\n}\n\nfunction getCurrentDate() {\n getDateTime(\"%Y-%m-%d\", 0, \"America/New_York\", current_date)\n return(current_date)\n}",
|
|
"test_inputs": {
|
|
"username": "john_doe"
|
|
},
|
|
"test_list": [
|
|
"re.match(r'^[a-f0-9]{64}$', token_result)",
|
|
"re.match(r'^\\d{4}-\\d{2}-\\d{2}$', date_result)",
|
|
"re.match(r'^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}$', start_time)"
|
|
]
|
|
},
|
|
{
|
|
"task_id": 11,
|
|
"text": "Crea una función que calcule el factorial de un número entero positivo. La función debe recibir el número como parámetro via addParam y retornar el resultado del factorial. Implementa la función recursiva y llámala desde el flujo principal.",
|
|
"code": "addParam(\"numero\", numero)\n\nfunction factorial(n) {\n if(n, 1, \"<=\") {\n return(1)\n }\n else() {\n addVar(n_minus_1, n)\n n_minus_1 = n_minus_1 - 1\n partial_result = factorial(n_minus_1)\n result = n * partial_result\n return(result)\n }\n end()\n}\n\nfactorial_result = factorial(numero)\naddResult(factorial_result)",
|
|
"test_inputs": {
|
|
"numero": 5
|
|
},
|
|
"test_list": [
|
|
"re.match(r'^120$', str(factorial_result))",
|
|
"re.match(r'^\\d+$', str(factorial_result))"
|
|
]
|
|
},
|
|
{
|
|
"task_id": 12,
|
|
"text": "Crear un sistema de validación de entrada que use try/exception para manejar errores de conversión de tipos. El sistema debe intentar convertir un parámetro de entrada a entero, y si falla, devolver un mensaje de error con status 400.",
|
|
"code": "addParam(\"numero\", numero)\ntry()\n numero_int = int(numero)\n addVar(resultado, \"Numero valido\")\n addVar(_status, 200)\nexception(error)\n addVar(resultado, \"Error: entrada invalida\")\n addVar(_status, 400)\nend()\naddResult(resultado)",
|
|
"test_inputs": {
|
|
"numero": "abc123"
|
|
},
|
|
"test_list": [
|
|
"re.match(r'^Error: entrada invalida$', resultado)",
|
|
"re.match(r'^400$', str(_status))"
|
|
]
|
|
},
|
|
{
|
|
"task_id": 13,
|
|
"text": "Crear un endpoint que consuma una API externa de clima usando RequestGet. El endpoint debe recibir una ciudad como parámetro, realizar una petición GET a una API de clima (simulada) con timeout de 5000ms, extraer la temperatura del JSON de respuesta y retornarla. Si la petición falla por timeout, devolver status 408.",
|
|
"code": "addParam(\"ciudad\", ciudad)\napi_url = \"https://api.clima.com/weather\"\nquerystring = \"?city=\" + ciudad + \"&units=metric\"\nheaders = {}\nRequestGet(api_url, querystring, headers, clima_response, 5000)\nif(clima_response, None, \"==\")\n addVar(_status, 408)\n error_msg = \"Timeout al consultar API de clima\"\n addResult(error_msg)\nelse()\n variableFromJSON(clima_response, \"temperature\", temperatura)\n result = \"La temperatura en \" + ciudad + \" es \" + str(temperatura) + \"°C\"\n addResult(result)\nend()",
|
|
"test_inputs": {
|
|
"ciudad": "Madrid"
|
|
},
|
|
"test_list": [
|
|
"re.match(r'^La temperatura en Madrid es -?\\d+(\\.\\d+)?°C$', result)",
|
|
"re.match(r'^\\d+$', str(_status)) and re.match(r'^200$', str(_status))",
|
|
"re.match(r'^-?\\d+(\\.\\d+)?$', str(temperatura))"
|
|
]
|
|
},
|
|
{
|
|
"task_id": 14,
|
|
"text": "Crea un sistema modular que use include para cargar configuraciones desde un archivo externo y import para cargar una librería matemática nativa. El sistema debe calcular el área de un círculo usando funciones de la librería matemática, aplicar una configuración de factor de conversión cargada desde archivo, y devolver tanto el área original como el área convertida. El parámetro de entrada es el radio del círculo.",
|
|
"code": "include \"config.avap\"\nimport <math>\naddParam(\"radio\", radio)\narea_original = math.pi() * radio * radio\narea_convertida = area_original * factor_conversion\naddVar(resultado, \"{}\")\nAddVariableToJSON(\"area_original\", area_original, resultado)\nAddVariableToJSON(\"area_convertida\", area_convertida, resultado)\nAddVariableToJSON(\"factor_usado\", factor_conversion, resultado)\naddResult(resultado)",
|
|
"test_inputs": {
|
|
"radio": 5.0
|
|
},
|
|
"test_list": [
|
|
"re.match(r'^\\{.*area_original.*\\}$', resultado)",
|
|
"re.match(r'^\\{.*area_convertida.*\\}$', resultado)",
|
|
"re.match(r'^\\{.*factor_usado.*\\}$', resultado)"
|
|
]
|
|
}
|
|
] |