Skip to content

Commit b83b992

Browse files
author
Gayathri Sairamkrishnan
committed
CI checks
1 parent cae1190 commit b83b992

File tree

2 files changed

+70
-68
lines changed

2 files changed

+70
-68
lines changed

‎Sources/OpenAPIRuntime/Interface/ErrorHandlingMiddleware.swift

Lines changed: 13 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -45,17 +45,20 @@ import HTTPTypes
4545
/// It should be determined based on the specific needs of each application.
4646
/// Consider the order of execution and dependencies between middlewares.
4747
public struct ErrorHandlingMiddleware: ServerMiddleware {
48-
public func intercept(_ request: HTTPTypes.HTTPRequest,
49-
body: OpenAPIRuntime.HTTPBody?,
50-
metadata: OpenAPIRuntime.ServerRequestMetadata,
51-
operationID: String,
52-
next: @Sendable (HTTPTypes.HTTPRequest, OpenAPIRuntime.HTTPBody?, OpenAPIRuntime.ServerRequestMetadata) async throws -> (HTTPTypes.HTTPResponse, OpenAPIRuntime.HTTPBody?)) async throws -> (HTTPTypes.HTTPResponse, OpenAPIRuntime.HTTPBody?) {
53-
do {
54-
return try await next(request, body, metadata)
55-
} catch let error as ServerError {
48+
public func intercept(
49+
_ request: HTTPTypes.HTTPRequest,
50+
body: OpenAPIRuntime.HTTPBody?,
51+
metadata: OpenAPIRuntime.ServerRequestMetadata,
52+
operationID: String,
53+
next: @Sendable (HTTPTypes.HTTPRequest, OpenAPIRuntime.HTTPBody?, OpenAPIRuntime.ServerRequestMetadata)
54+
async throws -> (HTTPTypes.HTTPResponse, OpenAPIRuntime.HTTPBody?)
55+
) async throws -> (HTTPTypes.HTTPResponse, OpenAPIRuntime.HTTPBody?) {
56+
do { return try await next(request, body, metadata) } catch let error as ServerError {
5657
if let appError = error.underlyingError as? (any HTTPResponseConvertible) {
57-
return (HTTPResponse(status: appError.httpStatus, headerFields: appError.httpHeaderFields),
58-
appError.httpBody)
58+
return (
59+
HTTPResponse(status: appError.httpStatus, headerFields: appError.httpHeaderFields),
60+
appError.httpBody
61+
)
5962
} else {
6063
return (HTTPResponse(status: .internalServerError), nil)
6164
}
@@ -69,11 +72,9 @@ public protocol HTTPResponseConvertible {
6972

7073
/// HTTP status to return in the response.
7174
var httpStatus: HTTPResponse.Status { get }
72-
7375
/// Headers to return in the response.
7476
/// This is optional as default values are provided in the extension.
7577
var httpHeaderFields: HTTPTypes.HTTPFields { get }
76-
7778
/// (Optional) The body of the response to return
7879
var httpBody: OpenAPIRuntime.HTTPBody? { get }
7980
}

‎Tests/OpenAPIRuntimeTests/Interface/Test_ErrorHandlingMiddleware.swift

Lines changed: 57 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -17,67 +17,73 @@ import HTTPTypes
1717
import XCTest
1818
@_spi(Generated) @testable import OpenAPIRuntime
1919

20-
2120
final class Test_ErrorHandlingMiddlewareTests: XCTestCase {
2221
static let mockRequest: HTTPRequest = .init(soar_path: "http://abc.com", method: .get)
2322
static let mockBody: HTTPBody = HTTPBody("hello")
2423
static let errorHandlingMiddleware = ErrorHandlingMiddleware()
2524

2625
func testSuccessfulRequest() async throws {
27-
let response = try await Test_ErrorHandlingMiddlewareTests.errorHandlingMiddleware.intercept(Test_ErrorHandlingMiddlewareTests.mockRequest,
28-
body: Test_ErrorHandlingMiddlewareTests.mockBody,
29-
metadata: .init(), operationID: "testop",
30-
next: getNextMiddleware(failurePhase: .never))
26+
let response = try await Test_ErrorHandlingMiddlewareTests.errorHandlingMiddleware.intercept(
27+
Test_ErrorHandlingMiddlewareTests.mockRequest,
28+
body: Test_ErrorHandlingMiddlewareTests.mockBody,
29+
metadata: .init(),
30+
operationID: "testop",
31+
next: getNextMiddleware(failurePhase: .never)
32+
)
3133
XCTAssertEqual(response.0.status, .ok)
3234
}
33-
3435
func testError_confirmingToProtocol_convertedToResponse() async throws {
35-
let (response, responseBody) = try await Test_ErrorHandlingMiddlewareTests.errorHandlingMiddleware.intercept(Test_ErrorHandlingMiddlewareTests.mockRequest,
36-
body: Test_ErrorHandlingMiddlewareTests.mockBody,
37-
metadata: .init(), operationID: "testop",
38-
next: getNextMiddleware(failurePhase: .convertibleError))
36+
let (response, responseBody) = try await Test_ErrorHandlingMiddlewareTests.errorHandlingMiddleware.intercept(
37+
Test_ErrorHandlingMiddlewareTests.mockRequest,
38+
body: Test_ErrorHandlingMiddlewareTests.mockBody,
39+
metadata: .init(),
40+
operationID: "testop",
41+
next: getNextMiddleware(failurePhase: .convertibleError)
42+
)
3943
XCTAssertEqual(response.status, .badGateway)
4044
XCTAssertEqual(response.headerFields, [.contentType: "application/json"])
4145
XCTAssertEqual(responseBody, TEST_HTTP_BODY)
4246
}
4347

44-
4548
func testError_confirmingToProtocolWithoutAllValues_convertedToResponse() async throws {
46-
let (response, responseBody) = try await Test_ErrorHandlingMiddlewareTests.errorHandlingMiddleware.intercept(Test_ErrorHandlingMiddlewareTests.mockRequest,
47-
body: Test_ErrorHandlingMiddlewareTests.mockBody,
48-
metadata: .init(), operationID: "testop",
49-
next: getNextMiddleware(failurePhase: .partialConvertibleError))
49+
let (response, responseBody) = try await Test_ErrorHandlingMiddlewareTests.errorHandlingMiddleware.intercept(
50+
Test_ErrorHandlingMiddlewareTests.mockRequest,
51+
body: Test_ErrorHandlingMiddlewareTests.mockBody,
52+
metadata: .init(),
53+
operationID: "testop",
54+
next: getNextMiddleware(failurePhase: .partialConvertibleError)
55+
)
5056
XCTAssertEqual(response.status, .badRequest)
5157
XCTAssertEqual(response.headerFields, [:])
5258
XCTAssertEqual(responseBody, nil)
5359
}
54-
5560
func testError_notConfirmingToProtocol_returns500() async throws {
56-
let (response, responseBody) = try await Test_ErrorHandlingMiddlewareTests.errorHandlingMiddleware.intercept(Test_ErrorHandlingMiddlewareTests.mockRequest,
57-
body: Test_ErrorHandlingMiddlewareTests.mockBody,
58-
metadata: .init(), operationID: "testop",
59-
next: getNextMiddleware(failurePhase: .nonConvertibleError))
61+
let (response, responseBody) = try await Test_ErrorHandlingMiddlewareTests.errorHandlingMiddleware.intercept(
62+
Test_ErrorHandlingMiddlewareTests.mockRequest,
63+
body: Test_ErrorHandlingMiddlewareTests.mockBody,
64+
metadata: .init(),
65+
operationID: "testop",
66+
next: getNextMiddleware(failurePhase: .nonConvertibleError)
67+
)
6068
XCTAssertEqual(response.status, .internalServerError)
6169
XCTAssertEqual(response.headerFields, [:])
6270
XCTAssertEqual(responseBody, nil)
6371
}
64-
65-
private func getNextMiddleware(failurePhase: MockErrorMiddleware_Next.FailurePhase) -> @Sendable (HTTPTypes.HTTPRequest,
66-
OpenAPIRuntime.HTTPBody?,
67-
OpenAPIRuntime.ServerRequestMetadata) async throws ->
68-
(HTTPTypes.HTTPResponse, OpenAPIRuntime.HTTPBody?) {
69-
70-
let mockNext: @Sendable (HTTPTypes.HTTPRequest,
71-
OpenAPIRuntime.HTTPBody?,
72-
OpenAPIRuntime.ServerRequestMetadata) async throws ->
73-
(HTTPTypes.HTTPResponse, OpenAPIRuntime.HTTPBody?) =
74-
{ request, body, metadata in
75-
try await MockErrorMiddleware_Next(failurePhase: failurePhase).intercept(request,
76-
body: body,
77-
metadata: metadata,
78-
operationID: "testop",
79-
next: { _,_,_ in (HTTPResponse.init(status: .ok), nil) })
80-
}
72+
private func getNextMiddleware(failurePhase: MockErrorMiddleware_Next.FailurePhase) -> @Sendable (
73+
HTTPTypes.HTTPRequest, OpenAPIRuntime.HTTPBody?, OpenAPIRuntime.ServerRequestMetadata
74+
) async throws -> (HTTPTypes.HTTPResponse, OpenAPIRuntime.HTTPBody?) {
75+
let mockNext:
76+
@Sendable (HTTPTypes.HTTPRequest, OpenAPIRuntime.HTTPBody?, OpenAPIRuntime.ServerRequestMetadata)
77+
async throws -> (HTTPTypes.HTTPResponse, OpenAPIRuntime.HTTPBody?) = { request, body, metadata in
78+
try await MockErrorMiddleware_Next(failurePhase: failurePhase)
79+
.intercept(
80+
request,
81+
body: body,
82+
metadata: metadata,
83+
operationID: "testop",
84+
next: { _, _, _ in (HTTPResponse.init(status: .ok), nil) }
85+
)
86+
}
8187
return mockNext
8288
}
8389
}
@@ -91,8 +97,7 @@ struct MockErrorMiddleware_Next: ServerMiddleware {
9197
}
9298
var failurePhase: FailurePhase = .never
9399

94-
@Sendable
95-
func intercept(
100+
@Sendable func intercept(
96101
_ request: HTTPRequest,
97102
body: HTTPBody?,
98103
metadata: ServerRequestMetadata,
@@ -101,25 +106,21 @@ struct MockErrorMiddleware_Next: ServerMiddleware {
101106
) async throws -> (HTTPResponse, HTTPBody?) {
102107
var error: (any Error)?
103108
switch failurePhase {
104-
case .never:
105-
break
106-
case .convertibleError:
107-
error = ConvertibleError()
108-
case .nonConvertibleError:
109-
error = NonConvertibleError()
110-
case .partialConvertibleError:
111-
error = PartialConvertibleError()
109+
case .never: break
110+
case .convertibleError: error = ConvertibleError()
111+
case .nonConvertibleError: error = NonConvertibleError()
112+
case .partialConvertibleError: error = PartialConvertibleError()
112113
}
113-
114114
if let underlyingError = error {
115-
throw ServerError(operationID: operationID,
116-
request: request,
117-
requestBody: body,
118-
requestMetadata: metadata,
119-
causeDescription: "",
120-
underlyingError: underlyingError)
115+
throw ServerError(
116+
operationID: operationID,
117+
request: request,
118+
requestBody: body,
119+
requestMetadata: metadata,
120+
causeDescription: "",
121+
underlyingError: underlyingError
122+
)
121123
}
122-
123124
let (response, responseBody) = try await next(request, body, metadata)
124125
return (response, responseBody)
125126
}
@@ -137,4 +138,4 @@ struct PartialConvertibleError: Error, HTTPResponseConvertible {
137138

138139
struct NonConvertibleError: Error {}
139140

140-
let TEST_HTTP_BODY = HTTPBody(try! JSONEncoder().encode(["error"," test error"]))
141+
let TEST_HTTP_BODY = HTTPBody(try! JSONEncoder().encode(["error", " test error"]))

0 commit comments

Comments
 (0)