@miqro/core 1.5.15 → 1.5.16
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/dist/app-utils.d.ts +13 -0
- package/dist/app-utils.js +82 -0
- package/dist/app-utils.js.map +1 -0
- package/dist/app.js +6 -88
- package/dist/app.js.map +1 -1
- package/dist/common/context.js +4 -1
- package/dist/common/context.js.map +1 -1
- package/dist/router.js +3 -0
- package/dist/router.js.map +1 -1
- package/package.json +6 -6
- package/src/app-utils.ts +82 -0
- package/src/app-utils.unit.test.js +100 -0
- package/src/app.ts +4 -89
- package/src/app.unit.test.js +334 -0
- package/src/common/context.ts +4 -1
- package/src/common/context.unit.test.js +286 -0
- package/src/proxy.unit.test.js +157 -0
- package/src/router.ts +3 -0
- package/src/router.unit.test.js +397 -0
- package/src/setup-test.js +3 -1
|
@@ -0,0 +1,334 @@
|
|
|
1
|
+
const {fake, requireMock} = require("@miqro/test");
|
|
2
|
+
const {resolve} = require("path");
|
|
3
|
+
const {strictEqual} = require("assert");
|
|
4
|
+
const {distPath} = require("./setup-test.js");
|
|
5
|
+
|
|
6
|
+
const testFilePath = resolve(distPath, "app.js");
|
|
7
|
+
|
|
8
|
+
describe("app unit tests", () => {
|
|
9
|
+
describe("this.listen", () => {
|
|
10
|
+
it("happy path", () => {
|
|
11
|
+
const defaultAppErrorHandler = fake(() => {
|
|
12
|
+
});
|
|
13
|
+
const fakeServer = {
|
|
14
|
+
listen: fake(() => {
|
|
15
|
+
|
|
16
|
+
})
|
|
17
|
+
};
|
|
18
|
+
const createServer = fake(() => {
|
|
19
|
+
return fakeServer;
|
|
20
|
+
});
|
|
21
|
+
const {App} = requireMock(testFilePath, {
|
|
22
|
+
"http": {
|
|
23
|
+
createServer
|
|
24
|
+
},
|
|
25
|
+
"uuid": {},
|
|
26
|
+
"./common": {},
|
|
27
|
+
"./router": {
|
|
28
|
+
Router: class {
|
|
29
|
+
|
|
30
|
+
}
|
|
31
|
+
},
|
|
32
|
+
"./app-utils": {
|
|
33
|
+
defaultAppErrorHandler
|
|
34
|
+
}
|
|
35
|
+
}, distPath);
|
|
36
|
+
const app = new App();
|
|
37
|
+
strictEqual(defaultAppErrorHandler.callCount, 1);
|
|
38
|
+
strictEqual(createServer.callCount, 0);
|
|
39
|
+
app.listen(8080);
|
|
40
|
+
strictEqual(createServer.callCount, 1);
|
|
41
|
+
strictEqual(createServer.callArgs[0][0], app.listener);
|
|
42
|
+
strictEqual(fakeServer.listen.callCount, 1);
|
|
43
|
+
strictEqual(fakeServer.listen.callArgs[0][0], 8080);
|
|
44
|
+
});
|
|
45
|
+
});
|
|
46
|
+
describe("this.listener", () => {
|
|
47
|
+
it("run doesnt send response should send 404", async () => {
|
|
48
|
+
|
|
49
|
+
const v4Ret = "v4Ret";
|
|
50
|
+
|
|
51
|
+
const fakeLogger = {
|
|
52
|
+
trace: fake(() => {
|
|
53
|
+
|
|
54
|
+
})
|
|
55
|
+
};
|
|
56
|
+
|
|
57
|
+
const fakeReq = {};
|
|
58
|
+
|
|
59
|
+
const fakeRes = {}
|
|
60
|
+
|
|
61
|
+
const defaultAppErrorHandler = fake(() => {
|
|
62
|
+
});
|
|
63
|
+
|
|
64
|
+
const v4 = fake(() => {
|
|
65
|
+
return v4Ret;
|
|
66
|
+
});
|
|
67
|
+
|
|
68
|
+
const defaultLoggerFactory = fake(() => {
|
|
69
|
+
return fakeLogger;
|
|
70
|
+
});
|
|
71
|
+
|
|
72
|
+
const routerRun = fake(() => {
|
|
73
|
+
});
|
|
74
|
+
|
|
75
|
+
const ctxEnd = fake(() => {
|
|
76
|
+
|
|
77
|
+
});
|
|
78
|
+
|
|
79
|
+
class Context {
|
|
80
|
+
constructor(uuid, req, res, logger) {
|
|
81
|
+
this.uuid = uuid;
|
|
82
|
+
this.req = req;
|
|
83
|
+
this.res = res;
|
|
84
|
+
this.logger = logger;
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
end() {
|
|
88
|
+
if (this.res.headersSent) {
|
|
89
|
+
throw new Error("cannot double end res");
|
|
90
|
+
}
|
|
91
|
+
this.res.headersSent = true;
|
|
92
|
+
return ctxEnd(...arguments);
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
const {App} = requireMock(testFilePath, {
|
|
97
|
+
"http": {},
|
|
98
|
+
"uuid": {
|
|
99
|
+
v4
|
|
100
|
+
},
|
|
101
|
+
"./common": {
|
|
102
|
+
defaultLoggerFactory,
|
|
103
|
+
Context
|
|
104
|
+
},
|
|
105
|
+
"./router": {
|
|
106
|
+
Router: class {
|
|
107
|
+
run() {
|
|
108
|
+
return routerRun(...arguments);
|
|
109
|
+
}
|
|
110
|
+
}
|
|
111
|
+
},
|
|
112
|
+
"./app-utils": {
|
|
113
|
+
defaultAppErrorHandler,
|
|
114
|
+
HTML_HEADERS: "HTML_HEADERS",
|
|
115
|
+
STATUS: {
|
|
116
|
+
NOT_FOUND: "NOT_FOUND"
|
|
117
|
+
}
|
|
118
|
+
}
|
|
119
|
+
}, distPath);
|
|
120
|
+
const app = new App();
|
|
121
|
+
strictEqual(defaultAppErrorHandler.callCount, 1);
|
|
122
|
+
const ret = await app.listener(fakeReq, fakeRes);
|
|
123
|
+
strictEqual(ret, undefined);
|
|
124
|
+
strictEqual(routerRun.callCount, 1);
|
|
125
|
+
strictEqual(routerRun.callArgs[0][0] instanceof Context, true);
|
|
126
|
+
strictEqual(routerRun.callArgs[0][0].res, fakeRes);
|
|
127
|
+
strictEqual(routerRun.callArgs[0][0].req, fakeReq);
|
|
128
|
+
strictEqual(routerRun.callArgs[0][0].uuid, v4Ret);
|
|
129
|
+
strictEqual(routerRun.callArgs[0][0].logger, fakeLogger);
|
|
130
|
+
strictEqual(ctxEnd.callCount, 1);
|
|
131
|
+
strictEqual(ctxEnd.callArgs[0][0].status, "NOT_FOUND");
|
|
132
|
+
strictEqual(ctxEnd.callArgs[0][0].body, "NOT FOUND");
|
|
133
|
+
strictEqual(ctxEnd.callArgs[0][0].headers, "HTML_HEADERS");
|
|
134
|
+
});
|
|
135
|
+
|
|
136
|
+
it("run throws and defaultErrorHandler send response", async () => {
|
|
137
|
+
const v4Ret = "v4Ret";
|
|
138
|
+
|
|
139
|
+
const fakeLogger = {
|
|
140
|
+
trace: fake(() => {
|
|
141
|
+
|
|
142
|
+
})
|
|
143
|
+
};
|
|
144
|
+
|
|
145
|
+
const fakeReq = {};
|
|
146
|
+
|
|
147
|
+
const fakeRes = {}
|
|
148
|
+
|
|
149
|
+
const errorHandler = fake(async (e, ctx) => {
|
|
150
|
+
await ctx.end("fakeEnd");
|
|
151
|
+
});
|
|
152
|
+
|
|
153
|
+
const defaultAppErrorHandler = fake(() => {
|
|
154
|
+
return errorHandler;
|
|
155
|
+
});
|
|
156
|
+
|
|
157
|
+
const v4 = fake(() => {
|
|
158
|
+
return v4Ret;
|
|
159
|
+
});
|
|
160
|
+
|
|
161
|
+
const defaultLoggerFactory = fake(() => {
|
|
162
|
+
return fakeLogger;
|
|
163
|
+
});
|
|
164
|
+
|
|
165
|
+
const routerRun = fake(() => {
|
|
166
|
+
throw new Error("routerRunError");
|
|
167
|
+
});
|
|
168
|
+
|
|
169
|
+
const ctxEnd = fake(() => {
|
|
170
|
+
|
|
171
|
+
});
|
|
172
|
+
|
|
173
|
+
class Context {
|
|
174
|
+
constructor(uuid, req, res, logger) {
|
|
175
|
+
this.uuid = uuid;
|
|
176
|
+
this.req = req;
|
|
177
|
+
this.res = res;
|
|
178
|
+
this.logger = logger;
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
end() {
|
|
182
|
+
if (this.res.headersSent) {
|
|
183
|
+
throw new Error("cannot double end res");
|
|
184
|
+
}
|
|
185
|
+
this.res.headersSent = true;
|
|
186
|
+
return ctxEnd(...arguments);
|
|
187
|
+
}
|
|
188
|
+
}
|
|
189
|
+
|
|
190
|
+
const {App} = requireMock(testFilePath, {
|
|
191
|
+
"http": {},
|
|
192
|
+
"uuid": {
|
|
193
|
+
v4
|
|
194
|
+
},
|
|
195
|
+
"./common": {
|
|
196
|
+
defaultLoggerFactory,
|
|
197
|
+
Context
|
|
198
|
+
},
|
|
199
|
+
"./router": {
|
|
200
|
+
Router: class {
|
|
201
|
+
run() {
|
|
202
|
+
return routerRun(...arguments);
|
|
203
|
+
}
|
|
204
|
+
}
|
|
205
|
+
},
|
|
206
|
+
"./app-utils": {
|
|
207
|
+
defaultAppErrorHandler
|
|
208
|
+
}
|
|
209
|
+
}, distPath);
|
|
210
|
+
const app = new App();
|
|
211
|
+
strictEqual(defaultAppErrorHandler.callCount, 1);
|
|
212
|
+
const ret = await app.listener(fakeReq, fakeRes);
|
|
213
|
+
strictEqual(errorHandler.callCount, 1);
|
|
214
|
+
strictEqual(errorHandler.callArgs[0][0].message, "routerRunError");
|
|
215
|
+
strictEqual(errorHandler.callArgs[0][1] instanceof Context, true);
|
|
216
|
+
strictEqual(errorHandler.callArgs[0][1].res, fakeRes);
|
|
217
|
+
strictEqual(errorHandler.callArgs[0][1].req, fakeReq);
|
|
218
|
+
strictEqual(errorHandler.callArgs[0][1].uuid, v4Ret);
|
|
219
|
+
strictEqual(errorHandler.callArgs[0][1].logger, fakeLogger);
|
|
220
|
+
strictEqual(ret, undefined);
|
|
221
|
+
strictEqual(routerRun.callCount, 1);
|
|
222
|
+
strictEqual(routerRun.callArgs[0][0] instanceof Context, true);
|
|
223
|
+
strictEqual(routerRun.callArgs[0][0].res, fakeRes);
|
|
224
|
+
strictEqual(routerRun.callArgs[0][0].req, fakeReq);
|
|
225
|
+
strictEqual(routerRun.callArgs[0][0].uuid, v4Ret);
|
|
226
|
+
strictEqual(routerRun.callArgs[0][0].logger, fakeLogger);
|
|
227
|
+
strictEqual(ctxEnd.callCount, 1);
|
|
228
|
+
strictEqual(ctxEnd.callArgs[0][0], "fakeEnd");
|
|
229
|
+
});
|
|
230
|
+
|
|
231
|
+
it("run throws and defaultErrorHandler doesn't send response", async () => {
|
|
232
|
+
const v4Ret = "v4Ret";
|
|
233
|
+
|
|
234
|
+
const fakeLogger = {
|
|
235
|
+
trace: fake(() => {
|
|
236
|
+
|
|
237
|
+
}),
|
|
238
|
+
error: fake(() => {
|
|
239
|
+
|
|
240
|
+
})
|
|
241
|
+
};
|
|
242
|
+
|
|
243
|
+
const fakeReq = {};
|
|
244
|
+
|
|
245
|
+
const fakeRes = {}
|
|
246
|
+
|
|
247
|
+
const errorHandler = fake(async (e, ctx) => {
|
|
248
|
+
});
|
|
249
|
+
|
|
250
|
+
const defaultAppErrorHandler = fake(() => {
|
|
251
|
+
return errorHandler;
|
|
252
|
+
});
|
|
253
|
+
|
|
254
|
+
const v4 = fake(() => {
|
|
255
|
+
return v4Ret;
|
|
256
|
+
});
|
|
257
|
+
|
|
258
|
+
const defaultLoggerFactory = fake(() => {
|
|
259
|
+
return fakeLogger;
|
|
260
|
+
});
|
|
261
|
+
|
|
262
|
+
const routerRun = fake(() => {
|
|
263
|
+
throw new Error("routerRunError");
|
|
264
|
+
});
|
|
265
|
+
|
|
266
|
+
const ctxEnd = fake(() => {
|
|
267
|
+
|
|
268
|
+
});
|
|
269
|
+
|
|
270
|
+
class Context {
|
|
271
|
+
constructor(uuid, req, res, logger) {
|
|
272
|
+
this.uuid = uuid;
|
|
273
|
+
this.req = req;
|
|
274
|
+
this.res = res;
|
|
275
|
+
this.logger = logger;
|
|
276
|
+
}
|
|
277
|
+
|
|
278
|
+
end() {
|
|
279
|
+
if (this.res.headersSent) {
|
|
280
|
+
throw new Error("cannot double end res");
|
|
281
|
+
}
|
|
282
|
+
this.res.headersSent = true;
|
|
283
|
+
return ctxEnd(...arguments);
|
|
284
|
+
}
|
|
285
|
+
}
|
|
286
|
+
|
|
287
|
+
const {App} = requireMock(testFilePath, {
|
|
288
|
+
"http": {},
|
|
289
|
+
"uuid": {
|
|
290
|
+
v4
|
|
291
|
+
},
|
|
292
|
+
"./common": {
|
|
293
|
+
defaultLoggerFactory,
|
|
294
|
+
Context
|
|
295
|
+
},
|
|
296
|
+
"./router": {
|
|
297
|
+
Router: class {
|
|
298
|
+
run() {
|
|
299
|
+
return routerRun(...arguments);
|
|
300
|
+
}
|
|
301
|
+
}
|
|
302
|
+
},
|
|
303
|
+
"./app-utils": {
|
|
304
|
+
defaultAppErrorHandler,
|
|
305
|
+
HTML_HEADERS: "HTML_HEADERS",
|
|
306
|
+
STATUS: {
|
|
307
|
+
ERROR: "ERROR"
|
|
308
|
+
}
|
|
309
|
+
}
|
|
310
|
+
}, distPath);
|
|
311
|
+
const app = new App();
|
|
312
|
+
strictEqual(defaultAppErrorHandler.callCount, 1);
|
|
313
|
+
const ret = await app.listener(fakeReq, fakeRes);
|
|
314
|
+
strictEqual(errorHandler.callCount, 1);
|
|
315
|
+
strictEqual(errorHandler.callArgs[0][0].message, "routerRunError");
|
|
316
|
+
strictEqual(errorHandler.callArgs[0][1] instanceof Context, true);
|
|
317
|
+
strictEqual(errorHandler.callArgs[0][1].res, fakeRes);
|
|
318
|
+
strictEqual(errorHandler.callArgs[0][1].req, fakeReq);
|
|
319
|
+
strictEqual(errorHandler.callArgs[0][1].uuid, v4Ret);
|
|
320
|
+
strictEqual(errorHandler.callArgs[0][1].logger, fakeLogger);
|
|
321
|
+
strictEqual(ret, undefined);
|
|
322
|
+
strictEqual(routerRun.callCount, 1);
|
|
323
|
+
strictEqual(routerRun.callArgs[0][0] instanceof Context, true);
|
|
324
|
+
strictEqual(routerRun.callArgs[0][0].res, fakeRes);
|
|
325
|
+
strictEqual(routerRun.callArgs[0][0].req, fakeReq);
|
|
326
|
+
strictEqual(routerRun.callArgs[0][0].uuid, v4Ret);
|
|
327
|
+
strictEqual(routerRun.callArgs[0][0].logger, fakeLogger);
|
|
328
|
+
strictEqual(ctxEnd.callCount, 1);
|
|
329
|
+
strictEqual(ctxEnd.callArgs[0][0].status, "ERROR");
|
|
330
|
+
strictEqual(ctxEnd.callArgs[0][0].headers, "HTML_HEADERS");
|
|
331
|
+
strictEqual(ctxEnd.callArgs[0][0].body, "SERVER ERROR");
|
|
332
|
+
});
|
|
333
|
+
});
|
|
334
|
+
});
|
package/src/common/context.ts
CHANGED
|
@@ -71,7 +71,7 @@ export class Context {
|
|
|
71
71
|
const current = c ? c instanceof Array ? c.join(", ") : String(c) : "";
|
|
72
72
|
const nV = value instanceof Array ? value.join(", ") : String(value);
|
|
73
73
|
const newValue = current ? `${current}, ${nV}` : nV;
|
|
74
|
-
return this.
|
|
74
|
+
return this.setHeader("Vary", newValue.indexOf("*") !== -1 ? "*" : newValue);
|
|
75
75
|
}
|
|
76
76
|
|
|
77
77
|
public setHeader(name: string, value: number | string | ReadonlyArray<string>): ServerResponse {
|
|
@@ -87,6 +87,9 @@ export class Context {
|
|
|
87
87
|
status: number;
|
|
88
88
|
headers: OutgoingHttpHeaders;
|
|
89
89
|
}): Promise<void> {
|
|
90
|
+
if (this.res.headersSent) {
|
|
91
|
+
return Promise.reject(new Error("already ended"));
|
|
92
|
+
}
|
|
90
93
|
return new Promise<void>((resolve, reject) => {
|
|
91
94
|
try {
|
|
92
95
|
if (this.res.headersSent) {
|
|
@@ -0,0 +1,286 @@
|
|
|
1
|
+
const {fake, requireMock} = require("@miqro/test");
|
|
2
|
+
const {resolve} = require("path");
|
|
3
|
+
const {format} = require("util");
|
|
4
|
+
const {strictEqual} = require("assert");
|
|
5
|
+
const {distPath} = require("../setup-test.js");
|
|
6
|
+
const {serialize} = require("cookie");
|
|
7
|
+
|
|
8
|
+
const testFilePath = resolve(distPath, "common", "context.js");
|
|
9
|
+
|
|
10
|
+
describe("context unit tests", () => {
|
|
11
|
+
|
|
12
|
+
const res = {
|
|
13
|
+
headersSent: false,
|
|
14
|
+
end: fake((body, cb) => {
|
|
15
|
+
res.headersSent = true
|
|
16
|
+
cb();
|
|
17
|
+
}),
|
|
18
|
+
setHeader: fake(() => {
|
|
19
|
+
|
|
20
|
+
}),
|
|
21
|
+
removeHeader: fake(() => {
|
|
22
|
+
|
|
23
|
+
})
|
|
24
|
+
};
|
|
25
|
+
const logger = "logger1";
|
|
26
|
+
const newURLRet = {
|
|
27
|
+
pathname: "pathname",
|
|
28
|
+
searchParams: "searchParams"
|
|
29
|
+
};
|
|
30
|
+
const parseSearchParamsRet = "parseSearchParamsRet";
|
|
31
|
+
const normalizePathRet = "normalizePathRet";
|
|
32
|
+
const newURL = fake(() => {
|
|
33
|
+
return newURLRet;
|
|
34
|
+
});
|
|
35
|
+
const normalizePath = fake(() => {
|
|
36
|
+
return normalizePathRet;
|
|
37
|
+
});
|
|
38
|
+
const parseSearchParams = fake(() => {
|
|
39
|
+
return parseSearchParamsRet;
|
|
40
|
+
});
|
|
41
|
+
const cookieSerializeRet = "cookieSerializeRet";
|
|
42
|
+
const cookieSerialize = fake(() => {
|
|
43
|
+
return cookieSerializeRet;
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
let Context;
|
|
47
|
+
|
|
48
|
+
before(() => {
|
|
49
|
+
res.headersSent = false;
|
|
50
|
+
cookieSerialize.reset();
|
|
51
|
+
res.end.reset();
|
|
52
|
+
res.setHeader.reset();
|
|
53
|
+
res.removeHeader.reset();
|
|
54
|
+
newURL.reset();
|
|
55
|
+
normalizePath.reset();
|
|
56
|
+
parseSearchParams.reset();
|
|
57
|
+
const lib = requireMock(testFilePath, {
|
|
58
|
+
"./logger": {},
|
|
59
|
+
"./session": {},
|
|
60
|
+
"http": {},
|
|
61
|
+
"./tokenize-match": {
|
|
62
|
+
normalizePath,
|
|
63
|
+
parseSearchParams
|
|
64
|
+
},
|
|
65
|
+
"url": {},
|
|
66
|
+
"./helpers": {
|
|
67
|
+
newURL
|
|
68
|
+
},
|
|
69
|
+
"cookie": {
|
|
70
|
+
serialize: cookieSerialize
|
|
71
|
+
},
|
|
72
|
+
}, distPath);
|
|
73
|
+
Context = lib.Context;
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
const uuid = "uuid1";
|
|
77
|
+
[{
|
|
78
|
+
req: {
|
|
79
|
+
url: "/url",
|
|
80
|
+
socket: {
|
|
81
|
+
remoteAddress: "remoteAddress"
|
|
82
|
+
},
|
|
83
|
+
headers: {
|
|
84
|
+
host: "fakeHost"
|
|
85
|
+
}
|
|
86
|
+
}
|
|
87
|
+
}, {
|
|
88
|
+
req: {
|
|
89
|
+
url: "/url",
|
|
90
|
+
method: "MeThoD",
|
|
91
|
+
socket: {
|
|
92
|
+
remoteAddress: "remoteAddress"
|
|
93
|
+
},
|
|
94
|
+
headers: {
|
|
95
|
+
host: "fakeHost"
|
|
96
|
+
}
|
|
97
|
+
}
|
|
98
|
+
}].forEach(({req}) => {
|
|
99
|
+
|
|
100
|
+
it(format("ctor req %o", req), async () => {
|
|
101
|
+
const context = new Context(uuid, req, res, logger);
|
|
102
|
+
strictEqual(context.uuid, uuid);
|
|
103
|
+
strictEqual(context.body, undefined);
|
|
104
|
+
strictEqual(res.removeHeader.callCount, 1);
|
|
105
|
+
strictEqual(res.removeHeader.callArgs[0][0], "Date");
|
|
106
|
+
strictEqual(context.req, req);
|
|
107
|
+
strictEqual(context.res, res);
|
|
108
|
+
strictEqual(context.query, parseSearchParamsRet);
|
|
109
|
+
strictEqual(cookieSerialize.callCount, 0);
|
|
110
|
+
strictEqual(parseSearchParams.callCount, 1);
|
|
111
|
+
strictEqual(parseSearchParams.callArgs[0][0], newURLRet.searchParams);
|
|
112
|
+
strictEqual(normalizePath.callCount, 1);
|
|
113
|
+
strictEqual(normalizePath.callArgs[0][0], newURLRet.pathname);
|
|
114
|
+
strictEqual(context.path, normalizePathRet);
|
|
115
|
+
strictEqual(context.method, req.method ? req.method.toUpperCase() : "GET");
|
|
116
|
+
strictEqual(context.logger, logger);
|
|
117
|
+
strictEqual(context.url, newURLRet);
|
|
118
|
+
strictEqual(newURL.callCount, 1);
|
|
119
|
+
strictEqual(newURL.callArgs[0][0], req.url);
|
|
120
|
+
strictEqual(newURL.callArgs[0][1], `http://${req.headers.host}`);
|
|
121
|
+
strictEqual(res.end.callCount, 0);
|
|
122
|
+
strictEqual(res.setHeader.callCount, 0);
|
|
123
|
+
});
|
|
124
|
+
});
|
|
125
|
+
|
|
126
|
+
|
|
127
|
+
it("this.setHeader alias for this.res.setHeader", () => {
|
|
128
|
+
const context = new Context(uuid, {
|
|
129
|
+
url: "/url",
|
|
130
|
+
method: "MeThoD",
|
|
131
|
+
socket: {
|
|
132
|
+
remoteAddress: "remoteAddress"
|
|
133
|
+
},
|
|
134
|
+
headers: {
|
|
135
|
+
host: "fakeHost"
|
|
136
|
+
}
|
|
137
|
+
}, res, logger);
|
|
138
|
+
context.setHeader("key", "value");
|
|
139
|
+
strictEqual(cookieSerialize.callCount, 0);
|
|
140
|
+
strictEqual(res.end.callCount, 0);
|
|
141
|
+
strictEqual(res.setHeader.callCount, 1);
|
|
142
|
+
strictEqual(res.setHeader.callArgs[0][0], "key");
|
|
143
|
+
strictEqual(res.setHeader.callArgs[0][1], "value");
|
|
144
|
+
});
|
|
145
|
+
|
|
146
|
+
it("this.close calls this.end", async () => {
|
|
147
|
+
const context = new Context(uuid, {
|
|
148
|
+
url: "/url",
|
|
149
|
+
method: "MeThoD",
|
|
150
|
+
socket: {
|
|
151
|
+
remoteAddress: "remoteAddress"
|
|
152
|
+
},
|
|
153
|
+
headers: {
|
|
154
|
+
host: "fakeHost"
|
|
155
|
+
}
|
|
156
|
+
}, res, logger);
|
|
157
|
+
context.end = fake(async () => {
|
|
158
|
+
|
|
159
|
+
});
|
|
160
|
+
await context.close();
|
|
161
|
+
strictEqual(cookieSerialize.callCount, 0);
|
|
162
|
+
strictEqual(res.end.callCount, 0);
|
|
163
|
+
strictEqual(res.setHeader.callCount, 0);
|
|
164
|
+
strictEqual(context.end.callCount, 1);
|
|
165
|
+
strictEqual(context.end.callArgs[0][0].status, 400);
|
|
166
|
+
strictEqual(context.end.callArgs[0][0].headers.connection, "close");
|
|
167
|
+
});
|
|
168
|
+
|
|
169
|
+
it("this.addVaryHeader", () => {
|
|
170
|
+
// TODO
|
|
171
|
+
});
|
|
172
|
+
|
|
173
|
+
it("this.setCookie alias for this.res.setHeader with cookie.serializer", async () => {
|
|
174
|
+
const context = new Context(uuid, {
|
|
175
|
+
url: "/url",
|
|
176
|
+
method: "MeThoD",
|
|
177
|
+
socket: {
|
|
178
|
+
remoteAddress: "remoteAddress"
|
|
179
|
+
},
|
|
180
|
+
headers: {
|
|
181
|
+
host: "fakeHost"
|
|
182
|
+
}
|
|
183
|
+
}, res, logger);
|
|
184
|
+
await context.setCookie("name", "value");
|
|
185
|
+
strictEqual(cookieSerialize.callCount, 1);
|
|
186
|
+
strictEqual(cookieSerialize.callArgs[0][0], "name");
|
|
187
|
+
strictEqual(cookieSerialize.callArgs[0][1], "value");
|
|
188
|
+
strictEqual(res.end.callCount, 0);
|
|
189
|
+
strictEqual(res.setHeader.callCount, 1);
|
|
190
|
+
strictEqual(res.setHeader.callArgs[0][0], "Set-Cookie");
|
|
191
|
+
strictEqual(res.setHeader.callArgs[0][1], cookieSerializeRet);
|
|
192
|
+
});
|
|
193
|
+
|
|
194
|
+
it("this.end with headers not sent", async () => {
|
|
195
|
+
const context = new Context(uuid, {
|
|
196
|
+
url: "/url",
|
|
197
|
+
method: "MeThoD",
|
|
198
|
+
socket: {
|
|
199
|
+
remoteAddress: "remoteAddress"
|
|
200
|
+
},
|
|
201
|
+
headers: {
|
|
202
|
+
host: "fakeHost"
|
|
203
|
+
}
|
|
204
|
+
}, res, logger);
|
|
205
|
+
res.headersSent = true;
|
|
206
|
+
try {
|
|
207
|
+
await context.end("end1");
|
|
208
|
+
strictEqual(false, true);
|
|
209
|
+
} catch (e) {
|
|
210
|
+
strictEqual(e.message, "already ended");
|
|
211
|
+
}
|
|
212
|
+
});
|
|
213
|
+
|
|
214
|
+
it("this.end with headers sent", async () => {
|
|
215
|
+
const context = new Context(uuid, {
|
|
216
|
+
url: "/url",
|
|
217
|
+
method: "MeThoD",
|
|
218
|
+
socket: {
|
|
219
|
+
remoteAddress: "remoteAddress"
|
|
220
|
+
},
|
|
221
|
+
headers: {
|
|
222
|
+
host: "fakeHost"
|
|
223
|
+
}
|
|
224
|
+
}, res, logger
|
|
225
|
+
);
|
|
226
|
+
const headers = {
|
|
227
|
+
key1: "value1",
|
|
228
|
+
key2: "value2"
|
|
229
|
+
};
|
|
230
|
+
const body = "body";
|
|
231
|
+
const status = "status";
|
|
232
|
+
await context.end({
|
|
233
|
+
headers,
|
|
234
|
+
body,
|
|
235
|
+
status
|
|
236
|
+
});
|
|
237
|
+
strictEqual(res.end.callCount, 1);
|
|
238
|
+
strictEqual(res.end.callArgs[0][0], body);
|
|
239
|
+
strictEqual(res.setHeader.callCount, 2);
|
|
240
|
+
strictEqual(res.setHeader.callArgs[0][0], "key1");
|
|
241
|
+
strictEqual(res.setHeader.callArgs[0][1], "value1");
|
|
242
|
+
strictEqual(res.setHeader.callArgs[1][0], "key2");
|
|
243
|
+
strictEqual(res.setHeader.callArgs[1][1], "value2");
|
|
244
|
+
});
|
|
245
|
+
|
|
246
|
+
[{status: "status"}, {status: undefined}].forEach(({status}) => {
|
|
247
|
+
[{headers: "headers"}, {status: undefined}].forEach(({headers}) => {
|
|
248
|
+
[{body: {attr1: "value2"}}].forEach(({body}) => {
|
|
249
|
+
it(format("this.json alias for this.end %o", {status, headers, body}), async () => {
|
|
250
|
+
const context = new Context(uuid, {
|
|
251
|
+
url: "/url",
|
|
252
|
+
method: "MeThoD",
|
|
253
|
+
socket: {
|
|
254
|
+
remoteAddress: "remoteAddress"
|
|
255
|
+
},
|
|
256
|
+
headers: {
|
|
257
|
+
host: "fakeHost"
|
|
258
|
+
}
|
|
259
|
+
}, res, logger);
|
|
260
|
+
context.end = fake(async () => {
|
|
261
|
+
|
|
262
|
+
});
|
|
263
|
+
await context.json(body, headers, status);
|
|
264
|
+
strictEqual(cookieSerialize.callCount, 0);
|
|
265
|
+
strictEqual(res.end.callCount, 0);
|
|
266
|
+
strictEqual(res.setHeader.callCount, 0);
|
|
267
|
+
strictEqual(context.end.callCount, 1);
|
|
268
|
+
strictEqual(context.end.callArgs[0][0].status, status ? status : 200);
|
|
269
|
+
});
|
|
270
|
+
});
|
|
271
|
+
});
|
|
272
|
+
});
|
|
273
|
+
|
|
274
|
+
|
|
275
|
+
it("this.text", () => {
|
|
276
|
+
// TODO
|
|
277
|
+
});
|
|
278
|
+
|
|
279
|
+
it("this.html", () => {
|
|
280
|
+
// TODO
|
|
281
|
+
});
|
|
282
|
+
|
|
283
|
+
it("this.redirect", () => {
|
|
284
|
+
// TODO
|
|
285
|
+
});
|
|
286
|
+
});
|