601 lines
28 KiB
JSON
601 lines
28 KiB
JSON
[
|
|
{
|
|
"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"
|
|
]
|
|
}
|
|
}
|
|
] |