simplify base64 case in OpenAPIGeneratorReferenceTests

Author: rnro

Tests/OpenAPIGeneratorReferenceTests/Resources/Docs/petstore.yaml

@@ -225,40 +225,6 @@ paths:
             text/plain:
               schema:
                 type: string
-  /pets/{petId}/audio:
-    parameters:
-      - $ref: '#/components/parameters/path.petId'
-    put:
-      summary: Upload an audio recording
-      operationId: uploadAudioForPet
-      requestBody:
-        required: true
-        description: Base64-encoded audio
-        content:
-          application/json:
-            schema:
-              type: string
-              format: byte
-      responses:
-        '200':
-          description: Echoes audio back
-          content:
-            application/json:
-              schema:
-                type: string
-                format: byte
-        '412':
-          description: Audio is not acceptable
-          content:
-            application/json:
-              schema:
-                type: string
-        '500':
-          description: Server error
-          content:
-            text/plain:
-              schema:
-                type: string
 components:
   headers:
     TracingHeader:
@@ -299,6 +265,10 @@ components:
           type: string
         tag:
           type: string
+        genome:
+          description: "Pet genome (base64-encoded)"
+          type: string
+          format: byte
         kind:
           $ref: '#/components/schemas/PetKind'
     MixedAnyOf:

Tests/OpenAPIGeneratorReferenceTests/Resources/ReferenceSources/Petstore/Client.swift

@@ -484,82 +484,4 @@ public struct Client: APIProtocol {
             }
         )
     }
-    /// Upload an audio recording
-    ///
-    /// - Remark: HTTP `PUT /pets/{petId}/audio`.
-    /// - Remark: Generated from `#/paths//pets/{petId}/audio/put(uploadAudioForPet)`.
-    public func uploadAudioForPet(_ input: Operations.uploadAudioForPet.Input) async throws
-        -> Operations.uploadAudioForPet.Output
-    {
-        try await client.send(
-            input: input,
-            forOperation: Operations.uploadAudioForPet.id,
-            serializer: { input in
-                let path = try converter.renderedPath(template: "/pets/{}/audio", parameters: [input.path.petId])
-                var request: HTTPTypes.HTTPRequest = .init(soar_path: path, method: .put)
-                suppressMutabilityWarning(&request)
-                converter.setAcceptHeader(in: &request.headerFields, contentTypes: input.headers.accept)
-                let body: OpenAPIRuntime.HTTPBody?
-                switch input.body {
-                case let .json(value):
-                    body = try converter.setRequiredRequestBodyAsJSON(
-                        value,
-                        headerFields: &request.headerFields,
-                        contentType: "application/json; charset=utf-8"
-                    )
-                }
-                return (request, body)
-            },
-            deserializer: { response, responseBody in
-                switch response.status.code {
-                case 200:
-                    let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
-                    let body: Operations.uploadAudioForPet.Output.Ok.Body
-                    if try contentType == nil
-                        || converter.isMatchingContentType(received: contentType, expectedRaw: "application/json")
-                    {
-                        body = try await converter.getResponseBodyAsJSON(
-                            OpenAPIRuntime.Base64EncodedData.self,
-                            from: responseBody,
-                            transforming: { value in .json(value) }
-                        )
-                    } else {
-                        throw converter.makeUnexpectedContentTypeError(contentType: contentType)
-                    }
-                    return .ok(.init(body: body))
-                case 412:
-                    let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
-                    let body: Operations.uploadAudioForPet.Output.PreconditionFailed.Body
-                    if try contentType == nil
-                        || converter.isMatchingContentType(received: contentType, expectedRaw: "application/json")
-                    {
-                        body = try await converter.getResponseBodyAsJSON(
-                            Swift.String.self,
-                            from: responseBody,
-                            transforming: { value in .json(value) }
-                        )
-                    } else {
-                        throw converter.makeUnexpectedContentTypeError(contentType: contentType)
-                    }
-                    return .preconditionFailed(.init(body: body))
-                case 500:
-                    let contentType = converter.extractContentTypeIfPresent(in: response.headerFields)
-                    let body: Operations.uploadAudioForPet.Output.InternalServerError.Body
-                    if try contentType == nil
-                        || converter.isMatchingContentType(received: contentType, expectedRaw: "text/plain")
-                    {
-                        body = try converter.getResponseBodyAsBinary(
-                            OpenAPIRuntime.HTTPBody.self,
-                            from: responseBody,
-                            transforming: { value in .plainText(value) }
-                        )
-                    } else {
-                        throw converter.makeUnexpectedContentTypeError(contentType: contentType)
-                    }
-                    return .internalServerError(.init(body: body))
-                default: return .undocumented(statusCode: response.status.code, .init())
-                }
-            }
-        )
-    }
 }

