Handle empty schema in requestBody.

Update logging around the generate/update script execution

Author: yugokato

src/openapi_test_client/libraries/api/api_client_generator.py

@@ -168,10 +168,10 @@ def generate_api_class(
         base_class = _get_base_api_class(api_client)
     api_dir = app_client_dir / API_CLASS_DIR_NAME
     api_class_file_path = api_dir / f"{class_file_name.lower()}.py"
-    logger.warning(
+    logger.info(
         f"Generating a new API class file:\n"
         f"- API class name: {class_name} (tag={tag})\n"
-        f"- file path: {api_class_file_path}"
+        f"- file path: {api_class_file_path}",
     )
     if api_class_file_path.exists():
         raise RuntimeError(f"{api_class_file_path} exists")
@@ -301,13 +301,13 @@ def update_endpoint_functions(
         original_model_code = format_code(model_file_path.read_text(), remove_unused_imports=False)
     else:
         original_model_code = ""
-    method = path = func_name = None
+    method = path = func_name = ""
     defined_endpoints = []
     param_models = []
 
     def update_existing_endpoints(target_api_class: type[APIBase] = api_class) -> None:
         """Updated existing endpoint functions"""
-        nonlocal modified_api_cls_code
+        nonlocal modified_api_cls_code, method, path, func_name
         new_code = current_code = modified_api_cls_code
         api_spec_tags = set()
 
@@ -351,7 +351,7 @@ def update_existing_endpoints(target_api_class: type[APIBase] = api_class) -> No
                 if endpoint_function.endpoint.is_documented:
                     err = f"{TAB}Not found: {method.upper()} {path} ({func_name})"
                     print(color(err, color_code=ColorCodes.RED))  # noqa: T201
-                else:
+                elif verbose:
                     msg = f"{TAB}Skipped undocumented endpoint: {method.upper()} {path} ({func_name})"
                     print(msg)  # noqa: T201
                 continue
@@ -522,12 +522,13 @@ def update_missing_endpoints() -> None:
             original_api_cls_code = original_model_code = ""
         if not update_param_models_only:
             if api_cls_updated := (original_api_cls_code != modified_api_cls_code):
-                if not is_new_api_class:
-                    msg = f"{TAB}Update{' required' if dry_run else 'd'}: {api_cls_file_path}"
-                    print(color(msg, color_code=ColorCodes.YELLOW))  # noqa:T201
-
                 if show_diff:
                     # Print diff
+                    if is_new_api_class:
+                        logger.info(f"Generated API class code: {api_cls_file_path}")
+                    else:
+                        msg = f"{TAB}Update{' required' if dry_run else 'd'}: {api_cls_file_path}"
+                        print(color(msg, color_code=ColorCodes.YELLOW))  # noqa:T201
                     diff_code(
                         original_api_cls_code,
                         modified_api_cls_code,
@@ -540,6 +541,8 @@ def update_missing_endpoints() -> None:
                     api_cls_file_path.write_text(modified_api_cls_code)
 
         if param_models:
+            if verbose:
+                logger.info(f"Checking param models for {api_class.__name__}...")
             modified_model_code = (
                 f"from dataclasses import dataclass\n\nfrom {ParamModel.__module__} import {ParamModel.__name__}\n\n"
             )
@@ -551,9 +554,12 @@ def update_missing_endpoints() -> None:
 
             if model_updated := (original_model_code != modified_model_code):
                 # Print diff
-                msg = f"{TAB}Update{' required' if dry_run else 'd'} (models): {model_file_path}"
-                print(color(msg, color_code=ColorCodes.YELLOW))  # noqa:T201
                 if show_diff:
+                    if is_new_api_class:
+                        logger.info(f"Generated param models: {model_file_path}")
+                    else:
+                        msg = f"{TAB}Update{' required' if dry_run else 'd'} (models): {model_file_path}"
+                        print(color(msg, color_code=ColorCodes.YELLOW))  # noqa:T201
                     diff_code(
                         original_model_code,
                         modified_model_code,
@@ -565,12 +571,14 @@ def update_missing_endpoints() -> None:
                     model_file_path.parent.mkdir(parents=True, exist_ok=True)
                     model_file_path.write_text(modified_model_code)
     except Exception as e:
-        # This should not happen
+        # An error during code generation
         tb = traceback.format_exc()
-        err = f"Failed to update {api_cls_file_path}:"
-        if all([func_name, method, path]):
-            err += f" {func_name} ({method} {path})"
-        err += f"\n{tb})\n"
+        err = f"Failed to update code:\n - File {api_cls_file_path}"
+        if func_name:
+            err += f"\n - Function: {func_name}"
+        if method and path:
+            err += f"\n - Endpoint: {method.upper()} {path}"
+        err += f"\n - Error details:\n{tb}\n"
         print(color(err, color_code=ColorCodes.RED))  # noqa :T201
         if api_cls_updated and not dry_run:
             # revert back to original code
@@ -590,7 +598,7 @@ def generate_api_client(temp_api_client: OpenAPIClient, show_generated_code: boo
     :param temp_api_client: Temporary API client
     :param show_generated_code: Show generated client code
     """
-    logger.warning(f"Generating a new API client for {temp_api_client.app_name}")
+    logger.info(f"Generating a new API client for {temp_api_client.app_name}")
     assert _is_temp_client(temp_api_client)
     app_name = temp_api_client.app_name
     base_api_class = generate_base_api_class(temp_api_client)

src/openapi_test_client/libraries/api/api_functions/utils/endpoint_model.py

@@ -40,7 +40,21 @@ def create_endpoint_model(endpoint_func: EndpointFunc, api_spec: dict[str, Any]
         if parameter_objects := operation_obj.get("parameters"):
             _parse_parameter_objects(method, parameter_objects, path_param_fields, body_or_query_param_fields)
         if request_body := operation_obj.get("requestBody"):
-            content_type = _parse_request_body_object(request_body, body_or_query_param_fields)
+            try:
+                content_type = _parse_request_body_object(request_body, body_or_query_param_fields)
+            except Exception:
+                logger.warning(f"Unable to parse the following requestBody obj:\n{request_body}")
+                raise
+
+        expected_path_params = re.findall(r"{([^}]+)}", path)
+        documented_path_params = [x[0] for x in path_param_fields]
+        if undocumented_path_params := [x for x in expected_path_params if x not in documented_path_params]:
+            logger.warning(f"{method.upper()} {path}: Found undocumented path parameters: {undocumented_path_params}")
+            # Some OpenAPI specs don't properly document path parameters at all, or path parameters could be documented
+            # as incorrect "in" like "query". We fix this by adding the missing path parameters, and remove them from
+            # body/query params if any
+            path_param_fields = [DataclassModelField(x, str) for x in expected_path_params]
+            body_or_query_param_fields = [x for x in body_or_query_param_fields if x[0] not in expected_path_params]
     else:
         # Generate model fields from the function signature
         sig = inspect.signature(endpoint_func._original_func)
@@ -54,19 +68,6 @@ def create_endpoint_model(endpoint_func: EndpointFunc, api_spec: dict[str, Any]
                 # keyword arguments (body/query parameters)
                 _add_body_or_query_param_field(body_or_query_param_fields, name, param_obj.annotation)
 
-    if hasattr(endpoint_func, "endpoint"):
-        method = endpoint_func.endpoint.method
-        path = endpoint_func.endpoint.path
-        expected_path_params = re.findall(r"{([^}]+)}", path)
-        documented_path_params = [x[0] for x in path_param_fields]
-        if undocumented_path_params := [x for x in expected_path_params if x not in documented_path_params]:
-            logger.warning(f"{method.upper()} {path}: Found undocumented path parameters: {undocumented_path_params}")
-            # Some OpenAPI specs don't properly document path parameters at all, or path parameters could be documented
-            # as incorrect "in" like "query". We fix this by adding the missing path parameters, and remove them from
-            # body/query params if any
-            path_param_fields = [DataclassModelField(x, str) for x in expected_path_params]
-            body_or_query_param_fields = [x for x in body_or_query_param_fields if x[0] not in expected_path_params]
-
     # Address the case where a path param name conflicts with body/query param name
     for i, (field_name, field_type, _) in enumerate(path_param_fields):
         if field_name in [x[0] for x in body_or_query_param_fields]:
@@ -75,8 +76,9 @@ def create_endpoint_model(endpoint_func: EndpointFunc, api_spec: dict[str, Any]
     # Some OpenAPI specs define a parameter name using characters we can't use as a python variable name.
     # We will use the cleaned name as the model field and annotate it as `Annotated[field_type, Alias(<original_val>)]`
     # When calling an endpoint function, the actual name will be automatically resolved in the payload/query parameters
-    param_model_util.alias_illegal_model_field_names(model_name, path_param_fields)
-    param_model_util.alias_illegal_model_field_names(model_name, body_or_query_param_fields)
+    endpoint = f"{endpoint_func.method.upper()} {endpoint_func.path}"
+    param_model_util.alias_illegal_model_field_names(endpoint, path_param_fields)
+    param_model_util.alias_illegal_model_field_names(endpoint, body_or_query_param_fields)
 
     fields = path_param_fields + body_or_query_param_fields
     return cast(
@@ -211,7 +213,7 @@ def _parse_request_body_object(
     # TODO: Support multiple content types
     content_type = next(iter(contents))
 
-    def parse_schema_obj(obj: dict[str, Any]) -> list[dict[str, Any]] | None:
+    def parse_schema_obj(obj: dict[str, Any]) -> list[dict[str, Any] | list[dict[str, Any]]] | None:
         # This part has some variations, and sometimes not consistent
         if not (properties := obj.get("properties", {})):
             schema_type = obj.get("type")
@@ -235,8 +237,12 @@ def parse_schema_obj(obj: dict[str, Any]) -> list[dict[str, Any]] | None:
             ):
                 # The API directly takes data that is not form-encoded (eg. send tar binary data)
                 properties = {"data": schema_obj}
+            elif obj == {}:
+                # Empty schema
+                properties = {}
             else:
-                raise NotImplementedError(f"Unsupported request body:\n{json.dumps(obj, indent=4, default=str)}")
+                # An example from actual OpenAPI spec: {"content": {"application/json": {"schema": {"type": 'string"}}
+                raise NotImplementedError(f"Unsupported schema obj:\n{json.dumps(obj, indent=4, default=str)}")
 
         for param_name in properties:
             param_obj = properties[param_name]

src/openapi_test_client/libraries/api/api_functions/utils/param_model.py

@@ -313,10 +313,10 @@ def visit(model_name: str) -> None:
     return sorted(models, key=lambda x: sorted_models_names.index(x.__name__))
 
 
-def alias_illegal_model_field_names(model_name: str, model_fields: list[DataclassModelField]) -> None:
+def alias_illegal_model_field_names(location: str, model_fields: list[DataclassModelField]) -> None:
     """Clean illegal model field name and annotate the field type with Alias class
 
-    :param model_name: Model name
+    :param location: Location where the field is seen. This is used for logging purpose
     :param model_fields: fields value to be passed to make_dataclass()
     """
 
@@ -362,7 +362,9 @@ def make_alias(name: str, param_type: Any) -> str:
         for i, model_field in enumerate(model_fields):
             if (alias_name := make_alias(model_field.name, model_field.type)) != model_field.name:
                 if isinstance(model_field.default, Field) and model_field.default.metadata:
-                    logger.warning(f"Converted parameter name '{model_field.name}' to '{alias_name}'")
+                    logger.warning(
+                        f"[{location}]: The parameter name '{model_field.name}' was aliased to '{alias_name}'"
+                    )
                 new_fields = (
                     alias_name,
                     param_type_util.annotate_type(model_field.type, Alias(model_field.name)),

src/openapi_test_client/libraries/api/api_functions/utils/param_type.py

@@ -164,8 +164,9 @@ def resolve(param_type: str, param_format: str | None = None) -> Any:
             type_annotation = Literal[*enum]
         elif isinstance(param_def, ParamDef.UnknownType):
             logger.warning(
-                f"Unable to locate a parameter type for parameter '{param_name}'. Type '{Any}' will be applied.\n"
-                f"Unknown parameter object: {param_def.param_obj}"
+                f"Param '{param_name}': Unable to locate a parameter type in the following parameter object. "
+                f"Type '{Any}' will be applied:\n"
+                f"{param_def.param_obj}"
             )
             type_annotation = Any
         else:

src/openapi_test_client/libraries/common/code.py

@@ -39,6 +39,7 @@ def diff_code(code1: str, code2: str, fromfile: str = "before", tofile: str = "a
         else:
             color_code = ColorCodes.DEFAULT
         print(TAB + color(line.rstrip(), color_code=color_code))  # noqa: T201
+    print()  # noqa: T201
 
 
 def run_ruff(code: str, remove_unused_imports: bool = True) -> str:

src/openapi_test_client/scripts/generate_client.py

@@ -438,12 +438,12 @@ def _log_errors(action: str, failed_results: list[tuple[str, Exception]]) -> Non
             tb = tb.tb_next
         error_details.append(
             f"API class: {api_class_name}\n"
-            f"Error: {type(e).__name__}: {e}\n"
-            f"File: {tb.tb_frame.f_code.co_filename} (lineno={tb.tb_lineno})"
+            f"File: {tb.tb_frame.f_code.co_filename} (lineno={tb.tb_lineno})\n"
+            f"Error: {type(e).__name__}: {e}"
         )
     err = f"Failed to {action} code for the following API class(es). Please fix the issue and rerun the script."
     logger.error(err + "\n" + list_items(error_details))
-    if os.environ["PYTEST_CURRENT_TEST"]:
+    if os.environ.get("PYTEST_CURRENT_TEST"):
         raise Exception(f"{err}\n{list_items(error_details)}")
 
 

tests/integration/conftest.py

@@ -128,7 +128,7 @@ def external_dir(request: SubRequest, random_app_name: str) -> Generator[Path |
 
 @pytest.fixture
 def temp_app_client(
-    temp_dir: Path, mocker: MockerFixture, demo_app_openapi_spec_url: str, should_steram_cmd_output: bool
+    temp_dir: Path, mocker: MockerFixture, demo_app_openapi_spec_url: str
 ) -> Generator[OpenAPIClient, Any, None]:
     """Temporary demo app API client that will be generated for a test"""
     app_name = f"demo_app_{random.choice(range(1, 1000))}"