/
AsyncMiddlewareTests.swift
118 lines (100 loc) · 4.1 KB
/
AsyncMiddlewareTests.swift
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
import XCTVapor
import XCTest
import Vapor
final class AsyncMiddlewareTests: XCTestCase {
actor OrderStore {
var order: [String] = []
func addOrder(_ orderValue: String) {
self.order.append(orderValue)
}
func getOrder() -> [String] {
self.order
}
}
final class OrderMiddleware: AsyncMiddleware {
let pos: String
let store: OrderStore
init(_ pos: String, store: OrderStore) {
self.pos = pos
self.store = store
}
func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
await store.addOrder(pos)
return try await next.respond(to: request)
}
}
func testMiddlewareOrder() async throws {
let app = Application(.testing)
defer { app.shutdown() }
let store = OrderStore()
app.grouped(
OrderMiddleware("a", store: store), OrderMiddleware("b", store: store), OrderMiddleware("c", store: store)
).get("order") { req -> String in
return "done"
}
try await app.testable().test(.GET, "/order") { res in
let order = await store.getOrder()
XCTAssertEqual(res.status, .ok)
XCTAssertEqual(order, ["a", "b", "c"])
XCTAssertEqual(res.body.string, "done")
}
}
func testPrependingMiddleware() async throws {
let app = Application(.testing)
defer { app.shutdown() }
let store = OrderStore()
app.middleware.use(OrderMiddleware("b", store: store))
app.middleware.use(OrderMiddleware("c", store: store))
app.middleware.use(OrderMiddleware("a", store: store), at: .beginning)
app.middleware.use(OrderMiddleware("d", store: store), at: .end)
app.get("order") { req -> String in
return "done"
}
try await app.testable().test(.GET, "/order") { res in
let order = await store.getOrder()
XCTAssertEqual(res.status, .ok)
XCTAssertEqual(order, ["a", "b", "c", "d"])
XCTAssertEqual(res.body.string, "done")
}
}
func testCORSMiddlewareVariedByRequestOrigin() throws {
let app = Application(.testing)
defer { app.shutdown() }
app.grouped(
CORSMiddleware(configuration: .init(allowedOrigin: .originBased, allowedMethods: [.GET], allowedHeaders: [.origin]))
).get("order") { req -> String in
return "done"
}
try app.testable().test(.GET, "/order", headers: ["Origin": "foo"]) { res in
XCTAssertEqual(res.status, .ok)
XCTAssertEqual(res.body.string, "done")
XCTAssertEqual(res.headers[.vary], ["origin"])
XCTAssertEqual(res.headers[.accessControlAllowOrigin], ["foo"])
XCTAssertEqual(res.headers[.accessControlAllowHeaders], ["origin"])
}
}
func testCORSMiddlewareNoVariationByRequestOriginAllowed() throws {
let app = Application(.testing)
defer { app.shutdown() }
app.grouped(
CORSMiddleware(configuration: .init(allowedOrigin: .none, allowedMethods: [.GET], allowedHeaders: []))
).get("order") { req -> String in
return "done"
}
try app.testable().test(.GET, "/order", headers: ["Origin": "foo"]) { res in
XCTAssertEqual(res.status, .ok)
XCTAssertEqual(res.body.string, "done")
XCTAssertEqual(res.headers[.vary], [])
XCTAssertEqual(res.headers[.accessControlAllowOrigin], [""])
XCTAssertEqual(res.headers[.accessControlAllowHeaders], [""])
}
}
func testFileMiddlewareFromBundleInvalidPublicDirectory() {
XCTAssertThrowsError(try FileMiddleware(bundle: .module, publicDirectory: "/totally-real/folder")) { error in
guard let error = error as? FileMiddleware.BundleSetupError else {
return XCTFail("Error should be of type FileMiddleware.SetupError")
}
XCTAssertEqual(error, .publicDirectoryIsNotAFolder)
}
}
}