[BUG] Description

Description

A generated native API client does not handle a 204 response properly, if it also has a return type for 200 responses.

In case a 204 response is returned, the API tries to map the body to the return type but it fails.

The following snippet is of the api.mustache template:

            if (localVarResponse.statusCode()/ 100 != 2) {
              return CompletableFuture.failedFuture(getApiException("{{operationId}}", localVarResponse));
            }
            {{#returnType}}
            try {
              String responseBody = localVarResponse.body();
              return CompletableFuture.completedFuture(
                  new ApiResponse<{{{returnType}}}>(
                      localVarResponse.statusCode(),
                      localVarResponse.headers().map(),
                      responseBody == null || responseBody.isBlank() ? null : memberVarObjectMapper.readValue(responseBody, new TypeReference<{{{returnType}}}>() {}))
              );
            } catch (IOException e) {
              return CompletableFuture.failedFuture(new ApiException(e));
            }
            {{/returnType}}

For every 2xx response, the api tries to map the response to the return type which fails with a Jackson Exception cause of the empty body.

openapi-generator version

Version 7.9.0 but it seems to exist also in the latest version (7.12.0).

Steps to reproduce

Define an specification with a response with code 200 and a response body and a response with code 204. If a response with code 204 is returned during runtime, an ApiException with the Jackson exception as cause is thrown, it does not contain any status code or headers.

Suggest a fix

I see two ways to fix this issue:

• Do not attempt to map the body in case of a 204 and return an ApiResponse with null as body
• Throw also an ApiException but with correct status code and headers

I would go for the first solution as this is consistent with the behaviour in case ApiResponse is the return type and a 204 is returned.

Start with the api.mustache template and reproduce the issue using an OpenAPI specification containing 200 and 204 responses, then inspect the generated native Java client. Done means a 204 response no longer attempts to deserialize an empty body and returns an ApiResponse with the expected null body, status code, and headers.