Test openapi operations schema before calling an endpoint

test_openapi.py

from dataclasses import dataclass
from typing import Any, Dict, List, Literal, Union


@dataclass
class OpenAPIOperation:
    path: str
    action: Union[
        Literal["get"],
        Literal["post"],
        Literal["put"],
        Literal["delete"],
        Literal["patch"],
    ]
    parameters: List[str]


def check_api_for_ops(
    openapi_json: Dict[str, Any], operations: List[OpenAPIOperation]
) -> bool:
    for path, action, parameters in operations:
        if path in openapi_json["paths"] and action in openapi_json["paths"][path]:
            if "parameters" not in openapi_json["paths"][path][action]:
                return False
            path_parameters = [
                param["name"]
                for param in openapi_json["paths"][path][action]["parameters"]
                if "name" in param
            ]
            for parameter in parameters:
                if parameter not in path_parameters:
                    return False
        else:
            return False
    return True

testOpenApi.ts

import { compact, every, includes, isEmpty, map, some } from 'lodash';

interface OpenAPIOperation {
  path: string;
  action: 'get' | 'post' | 'put' | 'delete';
  parameters: string[];
}

function checkOpenApiForOps(
  openApiJson: any,
  operations: OpenAPIOperation[],
): boolean {
  return every(operations, ({ path, action, parameters }) => {
    if (
      includes(openApiJson.paths, path) &&
      openApiJson.paths?.[path]?.[action]
    ) {
      if (!isEmpty(openApiJson.paths[path][action].parameters)) {
        return false;
      }
      const pathParameters = compact(
        map(openApiJson.paths[path][action].parameters, 'name'),
      );
      if (
        some(parameters, (parameter) => !includes(pathParameters, parameter))
      ) {
        return false;
      }
    } else {
      return false;
    }
    return true;
  });
}