/
MiddlewareTests.swift
152 lines (126 loc) · 5.37 KB
/
MiddlewareTests.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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
import XCTVapor
import XCTest
import Vapor
import NIOCore
final class MiddlewareTests: XCTestCase {
actor OrderStore {
var order: [String] = []
func addOrder(_ orderValue: String) {
self.order.append(orderValue)
}
func getOrder() -> [String] {
self.order
}
}
final class OrderMiddleware: Middleware {
let pos: String
let store: OrderStore
init(_ pos: String, store: OrderStore) {
self.pos = pos
self.store = store
}
func respond(to req: Request, chainingTo next: Responder) -> EventLoopFuture<Response> {
req.eventLoop.makeFutureWithTask {
await self.store.addOrder(self.pos)
}.flatMap {
next.respond(to: req)
}
}
}
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 testFileMiddlewareFromBundle() throws {
var fileMiddleware: FileMiddleware!
XCTAssertNoThrow(fileMiddleware = try FileMiddleware(bundle: .module, publicDirectory: "/"), "FileMiddleware instantiation from Bundle should not fail")
let app = Application(.testing)
defer { app.shutdown() }
app.middleware.use(fileMiddleware)
try app.testable().test(.GET, "/foo.txt") { result in
XCTAssertEqual(result.status, .ok)
XCTAssertEqual(result.body.string, "bar\n")
}
}
func testFileMiddlewareFromBundleSubfolder() throws {
var fileMiddleware: FileMiddleware!
XCTAssertNoThrow(fileMiddleware = try FileMiddleware(bundle: .module, publicDirectory: "SubUtilities"), "FileMiddleware instantiation from Bundle should not fail")
let app = Application(.testing)
defer { app.shutdown() }
app.middleware.use(fileMiddleware)
try app.testable().test(.GET, "/index.html") { result in
XCTAssertEqual(result.status, .ok)
XCTAssertEqual(result.body.string, "<h1>Subdirectory Default</h1>\n")
}
}
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)
}
}
}