Tests/OpenAPIGeneratorReferenceTests/Resources/ReferenceSources/Petstore/Server.swift

@@ -70,11 +70,6 @@ extension APIProtocol {
             method: .put,
             path: server.apiPathComponentsWithServerPrefix("/pets/{petId}/avatar")
         )
-        try transport.register(
-            { try await server.uploadAudioForPet(request: $0, body: $1, metadata: $2) },
-            method: .put,
-            path: server.apiPathComponentsWithServerPrefix("/pets/{petId}/audio")
-        )
     }
 }
 fileprivate extension UniversalServer where APIHandler: APIProtocol {
@@ -597,95 +592,4 @@ fileprivate extension UniversalServer where APIHandler: APIProtocol {
             }
         )
     }
-    /// Upload an audio recording
-    ///
-    /// - Remark: HTTP `PUT /pets/{petId}/audio`.
-    /// - Remark: Generated from `#/paths//pets/{petId}/audio/put(uploadAudioForPet)`.
-    func uploadAudioForPet(request: HTTPRequest, body: HTTPBody?, metadata: ServerRequestMetadata) async throws -> (
-        HTTPResponse, HTTPBody?
-    ) {
-        try await handle(
-            request: request,
-            requestBody: body,
-            metadata: metadata,
-            forOperation: Operations.uploadAudioForPet.id,
-            using: { APIHandler.uploadAudioForPet($0) },
-            deserializer: { request, requestBody, metadata in
-                let path: Operations.uploadAudioForPet.Input.Path = .init(
-                    petId: try converter.getPathParameterAsURI(
-                        in: metadata.pathParameters,
-                        name: "petId",
-                        as: Components.Parameters.path_period_petId.self
-                    )
-                )
-                let headers: Operations.uploadAudioForPet.Input.Headers = .init(
-                    accept: try converter.extractAcceptHeaderIfPresent(in: request.headerFields)
-                )
-                let contentType = converter.extractContentTypeIfPresent(in: request.headerFields)
-                let body: Operations.uploadAudioForPet.Input.Body
-                if try contentType == nil
-                    || converter.isMatchingContentType(received: contentType, expectedRaw: "application/json")
-                {
-                    body = try await converter.getRequiredRequestBodyAsJSON(
-                        OpenAPIRuntime.Base64EncodedData.self,
-                        from: requestBody,
-                        transforming: { value in .json(value) }
-                    )
-                } else {
-                    throw converter.makeUnexpectedContentTypeError(contentType: contentType)
-                }
-                return Operations.uploadAudioForPet.Input(path: path, headers: headers, body: body)
-            },
-            serializer: { output, request in
-                switch output {
-                case let .ok(value):
-                    suppressUnusedWarning(value)
-                    var response = HTTPResponse(soar_statusCode: 200)
-                    suppressMutabilityWarning(&response)
-                    let body: HTTPBody
-                    switch value.body {
-                    case let .json(value):
-                        try converter.validateAcceptIfPresent("application/json", in: request.headerFields)
-                        body = try converter.setResponseBodyAsJSON(
-                            value,
-                            headerFields: &response.headerFields,
-                            contentType: "application/json; charset=utf-8"
-                        )
-                    }
-                    return (response, body)
-                case let .preconditionFailed(value):
-                    suppressUnusedWarning(value)
-                    var response = HTTPResponse(soar_statusCode: 412)
-                    suppressMutabilityWarning(&response)
-                    let body: HTTPBody
-                    switch value.body {
-                    case let .json(value):
-                        try converter.validateAcceptIfPresent("application/json", in: request.headerFields)
-                        body = try converter.setResponseBodyAsJSON(
-                            value,
-                            headerFields: &response.headerFields,
-                            contentType: "application/json; charset=utf-8"
-                        )
-                    }
-                    return (response, body)
-                case let .internalServerError(value):
-                    suppressUnusedWarning(value)
-                    var response = HTTPResponse(soar_statusCode: 500)
-                    suppressMutabilityWarning(&response)
-                    let body: HTTPBody
-                    switch value.body {
-                    case let .plainText(value):
-                        try converter.validateAcceptIfPresent("text/plain", in: request.headerFields)
-                        body = try converter.setResponseBodyAsBinary(
-                            value,
-                            headerFields: &response.headerFields,
-                            contentType: "text/plain"
-                        )
-                    }
-                    return (response, body)
-                case let .undocumented(statusCode, _): return (.init(soar_statusCode: statusCode), nil)
-                }
-            }
-        )
-    }
 }