@fastify/express 4.0.2 → 4.0.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.github/dependabot.yml +1 -1
- package/.github/workflows/ci.yml +12 -2
- package/LICENSE +4 -1
- package/README.md +3 -3
- package/index.js +8 -1
- package/package.json +7 -10
- package/test/404s.test.js +83 -114
- package/test/application.test.js +48 -80
- package/test/basic.test.js +157 -284
- package/test/enhance-request.test.js +57 -80
- package/test/form-data.test.js +50 -64
- package/test/hooks.test.js +15 -17
- package/test/middleware.test.js +228 -183
package/test/middleware.test.js
CHANGED
|
@@ -2,55 +2,49 @@
|
|
|
2
2
|
|
|
3
3
|
// Original Fastify test/middlewares.test.js file
|
|
4
4
|
|
|
5
|
-
const
|
|
6
|
-
const test = t.test
|
|
7
|
-
const sget = require('simple-get').concat
|
|
5
|
+
const { test } = require('node:test')
|
|
8
6
|
const fastify = require('fastify')
|
|
9
7
|
const fp = require('fastify-plugin')
|
|
10
8
|
const cors = require('cors')
|
|
9
|
+
const express = require('express')
|
|
11
10
|
const helmet = require('helmet')
|
|
12
11
|
|
|
13
12
|
const expressPlugin = require('../index')
|
|
14
13
|
|
|
15
|
-
test('use a middleware', t => {
|
|
16
|
-
t.plan(
|
|
14
|
+
test('use a middleware', async t => {
|
|
15
|
+
t.plan(5)
|
|
17
16
|
|
|
18
17
|
const instance = fastify()
|
|
18
|
+
t.after(() => instance.close())
|
|
19
19
|
instance.register(expressPlugin)
|
|
20
20
|
.after(() => {
|
|
21
21
|
const useRes = instance.use(function (_req, _res, next) {
|
|
22
|
-
t.
|
|
22
|
+
t.assert.ok('middleware called')
|
|
23
23
|
next()
|
|
24
24
|
})
|
|
25
25
|
|
|
26
|
-
t.
|
|
26
|
+
t.assert.deepStrictEqual(useRes, instance)
|
|
27
27
|
})
|
|
28
28
|
|
|
29
29
|
instance.get('/', function (_request, reply) {
|
|
30
30
|
reply.send({ hello: 'world' })
|
|
31
31
|
})
|
|
32
32
|
|
|
33
|
-
instance.listen({ port: 0 }
|
|
34
|
-
t.error(err)
|
|
33
|
+
const address = await instance.listen({ port: 0 })
|
|
35
34
|
|
|
36
|
-
|
|
35
|
+
const result = await fetch(address)
|
|
37
36
|
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
t.error(err)
|
|
43
|
-
t.equal(response.statusCode, 200)
|
|
44
|
-
t.equal(response.headers['content-length'], '' + body.length)
|
|
45
|
-
t.same(JSON.parse(body), { hello: 'world' })
|
|
46
|
-
})
|
|
47
|
-
})
|
|
37
|
+
const responseText = await result.text()
|
|
38
|
+
t.assert.deepStrictEqual(result.status, 200)
|
|
39
|
+
t.assert.deepStrictEqual(result.headers.get('content-length'), '' + responseText.length)
|
|
40
|
+
t.assert.deepStrictEqual(JSON.parse(responseText), { hello: 'world' })
|
|
48
41
|
})
|
|
49
42
|
|
|
50
|
-
test('use cors', t => {
|
|
51
|
-
t.plan(
|
|
43
|
+
test('use cors', async t => {
|
|
44
|
+
t.plan(1)
|
|
52
45
|
|
|
53
46
|
const instance = fastify()
|
|
47
|
+
t.after(() => instance.close())
|
|
54
48
|
instance.register(expressPlugin)
|
|
55
49
|
.after(() => {
|
|
56
50
|
instance.use(cors())
|
|
@@ -60,25 +54,17 @@ test('use cors', t => {
|
|
|
60
54
|
reply.send({ hello: 'world' })
|
|
61
55
|
})
|
|
62
56
|
|
|
63
|
-
instance.listen({ port: 0 }
|
|
64
|
-
t.error(err)
|
|
65
|
-
|
|
66
|
-
t.teardown(instance.server.close.bind(instance.server))
|
|
57
|
+
const address = await instance.listen({ port: 0 })
|
|
67
58
|
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
url: 'http://localhost:' + instance.server.address().port
|
|
71
|
-
}, (err, response) => {
|
|
72
|
-
t.error(err)
|
|
73
|
-
t.equal(response.headers['access-control-allow-origin'], '*')
|
|
74
|
-
})
|
|
75
|
-
})
|
|
59
|
+
const result = await fetch(address)
|
|
60
|
+
t.assert.deepStrictEqual(result.headers.get('access-control-allow-origin'), '*')
|
|
76
61
|
})
|
|
77
62
|
|
|
78
|
-
test('use helmet', t => {
|
|
79
|
-
t.plan(
|
|
63
|
+
test('use helmet', async t => {
|
|
64
|
+
t.plan(1)
|
|
80
65
|
|
|
81
66
|
const instance = fastify()
|
|
67
|
+
t.after(() => instance.close())
|
|
82
68
|
instance.register(expressPlugin)
|
|
83
69
|
.after(() => {
|
|
84
70
|
instance.use(helmet())
|
|
@@ -88,25 +74,17 @@ test('use helmet', t => {
|
|
|
88
74
|
reply.send({ hello: 'world' })
|
|
89
75
|
})
|
|
90
76
|
|
|
91
|
-
instance.listen({ port: 0 }
|
|
92
|
-
t.error(err)
|
|
93
|
-
|
|
94
|
-
t.teardown(instance.server.close.bind(instance.server))
|
|
77
|
+
const address = await instance.listen({ port: 0 })
|
|
95
78
|
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
url: 'http://localhost:' + instance.server.address().port
|
|
99
|
-
}, (err, response) => {
|
|
100
|
-
t.error(err)
|
|
101
|
-
t.ok(response.headers['x-xss-protection'])
|
|
102
|
-
})
|
|
103
|
-
})
|
|
79
|
+
const result = await fetch(address)
|
|
80
|
+
t.assert.ok(result.headers.get('x-xss-protection'))
|
|
104
81
|
})
|
|
105
82
|
|
|
106
|
-
test('use helmet and cors', t => {
|
|
107
|
-
t.plan(
|
|
83
|
+
test('use helmet and cors', async t => {
|
|
84
|
+
t.plan(2)
|
|
108
85
|
|
|
109
86
|
const instance = fastify()
|
|
87
|
+
t.after(() => instance.close())
|
|
110
88
|
instance.register(expressPlugin)
|
|
111
89
|
.after(() => {
|
|
112
90
|
instance.use(cors())
|
|
@@ -117,26 +95,40 @@ test('use helmet and cors', t => {
|
|
|
117
95
|
reply.send({ hello: 'world' })
|
|
118
96
|
})
|
|
119
97
|
|
|
120
|
-
instance.listen({ port: 0 }
|
|
121
|
-
|
|
98
|
+
const address = await instance.listen({ port: 0 })
|
|
99
|
+
|
|
100
|
+
const result = await fetch(address)
|
|
101
|
+
|
|
102
|
+
t.assert.ok(result.headers.get('x-xss-protection'))
|
|
103
|
+
t.assert.deepStrictEqual(result.headers.get('access-control-allow-origin'), '*')
|
|
104
|
+
})
|
|
122
105
|
|
|
123
|
-
|
|
106
|
+
test('use cors only on prefix', async t => {
|
|
107
|
+
t.plan(1)
|
|
124
108
|
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
t.ok(response.headers['x-xss-protection'])
|
|
131
|
-
t.equal(response.headers['access-control-allow-origin'], '*')
|
|
109
|
+
const instance = fastify()
|
|
110
|
+
t.after(() => instance.close())
|
|
111
|
+
instance.register((innerInstance) => {
|
|
112
|
+
innerInstance.register(expressPlugin).after(() => {
|
|
113
|
+
innerInstance.use('/', cors())
|
|
132
114
|
})
|
|
133
|
-
|
|
115
|
+
innerInstance.get('/', function (_request, reply) {
|
|
116
|
+
reply.send({ hello: 'world' })
|
|
117
|
+
})
|
|
118
|
+
}, { prefix: '/prefix' })
|
|
119
|
+
|
|
120
|
+
const address = await instance.listen({ port: 0 })
|
|
121
|
+
|
|
122
|
+
const result = await fetch(address + '/prefix')
|
|
123
|
+
|
|
124
|
+
t.assert.deepStrictEqual(result.headers.get('access-control-allow-origin'), '*')
|
|
134
125
|
})
|
|
135
126
|
|
|
136
|
-
test('middlewares with prefix', t => {
|
|
137
|
-
t.plan(
|
|
127
|
+
test('middlewares with prefix', async t => {
|
|
128
|
+
t.plan(4)
|
|
138
129
|
|
|
139
130
|
const instance = fastify()
|
|
131
|
+
t.after(() => instance.close())
|
|
140
132
|
instance.register(expressPlugin)
|
|
141
133
|
.after(() => {
|
|
142
134
|
instance.use(function (req, _res, next) {
|
|
@@ -176,87 +168,64 @@ test('middlewares with prefix', t => {
|
|
|
176
168
|
instance.get('/prefix/', handler)
|
|
177
169
|
instance.get('/prefix/inner', handler)
|
|
178
170
|
|
|
179
|
-
instance.listen({ port: 0 }
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
}, (err, _response, body) => {
|
|
190
|
-
t.error(err)
|
|
191
|
-
t.same(body, {
|
|
192
|
-
global: true,
|
|
193
|
-
global2: true,
|
|
194
|
-
root: true
|
|
195
|
-
})
|
|
196
|
-
})
|
|
171
|
+
const address = await instance.listen({ port: 0 })
|
|
172
|
+
|
|
173
|
+
await t.test('/', async t => {
|
|
174
|
+
t.plan(1)
|
|
175
|
+
|
|
176
|
+
const result = await fetch(address + '/')
|
|
177
|
+
t.assert.deepStrictEqual(await result.json(), {
|
|
178
|
+
global: true,
|
|
179
|
+
global2: true,
|
|
180
|
+
root: true
|
|
197
181
|
})
|
|
182
|
+
})
|
|
198
183
|
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
global: true,
|
|
210
|
-
global2: true,
|
|
211
|
-
root: true,
|
|
212
|
-
slashed: true
|
|
213
|
-
})
|
|
214
|
-
})
|
|
184
|
+
await t.test('/prefix', async t => {
|
|
185
|
+
t.plan(1)
|
|
186
|
+
|
|
187
|
+
const result = await fetch(address + '/prefix')
|
|
188
|
+
t.assert.deepStrictEqual(await result.json(), {
|
|
189
|
+
prefixed: true,
|
|
190
|
+
global: true,
|
|
191
|
+
global2: true,
|
|
192
|
+
root: true,
|
|
193
|
+
slashed: true
|
|
215
194
|
})
|
|
195
|
+
})
|
|
216
196
|
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
slashed: true,
|
|
228
|
-
global: true,
|
|
229
|
-
global2: true,
|
|
230
|
-
root: true
|
|
231
|
-
})
|
|
232
|
-
})
|
|
197
|
+
await t.test('/prefix/', async t => {
|
|
198
|
+
t.plan(1)
|
|
199
|
+
|
|
200
|
+
const result = await fetch(address + '/prefix/')
|
|
201
|
+
t.assert.deepStrictEqual(await result.json(), {
|
|
202
|
+
prefixed: true,
|
|
203
|
+
slashed: true,
|
|
204
|
+
global: true,
|
|
205
|
+
global2: true,
|
|
206
|
+
root: true
|
|
233
207
|
})
|
|
208
|
+
})
|
|
234
209
|
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
slashed: true,
|
|
246
|
-
global: true,
|
|
247
|
-
global2: true,
|
|
248
|
-
root: true
|
|
249
|
-
})
|
|
250
|
-
})
|
|
210
|
+
await t.test('/prefix/inner', async t => {
|
|
211
|
+
t.plan(1)
|
|
212
|
+
|
|
213
|
+
const result = await fetch(address + '/prefix/inner')
|
|
214
|
+
t.assert.deepStrictEqual(await result.json(), {
|
|
215
|
+
prefixed: true,
|
|
216
|
+
slashed: true,
|
|
217
|
+
global: true,
|
|
218
|
+
global2: true,
|
|
219
|
+
root: true
|
|
251
220
|
})
|
|
252
221
|
})
|
|
253
222
|
})
|
|
254
223
|
|
|
255
|
-
test('res.end should block middleware execution', t => {
|
|
256
|
-
t.plan(
|
|
224
|
+
test('res.end should block middleware execution', async t => {
|
|
225
|
+
t.plan(4)
|
|
257
226
|
|
|
258
227
|
const instance = fastify()
|
|
259
|
-
t.
|
|
228
|
+
t.after(() => instance.close())
|
|
260
229
|
instance.register(expressPlugin)
|
|
261
230
|
.after(() => {
|
|
262
231
|
instance.use(function (_req, res) {
|
|
@@ -264,55 +233,51 @@ test('res.end should block middleware execution', t => {
|
|
|
264
233
|
})
|
|
265
234
|
|
|
266
235
|
instance.use(function () {
|
|
267
|
-
t.fail('we should not be here')
|
|
236
|
+
t.assert.fail('we should not be here')
|
|
268
237
|
})
|
|
269
238
|
})
|
|
270
239
|
|
|
271
240
|
instance.addHook('onRequest', (_req, _res, next) => {
|
|
272
|
-
t.ok('called')
|
|
241
|
+
t.assert.ok('called')
|
|
273
242
|
next()
|
|
274
243
|
})
|
|
275
244
|
|
|
276
245
|
instance.addHook('preHandler', () => {
|
|
277
|
-
t.fail('this should not be called')
|
|
246
|
+
t.assert.fail('this should not be called')
|
|
278
247
|
})
|
|
279
248
|
|
|
280
249
|
instance.addHook('onSend', (_req, _reply, payload, next) => {
|
|
281
|
-
t.ok('called')
|
|
250
|
+
t.assert.ok('called')
|
|
282
251
|
next(null, payload)
|
|
283
252
|
})
|
|
284
253
|
|
|
285
254
|
instance.addHook('onResponse', (_request, _reply, next) => {
|
|
286
|
-
t.ok('called')
|
|
255
|
+
t.assert.ok('called')
|
|
287
256
|
next()
|
|
288
257
|
})
|
|
289
258
|
|
|
290
259
|
instance.get('/', function () {
|
|
291
|
-
t.fail('we should no be here')
|
|
260
|
+
t.assert.fail('we should no be here')
|
|
292
261
|
})
|
|
293
262
|
|
|
294
|
-
instance.listen({ port: 0 }
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
t.equal(res.statusCode, 200)
|
|
302
|
-
t.equal(data.toString(), 'hello')
|
|
303
|
-
})
|
|
304
|
-
})
|
|
263
|
+
const address = await instance.listen({ port: 0 })
|
|
264
|
+
|
|
265
|
+
const result = await fetch(address)
|
|
266
|
+
|
|
267
|
+
t.assert.deepStrictEqual(result.status, 200)
|
|
268
|
+
|
|
269
|
+
t.assert.deepStrictEqual(await result.text(), 'hello')
|
|
305
270
|
})
|
|
306
271
|
|
|
307
|
-
test('Use a middleware inside a plugin after an encapsulated plugin', t => {
|
|
308
|
-
t.plan(
|
|
272
|
+
test('Use a middleware inside a plugin after an encapsulated plugin', async t => {
|
|
273
|
+
t.plan(3)
|
|
309
274
|
const f = fastify()
|
|
310
|
-
t.
|
|
275
|
+
t.after(() => f.close())
|
|
311
276
|
f.register(expressPlugin)
|
|
312
277
|
|
|
313
278
|
f.register(function (instance, _opts, next) {
|
|
314
279
|
instance.use(function (_req, _res, next) {
|
|
315
|
-
t.ok('first middleware called')
|
|
280
|
+
t.assert.ok('first middleware called')
|
|
316
281
|
next()
|
|
317
282
|
})
|
|
318
283
|
|
|
@@ -325,42 +290,37 @@ test('Use a middleware inside a plugin after an encapsulated plugin', t => {
|
|
|
325
290
|
|
|
326
291
|
f.register(fp(function (instance, _opts, next) {
|
|
327
292
|
instance.use(function (_req, _res, next) {
|
|
328
|
-
t.ok('second middleware called')
|
|
293
|
+
t.assert.ok('second middleware called')
|
|
329
294
|
next()
|
|
330
295
|
})
|
|
331
296
|
|
|
332
297
|
next()
|
|
333
298
|
}))
|
|
334
299
|
|
|
335
|
-
f.listen({ port: 0 }
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
t.error(err)
|
|
342
|
-
t.equal(res.statusCode, 200)
|
|
343
|
-
t.same(JSON.parse(data), { hello: 'world' })
|
|
344
|
-
})
|
|
345
|
-
})
|
|
300
|
+
const address = await f.listen({ port: 0 })
|
|
301
|
+
|
|
302
|
+
const result = await fetch(address)
|
|
303
|
+
t.assert.deepStrictEqual(result.status, 200)
|
|
304
|
+
|
|
305
|
+
t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
|
|
346
306
|
})
|
|
347
307
|
|
|
348
|
-
test('middlewares should run in the order in which they are defined', t => {
|
|
349
|
-
t.plan(
|
|
308
|
+
test('middlewares should run in the order in which they are defined', async t => {
|
|
309
|
+
t.plan(8)
|
|
350
310
|
const f = fastify()
|
|
351
|
-
t.
|
|
311
|
+
t.after(() => f.close())
|
|
352
312
|
f.register(expressPlugin)
|
|
353
313
|
|
|
354
314
|
f.register(fp(function (instance, _opts, next) {
|
|
355
315
|
instance.use(function (req, _res, next) {
|
|
356
|
-
t.
|
|
316
|
+
t.assert.deepStrictEqual(req.previous, undefined)
|
|
357
317
|
req.previous = 1
|
|
358
318
|
next()
|
|
359
319
|
})
|
|
360
320
|
|
|
361
321
|
instance.register(fp(function (i, _opts, next) {
|
|
362
322
|
i.use(function (req, _res, next) {
|
|
363
|
-
t.
|
|
323
|
+
t.assert.deepStrictEqual(req.previous, 2)
|
|
364
324
|
req.previous = 3
|
|
365
325
|
next()
|
|
366
326
|
})
|
|
@@ -368,7 +328,7 @@ test('middlewares should run in the order in which they are defined', t => {
|
|
|
368
328
|
}))
|
|
369
329
|
|
|
370
330
|
instance.use(function (req, _res, next) {
|
|
371
|
-
t.
|
|
331
|
+
t.assert.deepStrictEqual(req.previous, 1)
|
|
372
332
|
req.previous = 2
|
|
373
333
|
next()
|
|
374
334
|
})
|
|
@@ -378,19 +338,19 @@ test('middlewares should run in the order in which they are defined', t => {
|
|
|
378
338
|
|
|
379
339
|
f.register(function (instance, _opts, next) {
|
|
380
340
|
instance.use(function (req, _res, next) {
|
|
381
|
-
t.
|
|
341
|
+
t.assert.deepStrictEqual(req.previous, 3)
|
|
382
342
|
req.previous = 4
|
|
383
343
|
next()
|
|
384
344
|
})
|
|
385
345
|
|
|
386
346
|
instance.get('/', function (request, reply) {
|
|
387
|
-
t.
|
|
347
|
+
t.assert.deepStrictEqual(request.raw.previous, 5)
|
|
388
348
|
reply.send({ hello: 'world' })
|
|
389
349
|
})
|
|
390
350
|
|
|
391
351
|
instance.register(fp(function (i, _opts, next) {
|
|
392
352
|
i.use(function (req, _res, next) {
|
|
393
|
-
t.
|
|
353
|
+
t.assert.deepStrictEqual(req.previous, 4)
|
|
394
354
|
req.previous = 5
|
|
395
355
|
next()
|
|
396
356
|
})
|
|
@@ -400,15 +360,100 @@ test('middlewares should run in the order in which they are defined', t => {
|
|
|
400
360
|
next()
|
|
401
361
|
})
|
|
402
362
|
|
|
403
|
-
f.listen({ port: 0 }
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
363
|
+
const address = await f.listen({ port: 0 })
|
|
364
|
+
|
|
365
|
+
const result = await fetch(address)
|
|
366
|
+
t.assert.deepStrictEqual(result.status, 200)
|
|
367
|
+
t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
|
|
368
|
+
})
|
|
369
|
+
|
|
370
|
+
test('middlewares for encoded paths', async t => {
|
|
371
|
+
await t.test('decode the request url and run the middleware', async (t) => {
|
|
372
|
+
await checkEncodedPath('/encoded', '/%65ncoded', t)
|
|
373
|
+
})
|
|
374
|
+
|
|
375
|
+
await t.test('does not double decode the url', async (t) => {
|
|
376
|
+
await checkEncodedPath('/%65ncoded', '/%2565ncoded', t)
|
|
377
|
+
})
|
|
378
|
+
|
|
379
|
+
await t.test('handle the decoding for express handlers', async (t) => {
|
|
380
|
+
t.plan(6)
|
|
381
|
+
|
|
382
|
+
const routeUrl = '/express'
|
|
383
|
+
const requestUrl = '/%65xpress'
|
|
384
|
+
|
|
385
|
+
const instance = fastify()
|
|
386
|
+
t.after(() => instance.close())
|
|
387
|
+
|
|
388
|
+
instance.addHook('onSend', async function hook (request, reply, payload) {
|
|
389
|
+
t.assert.deepStrictEqual(request.raw.url, routeUrl)
|
|
390
|
+
t.assert.deepStrictEqual(request.raw.originalUrl, requestUrl)
|
|
391
|
+
return payload
|
|
392
|
+
})
|
|
393
|
+
|
|
394
|
+
instance.addHook('onResponse', async function hook (request, reply) {
|
|
395
|
+
t.assert.deepStrictEqual(request.raw.url, routeUrl)
|
|
396
|
+
t.assert.deepStrictEqual(request.raw.originalUrl, requestUrl)
|
|
397
|
+
})
|
|
398
|
+
|
|
399
|
+
await instance.register(expressPlugin)
|
|
400
|
+
|
|
401
|
+
// Register the express-like middleware
|
|
402
|
+
instance.use(routeUrl, function (req, _res, next) {
|
|
403
|
+
req.slashedByExpress = true
|
|
404
|
+
next()
|
|
405
|
+
})
|
|
406
|
+
|
|
407
|
+
// Register an express Router with an express handler
|
|
408
|
+
const innerRouter = express.Router()
|
|
409
|
+
innerRouter.get(routeUrl, function (req, res) {
|
|
410
|
+
res.send({ slashedByExpress: req.slashedByExpress })
|
|
412
411
|
})
|
|
412
|
+
instance.use(innerRouter)
|
|
413
|
+
|
|
414
|
+
const address = await instance.listen({ port: 0 })
|
|
415
|
+
|
|
416
|
+
const response = await fetch(address + requestUrl)
|
|
417
|
+
const body = await response.json()
|
|
418
|
+
t.assert.ok(response.ok)
|
|
419
|
+
t.assert.deepStrictEqual(body, { slashedByExpress: true })
|
|
413
420
|
})
|
|
414
421
|
})
|
|
422
|
+
|
|
423
|
+
async function checkEncodedPath (routeUrl, requestUrl, t) {
|
|
424
|
+
t.plan(6)
|
|
425
|
+
|
|
426
|
+
const instance = fastify()
|
|
427
|
+
t.after(() => instance.close())
|
|
428
|
+
|
|
429
|
+
instance.addHook('onSend', async function hook (request, reply, payload) {
|
|
430
|
+
t.assert.deepStrictEqual(request.raw.url, routeUrl)
|
|
431
|
+
t.assert.deepStrictEqual(request.raw.originalUrl, requestUrl)
|
|
432
|
+
return payload
|
|
433
|
+
})
|
|
434
|
+
|
|
435
|
+
instance.addHook('onResponse', async function hook (request, reply) {
|
|
436
|
+
t.assert.deepStrictEqual(request.raw.url, routeUrl)
|
|
437
|
+
t.assert.deepStrictEqual(request.raw.originalUrl, requestUrl)
|
|
438
|
+
})
|
|
439
|
+
|
|
440
|
+
await instance.register(expressPlugin)
|
|
441
|
+
|
|
442
|
+
// Register the express-like middleware
|
|
443
|
+
instance.use(routeUrl, function (req, _res, next) {
|
|
444
|
+
req.slashed = true
|
|
445
|
+
next()
|
|
446
|
+
})
|
|
447
|
+
|
|
448
|
+
// ... with a Fastify route handler
|
|
449
|
+
instance.get(routeUrl, (request, reply) => {
|
|
450
|
+
reply.send({ slashed: request.raw.slashed, })
|
|
451
|
+
})
|
|
452
|
+
|
|
453
|
+
const address = await instance.listen({ port: 0 })
|
|
454
|
+
|
|
455
|
+
const response = await fetch(address + requestUrl)
|
|
456
|
+
const body = await response.json()
|
|
457
|
+
t.assert.ok(response.ok)
|
|
458
|
+
t.assert.deepStrictEqual(body, { slashed: true })
|
|
459
|
+
}
|