Add new JSON output files for candidate F reward statistics and MBPP tasks
- Created `candidate_F_reward_10_coverage_stats.json` with coverage statistics including total cells, filled cells, fill rate, and node type frequency. - Added `mbpp_avap.json` containing 14 tasks with descriptions, code implementations, test inputs, and expected test results for various endpoints and functionalities.
This commit is contained in:
pseco
parent
d50f33c707
commit
febf955a62
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1 @@
|
|||
[]
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
{
|
||||
"total_cells": 9139,
|
||||
"filled_cells": 0,
|
||||
"fill_rate": 0.0,
|
||||
"distribution_entropy": 0.0,
|
||||
"node_type_frequency": {},
|
||||
"low_quality_cells": 0,
|
||||
"empty_cells": 9139
|
||||
}
|
||||
|
|
@ -0,0 +1,601 @@
|
|||
[
|
||||
{
|
||||
"task_id": 1,
|
||||
"text": "Crear un servicio de API que genere múltiples tokens de sesión aleatorios para diferentes tipos de usuarios utilizando patrones específicos y almacene los resultados en una base de datos. El servicio debe procesar una lista de tipos de usuario y generar tokens únicos para cada tipo usando iteraciones controladas.",
|
||||
"code": "import \"crypto_utils\"\naddParam(\"user_types\", user_types_param)\naddParam(\"token_length\", token_length_param)\ndb = avapConnector(\"db_token_12345\")\nif(user_types_param, None, \"==\")\n addVar(_status, 400)\n addResult(error_msg)\nelse()\n variableToList(user_types_param, user_types_list)\n getListLen(user_types_list, list_length)\n addVar(counter, 0)\n startLoop(i, 0, list_length)\n itemFromList(user_types_list, i, current_user_type)\n if(current_user_type, \"admin\", \"==\")\n randomString(\"[A-Z0-9]\", 16, admin_token)\n addVar(final_token, admin_token)\n else()\n randomString(\"[a-z0-9]\", 12, regular_token)\n addVar(final_token, regular_token)\n end()\n ormAccessInsert({\"user_type\": current_user_type, \"token\": final_token, \"created_at\": \"2024-01-01\"}, \"user_tokens\", insert_result)\n addVar(counter, counter + 1)\n endLoop()\n ormAccessSelect(\"*\", \"user_tokens\", \"\", all_tokens)\n addResult(all_tokens)\n addResult(counter)\n addVar(_status, 201)\nend()",
|
||||
"test_inputs": {
|
||||
"user_types": [
|
||||
"admin",
|
||||
"user",
|
||||
"guest"
|
||||
],
|
||||
"token_length": "12"
|
||||
},
|
||||
"test_list": [
|
||||
"re.match(r'\\[.*\\]', str(all_tokens))",
|
||||
"re.match(r'^[0-9]+$', str(counter))",
|
||||
"re.match(r'^20[0-9]$', str(_status))"
|
||||
],
|
||||
"_cell": [
|
||||
"import",
|
||||
"randomString",
|
||||
"startLoop"
|
||||
],
|
||||
"_prior_weight": 0.4182,
|
||||
"_quality": {
|
||||
"fidelity": 1.0,
|
||||
"bonus_ratio": 0.371,
|
||||
"test_quality": 1.0,
|
||||
"richness": 0.933,
|
||||
"quality": 1.405,
|
||||
"detected": [
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"avapConnector",
|
||||
"else",
|
||||
"end",
|
||||
"endLoop",
|
||||
"getListLen",
|
||||
"if_mode1",
|
||||
"import",
|
||||
"itemFromList",
|
||||
"ormAccessInsert",
|
||||
"ormAccessSelect",
|
||||
"randomString",
|
||||
"startLoop"
|
||||
],
|
||||
"cell": [
|
||||
"import",
|
||||
"randomString",
|
||||
"startLoop"
|
||||
],
|
||||
"extra": [
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"avapConnector",
|
||||
"else",
|
||||
"end",
|
||||
"endLoop",
|
||||
"getListLen",
|
||||
"if_mode1",
|
||||
"itemFromList",
|
||||
"ormAccessInsert",
|
||||
"ormAccessSelect"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"task_id": 2,
|
||||
"text": "Crear un microservicio que consulte información de un usuario desde una API externa usando GET, valide la respuesta y maneje diferentes códigos de estado HTTP según el resultado obtenido.",
|
||||
"code": "addParam(\"user_id\", user_id)\nif(user_id, None, \"==\")\n_status = 400\naddVar(response_error, \"Missing user_id parameter\")\naddResult(response_error)\nelse()\napi_url = \"https://jsonplaceholder.typicode.com/users/\"\napi_url = api_url + str(user_id)\nheaders = {\"Content-Type\": \"application/json\"}\nRequestGet(api_url, \"\", headers, api_response, 5000)\nif(api_response, None, \"==\")\n_status = 503\naddVar(service_error, \"External API unavailable\")\naddResult(service_error)\nelse()\nvariableFromJSON(api_response, \"id\", user_found_id)\nif(user_found_id, None, \"==\")\n_status = 404\naddVar(not_found_msg, \"User not found in external service\")\naddResult(not_found_msg)\nelse()\nvariableFromJSON(api_response, \"name\", user_name)\nvariableFromJSON(api_response, \"email\", user_email)\nvariableFromJSON(api_response, \"phone\", user_phone)\nif(None, None, `len(user_name) > 0 and \"@\" in user_email`)\n_status = 200\naddVar(success_msg, \"User data retrieved successfully\")\naddResult(success_msg)\naddResult(user_name)\naddResult(user_email)\naddResult(user_phone)\nelse()\n_status = 422\naddVar(invalid_data, \"Invalid user data from external API\")\naddResult(invalid_data)\nend()\nend()\nend()\nend()",
|
||||
"test_inputs": {
|
||||
"user_id": "1"
|
||||
},
|
||||
"test_list": [
|
||||
"re.match(r'^User data retrieved successfully$', success_msg)",
|
||||
"re.match(r'^[A-Za-z\\s]+$', user_name)",
|
||||
"re.match(r'^[\\w\\._%+-]+@[\\w\\.-]+\\.[A-Za-z]{2,}$', user_email)"
|
||||
],
|
||||
"_cell": [
|
||||
"RequestGet",
|
||||
"_status"
|
||||
],
|
||||
"_prior_weight": 0.1313,
|
||||
"_quality": {
|
||||
"fidelity": 1.0,
|
||||
"bonus_ratio": 0.194,
|
||||
"test_quality": 1.0,
|
||||
"richness": 1.0,
|
||||
"quality": 1.358,
|
||||
"detected": [
|
||||
"RequestGet",
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"else",
|
||||
"end",
|
||||
"if_mode2",
|
||||
"variableFromJSON"
|
||||
],
|
||||
"cell": [
|
||||
"RequestGet",
|
||||
"_status"
|
||||
],
|
||||
"extra": [
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"else",
|
||||
"end",
|
||||
"if_mode2",
|
||||
"variableFromJSON"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"task_id": 3,
|
||||
"text": "Crear un endpoint que actualice el estado de múltiples tareas en una base de datos. El endpoint recibe una lista de IDs de tareas como parámetro de consulta, actualiza cada tarea al estado 'completada' y retorna el número de tareas actualizadas exitosamente.",
|
||||
"code": "addParam(\"task_ids\", task_list)\nif(task_list, None, \"!=\")\n getListLen(task_list, total_tasks)\n addVar(updated_count, 0)\n addVar(counter, 0)\n startLoop(i, 0, total_tasks)\n itemFromList(task_list, i, current_task_id)\n addVar(fields, [\"status\"])\n addVar(values, [\"completed\"])\n addVar(selector, \"id = %s\" % current_task_id)\n ormAccessUpdate(fields, values, \"tasks\", selector, update_result)\n if(update_result, None, \"is not None\")\n addVar(updated_count, updated_count + 1)\n end()\n addVar(counter, counter + 1)\n endLoop()\n addResult(updated_count)\n addVar(_status, 200)\nelse()\n addVar(error_msg, \"No task IDs provided\")\n addResult(error_msg)\n addVar(_status, 400)\nend()",
|
||||
"test_inputs": {
|
||||
"task_ids": [
|
||||
"101",
|
||||
"102",
|
||||
"103"
|
||||
]
|
||||
},
|
||||
"test_list": [
|
||||
"re.match(r'\\d+', str(updated_count))",
|
||||
"re.match(r'2\\d\\d', str(_status))",
|
||||
"re.match(r'completed', 'completed')"
|
||||
],
|
||||
"_cell": [
|
||||
"addVar",
|
||||
"itemFromList",
|
||||
"ormAccessUpdate"
|
||||
],
|
||||
"_prior_weight": 0.5394,
|
||||
"_quality": {
|
||||
"fidelity": 1.0,
|
||||
"bonus_ratio": 0.257,
|
||||
"test_quality": 1.0,
|
||||
"richness": 0.767,
|
||||
"quality": 1.354,
|
||||
"detected": [
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"else",
|
||||
"end",
|
||||
"endLoop",
|
||||
"getListLen",
|
||||
"if_mode1",
|
||||
"itemFromList",
|
||||
"ormAccessUpdate",
|
||||
"startLoop"
|
||||
],
|
||||
"cell": [
|
||||
"addVar",
|
||||
"itemFromList",
|
||||
"ormAccessUpdate"
|
||||
],
|
||||
"extra": [
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"else",
|
||||
"end",
|
||||
"endLoop",
|
||||
"getListLen",
|
||||
"if_mode1",
|
||||
"startLoop"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"task_id": 4,
|
||||
"text": "Desarrolla un endpoint de API que reciba un parámetro 'user_id', consulte la base de datos para obtener los datos del usuario en formato JSON, extraiga el campo 'email' del JSON resultante y devuelva el email junto con el status code apropiado. Si no encuentra el usuario, debe devolver un error 404.",
|
||||
"code": "addParam(\"user_id\", userId)\nif(userId, None, \"==\")\n addVar(_status, 400)\n addResult(_status)\nelse()\n ormAccessSelect(\"*\", \"users\", \"id = \" + str(userId), userResult)\n getListLen(userResult, resultCount)\n if(resultCount, 0, \"==\")\n addVar(_status, 404)\n addResult(_status)\n else()\n itemFromList(userResult, 0, firstUser)\n variableFromJSON(firstUser, \"email\", userEmail)\n variableFromJSON(firstUser, \"name\", userName)\n addVar(_status, 200)\n addResult(userEmail)\n addResult(userName)\n addResult(_status)\n end()\nend()",
|
||||
"test_inputs": {
|
||||
"user_id": "123"
|
||||
},
|
||||
"test_list": [
|
||||
"re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$', userEmail)",
|
||||
"re.match(r'^[A-Za-z\\s]+$', userName)",
|
||||
"re.match(r'^200$', str(_status))"
|
||||
],
|
||||
"_cell": [
|
||||
"addParam",
|
||||
"ormAccessSelect",
|
||||
"variableFromJSON"
|
||||
],
|
||||
"_prior_weight": 0.2485,
|
||||
"_quality": {
|
||||
"fidelity": 1.0,
|
||||
"bonus_ratio": 0.229,
|
||||
"test_quality": 1.0,
|
||||
"richness": 0.667,
|
||||
"quality": 1.335,
|
||||
"detected": [
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"else",
|
||||
"end",
|
||||
"getListLen",
|
||||
"if_mode1",
|
||||
"itemFromList",
|
||||
"ormAccessSelect",
|
||||
"variableFromJSON"
|
||||
],
|
||||
"cell": [
|
||||
"addParam",
|
||||
"ormAccessSelect",
|
||||
"variableFromJSON"
|
||||
],
|
||||
"extra": [
|
||||
"_status",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"else",
|
||||
"end",
|
||||
"getListLen",
|
||||
"if_mode1",
|
||||
"itemFromList"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"task_id": 5,
|
||||
"text": "Crear un microservicio que consulte productos en una base de datos, verifique el stock disponible y aplique descuentos basados en la cantidad. El servicio debe manejar casos donde no se encuentren productos y recorrer los resultados para calcular el precio total.",
|
||||
"code": "addParam(\"user_id\", user_id)\naddParam(\"categoria\", categoria)\naddParam(\"descuento_minimo\", descuento_min)\nif(user_id, None, \"!=\")\n ormAccessSelect(\"*\", \"productos\", \"categoria = '\" + categoria + \"'\", productos_lista)\n getListLen(productos_lista, total_productos)\n if(total_productos, 0, \">\")\n precio_total = 0\n descuento_aplicado = 0\n startLoop(i, 0, total_productos)\n itemFromList(productos_lista, i, producto_actual)\n variableFromJSON(producto_actual, \"precio\", precio_item)\n variableFromJSON(producto_actual, \"stock\", stock_item)\n variableFromJSON(producto_actual, \"nombre\", nombre_item)\n if(stock_item, 0, \">\")\n precio_total = precio_total + precio_item\n if(precio_item, descuento_min, \">=\")\n descuento_aplicado = descuento_aplicado + (precio_item * 0.1)\n else()\n addResult(nombre_item)\n end()\n else()\n addVar(mensaje_error, \"Producto sin stock: \" + nombre_item)\n addResult(mensaje_error)\n end()\n endLoop()\n precio_final = precio_total - descuento_aplicado\n addResult(precio_final)\n addVar(_status, 200)\n else()\n addVar(mensaje, \"No se encontraron productos en la categoria\")\n addResult(mensaje)\n addVar(_status, 404)\n end()\nelse()\n addVar(error_msg, \"ID de usuario requerido\")\n addResult(error_msg)\n addVar(_status, 400)\nend()",
|
||||
"test_inputs": {
|
||||
"user_id": "123",
|
||||
"categoria": "electronicos",
|
||||
"descuento_minimo": "100"
|
||||
},
|
||||
"test_list": [
|
||||
"re.match(r'\\d+', precio_final)",
|
||||
"re.match(r'[A-Za-z]+', mensaje)",
|
||||
"re.match(r'\\d{3}', _status)"
|
||||
],
|
||||
"_cell": [
|
||||
"else",
|
||||
"ormAccessSelect",
|
||||
"startLoop"
|
||||
],
|
||||
"_prior_weight": 0.2909,
|
||||
"_quality": {
|
||||
"fidelity": 1.0,
|
||||
"bonus_ratio": 0.286,
|
||||
"test_quality": 1.0,
|
||||
"richness": 1.0,
|
||||
"quality": 1.386,
|
||||
"detected": [
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"else",
|
||||
"end",
|
||||
"endLoop",
|
||||
"getListLen",
|
||||
"if_mode1",
|
||||
"itemFromList",
|
||||
"ormAccessSelect",
|
||||
"startLoop",
|
||||
"variableFromJSON"
|
||||
],
|
||||
"cell": [
|
||||
"else",
|
||||
"ormAccessSelect",
|
||||
"startLoop"
|
||||
],
|
||||
"extra": [
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"end",
|
||||
"endLoop",
|
||||
"getListLen",
|
||||
"if_mode1",
|
||||
"itemFromList",
|
||||
"variableFromJSON"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"task_id": 6,
|
||||
"text": "Crear un microservicio para registrar transacciones bancarias que valide el monto, inserte los datos en base de datos y maneje errores de conexión. El servicio debe rechazar montos negativos o nulos y retornar códigos HTTP apropiados.",
|
||||
"code": "registerEndpoint(\"/api/transaction\", \"POST\", [], \"Crear nueva transacción\", mainHandler, db_connector)\naddParam(\"amount\", amount)\naddParam(\"user_id\", user_id)\naddParam(\"description\", description)\ndb_connector = avapConnector(\"db_token_12345\")\nif(amount, 0, \"<=\")\n addVar(_status, 400)\n addResult(error_msg)\n return()\nelse()\n addVar(transaction_id, \"TXN\")\n randomString(\"[A-Z0-9]\", 8, random_suffix)\n transaction_id = transaction_id + random_suffix\n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", created_at)\n variableToList(user_id, fields_values)\n variableToList(amount, temp_amount)\n variableToList(description, temp_desc)\n variableToList(transaction_id, temp_id)\n variableToList(created_at, temp_date)\n getListLen(fields_values, current_len)\n itemFromList(temp_amount, 0, amount_value)\n itemFromList(temp_desc, 0, desc_value)\n itemFromList(temp_id, 0, id_value)\n itemFromList(temp_date, 0, date_value)\n try()\n ormAccessInsert([user_id, amount_value, desc_value, id_value, date_value], \"transactions\", insert_result)\n addVar(_status, 201)\n AddVariableToJSON(\"transaction_id\", transaction_id, response_data)\n AddVariableToJSON(\"status\", \"success\", response_data)\n AddVariableToJSON(\"amount\", amount_value, response_data)\n addResult(response_data)\n exception(db_error)\n addVar(_status, 500)\n AddVariableToJSON(\"error\", \"Database connection failed\", error_response)\n AddVariableToJSON(\"details\", db_error, error_response)\n addResult(error_response)\n end()\nend()",
|
||||
"test_inputs": {
|
||||
"amount": "150.75",
|
||||
"user_id": "USER123",
|
||||
"description": "Payment for services"
|
||||
},
|
||||
"test_list": [
|
||||
"re.match(r'TXN[A-Z0-9]{8}', transaction_id)",
|
||||
"re.match(r'\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}', created_at)",
|
||||
"re.match(r'success', response_data)"
|
||||
],
|
||||
"_cell": [
|
||||
"if_mode1",
|
||||
"ormAccessInsert",
|
||||
"try"
|
||||
],
|
||||
"_prior_weight": 0.4424,
|
||||
"_quality": {
|
||||
"fidelity": 1.0,
|
||||
"bonus_ratio": 0.371,
|
||||
"test_quality": 1.0,
|
||||
"richness": 1.0,
|
||||
"quality": 1.411,
|
||||
"detected": [
|
||||
"AddVariableToJSON",
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"avapConnector",
|
||||
"else",
|
||||
"end",
|
||||
"getDateTime",
|
||||
"getListLen",
|
||||
"if_mode1",
|
||||
"itemFromList",
|
||||
"ormAccessInsert",
|
||||
"randomString",
|
||||
"return",
|
||||
"try"
|
||||
],
|
||||
"cell": [
|
||||
"if_mode1",
|
||||
"ormAccessInsert",
|
||||
"try"
|
||||
],
|
||||
"extra": [
|
||||
"AddVariableToJSON",
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"avapConnector",
|
||||
"else",
|
||||
"end",
|
||||
"getDateTime",
|
||||
"getListLen",
|
||||
"itemFromList",
|
||||
"randomString",
|
||||
"return"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"task_id": 7,
|
||||
"text": "Crear un endpoint que importe una librería de utilidades, haga una petición GET a una API externa para obtener datos de clima, valide la respuesta y retorne información procesada con el estado HTTP apropiado.",
|
||||
"code": "import \"weather_utils\"\nfunction validateTemperature(temp) {\n if(temp, 50, \">=\") {\n return(\"extreme_hot\")\n else()\n if(temp, -20, \"<=\") {\n return(\"extreme_cold\")\n else()\n return(\"normal\")\n end()\n end()\n}\nfunction processWeatherData(data) {\n variableFromJSON(data, \"temperature\", temp)\n variableFromJSON(data, \"city\", city)\n validateTemperature(temp)\n tempStatus = validateTemperature(temp)\n AddVariableToJSON(\"status\", tempStatus, data)\n AddVariableToJSON(\"processed_at\", \"2024-01-15T10:30:00Z\", data)\n return(data)\n}\naddParam(\"city\", cityName)\naddParam(\"api_key\", apiKey)\nif(cityName, None, \"==\") {\n addVar(_status, 400)\n errorMsg = \"City parameter is required\"\n addResult(errorMsg)\n return()\nend()\nif(apiKey, None, \"==\") {\n addVar(_status, 401)\n errorMsg = \"API key is required\"\n addResult(errorMsg)\n return()\nend()\nweatherUrl = \"https://api.weather.com/v1/current\"\nqueryParams = \"city=\" + cityName + \"&key=\" + apiKey\nheaders = {\"User-Agent\": \"AVAP-Weather-Client/1.0\", \"Accept\": \"application/json\"}\nRequestGet(weatherUrl, queryParams, headers, weatherResponse, 5000)\nif(weatherResponse, None, \"==\") {\n addVar(_status, 503)\n errorMsg = \"Weather service unavailable\"\n addResult(errorMsg)\n return()\nend()\nvariableFromJSON(weatherResponse, \"error\", apiError)\nif(apiError, None, \"!=\") {\n addVar(_status, 502)\n addResult(apiError)\n return()\nend()\nprocessedData = processWeatherData(weatherResponse)\naddVar(_status, 200)\naddResult(processedData)",
|
||||
"test_inputs": {
|
||||
"city": "Madrid",
|
||||
"api_key": "test123"
|
||||
},
|
||||
"test_list": [
|
||||
"re.match(r'extreme_hot|extreme_cold|normal', tempStatus)",
|
||||
"re.match(r'Madrid|Barcelona|Valencia', cityName)",
|
||||
"re.match(r'\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z', processedData)"
|
||||
],
|
||||
"_cell": [
|
||||
"RequestGet",
|
||||
"import"
|
||||
],
|
||||
"_prior_weight": 0.3737,
|
||||
"_quality": {
|
||||
"fidelity": 1.0,
|
||||
"bonus_ratio": 0.306,
|
||||
"test_quality": 1.0,
|
||||
"richness": 1.0,
|
||||
"quality": 1.392,
|
||||
"detected": [
|
||||
"AddVariableToJSON",
|
||||
"RequestGet",
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"else",
|
||||
"end",
|
||||
"function",
|
||||
"if_mode1",
|
||||
"import",
|
||||
"return",
|
||||
"variableFromJSON"
|
||||
],
|
||||
"cell": [
|
||||
"RequestGet",
|
||||
"import"
|
||||
],
|
||||
"extra": [
|
||||
"AddVariableToJSON",
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"else",
|
||||
"end",
|
||||
"function",
|
||||
"if_mode1",
|
||||
"return",
|
||||
"variableFromJSON"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"task_id": 8,
|
||||
"text": "Desarrolla una función de autenticación externa que valide un token OAuth con un proveedor de identidad, consulte la base de datos de usuarios y registre la actividad de acceso. La función debe hacer una petición POST para validar el token, consultar la tabla 'usuarios' para verificar permisos, y devolver el código HTTP apropiado según el resultado de la validación.",
|
||||
"code": "addParam(\"token\", auth_token)\naddParam(\"client_id\", client_id)\nif(auth_token, None, \"==\")\n addVar(_status, 400)\n addResult(_status)\n return()\nend()\noauth_url = \"https://auth.provider.com/validate\"\nheaders = {\"Content-Type\": \"application/json\"}\nbody = {\"token\": auth_token, \"client_id\": client_id}\nRequestPost(oauth_url, \"\", headers, body, oauth_response, 5000)\nif(oauth_response, None, \"==\")\n addVar(_status, 503)\n error_msg = \"OAuth service unavailable\"\n addResult(error_msg)\n return()\nend()\nvariableFromJSON(oauth_response, \"valid\", is_valid)\nvariableFromJSON(oauth_response, \"user_id\", external_user_id)\nif(is_valid, \"false\", \"==\")\n addVar(_status, 401)\n error_msg = \"Invalid token\"\n addResult(error_msg)\n return()\nend()\ndb_connector = avapConnector(\"db-uuid-12345\")\nfields = \"user_id,email,status,permissions\"\nselector = \"external_id = '\" + external_user_id + \"'\"\normAccessSelect(fields, \"usuarios\", selector, user_data)\ngetListLen(user_data, user_count)\nif(user_count, 0, \"==\")\n addVar(_status, 404)\n error_msg = \"User not found\"\n addResult(error_msg)\n return()\nend()\nitemFromList(user_data, 0, user_record)\nvariableFromJSON(user_record, \"status\", user_status)\nvariableFromJSON(user_record, \"user_id\", internal_user_id)\nvariableFromJSON(user_record, \"email\", user_email)\nvariableFromJSON(user_record, \"permissions\", user_permissions)\nif(user_status, \"active\", \"!=\")\n addVar(_status, 403)\n error_msg = \"Account suspended\"\n addResult(error_msg)\n return()\nend()\ngetDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", access_timestamp)\naccess_log = {\"user_id\": internal_user_id, \"timestamp\": access_timestamp, \"action\": \"oauth_login\"}\nlog_fields = [\"user_id\", \"timestamp\", \"action\"]\nlog_values = [internal_user_id, access_timestamp, \"oauth_login\"]\normAccessInsert(log_values, \"access_logs\", log_result)\naddVar(_status, 200)\nresponse_data = {\"user_id\": internal_user_id, \"email\": user_email, \"permissions\": user_permissions}\naddResult(response_data)",
|
||||
"test_inputs": {
|
||||
"token": "valid_oauth_token_12345",
|
||||
"client_id": "app_client_001"
|
||||
},
|
||||
"test_list": [
|
||||
"re.match(r'\\d+', str(user_count))",
|
||||
"re.match(r'[a-zA-Z0-9_]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}', user_email)",
|
||||
"re.match(r'\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}', access_timestamp)"
|
||||
],
|
||||
"_cell": [
|
||||
"RequestPost",
|
||||
"_status",
|
||||
"ormAccessSelect"
|
||||
],
|
||||
"_prior_weight": 0.0909,
|
||||
"_quality": {
|
||||
"fidelity": 1.0,
|
||||
"bonus_ratio": 0.343,
|
||||
"test_quality": 1.0,
|
||||
"richness": 1.0,
|
||||
"quality": 1.403,
|
||||
"detected": [
|
||||
"RequestPost",
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"avapConnector",
|
||||
"end",
|
||||
"getDateTime",
|
||||
"getListLen",
|
||||
"if_mode1",
|
||||
"itemFromList",
|
||||
"ormAccessInsert",
|
||||
"ormAccessSelect",
|
||||
"return",
|
||||
"variableFromJSON"
|
||||
],
|
||||
"cell": [
|
||||
"RequestPost",
|
||||
"_status",
|
||||
"ormAccessSelect"
|
||||
],
|
||||
"extra": [
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"avapConnector",
|
||||
"end",
|
||||
"getDateTime",
|
||||
"getListLen",
|
||||
"if_mode1",
|
||||
"itemFromList",
|
||||
"ormAccessInsert",
|
||||
"return",
|
||||
"variableFromJSON"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"task_id": 9,
|
||||
"text": "Implementar un servicio que genere códigos de verificación aleatorios para una lista de usuarios, extraiga información específica de cada usuario usando índices de lista, y devuelva los resultados procesados con códigos únicos.",
|
||||
"code": "registerEndpoint(\"/api/generate-codes\", \"POST\", [], \"application/json\", mainHandler, None)\n\nfunction mainHandler()\n{\naddParam(\"user_data\", user_list)\naddParam(\"code_length\", length_param)\nif(user_list, None, \"==\")\n_status = 400\naddVar(error_msg, \"Lista de usuarios requerida\")\naddResult(error_msg)\nreturn()\nend()\nif(length_param, None, \"==\")\naddVar(length_param, 8)\nend()\nvariableToList(user_list, processed_users)\ngetListLen(processed_users, total_users)\naddVar(counter, 0)\naddVar(verification_codes, [])\nstartLoop(i, 0, total_users)\nitemFromList(processed_users, i, current_user)\nvariableFromJSON(current_user, \"email\", user_email)\nvariableFromJSON(current_user, \"user_id\", user_id)\nrandomString(\"[A-Z0-9]\", length_param, random_code)\nAddVariableToJSON(\"user_id\", user_id, code_entry)\nAddVariableToJSON(\"email\", user_email, code_entry)\nAddVariableToJSON(\"verification_code\", random_code, code_entry)\naddVar(verification_codes, verification_codes + [code_entry])\naddVar(counter, counter + 1)\nendLoop()\naddVar(response_data, {})\nAddVariableToJSON(\"generated_codes\", verification_codes, response_data)\nAddVariableToJSON(\"total_processed\", counter, response_data)\n_status = 200\naddResult(response_data)\nreturn()\n}",
|
||||
"test_inputs": {
|
||||
"user_data": "[{\"user_id\": 123, \"email\": \"test@example.com\"}, {\"user_id\": 456, \"email\": \"user@domain.org\"}]",
|
||||
"code_length": "6"
|
||||
},
|
||||
"test_list": [
|
||||
"re.match(r'^\\[{\"user_id\":', response_data)",
|
||||
"re.match(r'\"verification_code\":\"[A-Z0-9]{6}\"', response_data)",
|
||||
"re.match(r'\"total_processed\":2', response_data)"
|
||||
],
|
||||
"_cell": [
|
||||
"itemFromList",
|
||||
"randomString"
|
||||
],
|
||||
"_prior_weight": 0.1212,
|
||||
"_quality": {
|
||||
"fidelity": 1.0,
|
||||
"bonus_ratio": 0.361,
|
||||
"test_quality": 1.0,
|
||||
"richness": 1.0,
|
||||
"quality": 1.408,
|
||||
"detected": [
|
||||
"AddVariableToJSON",
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"end",
|
||||
"endLoop",
|
||||
"function",
|
||||
"getListLen",
|
||||
"if_mode1",
|
||||
"itemFromList",
|
||||
"randomString",
|
||||
"return",
|
||||
"startLoop",
|
||||
"variableFromJSON"
|
||||
],
|
||||
"cell": [
|
||||
"itemFromList",
|
||||
"randomString"
|
||||
],
|
||||
"extra": [
|
||||
"AddVariableToJSON",
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"end",
|
||||
"endLoop",
|
||||
"function",
|
||||
"getListLen",
|
||||
"if_mode1",
|
||||
"return",
|
||||
"startLoop",
|
||||
"variableFromJSON"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"task_id": 10,
|
||||
"text": "Crea un endpoint AVAP que reciba un parámetro 'table_name', valide que la tabla existe en la base de datos usando ORM, y devuelva información sobre la tabla. Si no recibe parámetro, debe usar 'users' por defecto. Implementa una función auxiliar para formatear la respuesta y maneja errores apropiadamente.",
|
||||
"code": "registerEndpoint(\"/api/validate-table\", \"GET\", [], \"default\", validateTableHandler, mainHandler)\nfunction validateTableHandler()\n{\n addParam(\"table_name\", received_table)\n if(received_table, None, \"==\")\n addVar(target_table, \"users\")\n else()\n addVar(target_table, $received_table)\n end()\n db_connector = avapConnector(\"db-uuid-12345\")\n ormCheckTable($target_table, table_exists)\n if(table_exists, True, \"==\")\n result = formatTableResponse($target_table, \"exists\")\n addVar(_status, 200)\n else()\n result = formatTableResponse($target_table, \"not_found\")\n addVar(_status, 404)\n end()\n addResult(result)\n return()\n}\nfunction formatTableResponse(table_name, status)\n{\n addVar(response_data, \"{}\")\n AddVariableToJSON(\"table\", $table_name, response_data)\n AddVariableToJSON(\"status\", $status, response_data)\n getDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", current_time)\n AddVariableToJSON(\"timestamp\", $current_time, response_data)\n return($response_data)\n}",
|
||||
"test_inputs": {
|
||||
"table_name": "products"
|
||||
},
|
||||
"test_list": [
|
||||
"re.match(r'\\{.*\"table\".*\"products\".*\\}', result)",
|
||||
"re.match(r'\\{.*\"status\".*\"exists\".*\\}', result)",
|
||||
"re.match(r'\\{.*\"timestamp\".*\"\\d{4}-\\d{2}-\\d{2}.*\\}', result)"
|
||||
],
|
||||
"_cell": [
|
||||
"addParam",
|
||||
"function",
|
||||
"ormCheckTable"
|
||||
],
|
||||
"_prior_weight": 0.5758,
|
||||
"_quality": {
|
||||
"fidelity": 1.0,
|
||||
"bonus_ratio": 0.286,
|
||||
"test_quality": 1.0,
|
||||
"richness": 1.0,
|
||||
"quality": 1.386,
|
||||
"detected": [
|
||||
"AddVariableToJSON",
|
||||
"_status",
|
||||
"addParam",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"avapConnector",
|
||||
"else",
|
||||
"end",
|
||||
"function",
|
||||
"getDateTime",
|
||||
"if_mode1",
|
||||
"ormCheckTable",
|
||||
"return"
|
||||
],
|
||||
"cell": [
|
||||
"addParam",
|
||||
"function",
|
||||
"ormCheckTable"
|
||||
],
|
||||
"extra": [
|
||||
"AddVariableToJSON",
|
||||
"_status",
|
||||
"addResult",
|
||||
"addVar",
|
||||
"avapConnector",
|
||||
"else",
|
||||
"end",
|
||||
"getDateTime",
|
||||
"if_mode1",
|
||||
"return"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
|
|
@ -0,0 +1,30 @@
|
|||
{
|
||||
"total_cells": 9139,
|
||||
"filled_cells": 10,
|
||||
"fill_rate": 0.0011,
|
||||
"distribution_entropy": 4.06,
|
||||
"node_type_frequency": {
|
||||
"startLoop": 2,
|
||||
"randomString": 2,
|
||||
"import": 2,
|
||||
"_status": 2,
|
||||
"RequestGet": 2,
|
||||
"itemFromList": 2,
|
||||
"addVar": 1,
|
||||
"ormAccessUpdate": 1,
|
||||
"ormAccessSelect": 3,
|
||||
"variableFromJSON": 1,
|
||||
"addParam": 2,
|
||||
"else": 1,
|
||||
"ormAccessInsert": 1,
|
||||
"try": 1,
|
||||
"if_mode1": 1,
|
||||
"RequestPost": 1,
|
||||
"ormCheckTable": 1,
|
||||
"function": 1
|
||||
},
|
||||
"low_quality_cells": 0,
|
||||
"empty_cells": 9129,
|
||||
"kl_divergence_dataset_vs_prior": -0.724,
|
||||
"prior_summary": "ConstructPrior: 4262 cells | mean=0.252 | epsilon=0.05 | github_files_analyzed=100 github_files_fetched=100 total_pair_cooccurrences=441 total_trio_cooccurrences=3821"
|
||||
}
|
||||
|
|
@ -0,0 +1,187 @@
|
|||
[
|
||||
{
|
||||
"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)"
|
||||
]
|
||||
}
|
||||
]
|
||||
Loading…
Reference in New Issue