};
ctx = {};
});
- it('collects body without writing', function () {
+ it('collects response without writing', function () {
Dingus.setHeadHandler(req, res, ctx);
res.write(Buffer.from('foo'));
res.write('baz');
res.end('quux');
assert(!origWrite.called);
assert(origEnd.called);
+ assert.deepStrictEqual(ctx.responseBody, undefined);
+ });
+ it('collects response without writing, persists written data', function () {
+ Dingus.setHeadHandler(req, res, ctx, true);
+ res.write(Buffer.from('foo'));
+ res.write('baz');
+ res.write();
+ res.end('quux');
+ assert(!origWrite.called);
+ assert(origEnd.called);
assert.deepStrictEqual(ctx.responseBody, Buffer.from('foobazquux'));
});
it('ignores non-head method', function () {
await dingus.dispatch(req, res, ctx);
assert(dingus.handlerBadRequest.called);
});
-
+ it('calls handler with additional arguments', async function () {
+ dingus.on('GET', '/', stubHandler, 'foo', 'bar');
+ await dingus.dispatch(req, res, ctx);
+ assert(stubHandler.called);
+ assert.strictEqual(stubHandler.args[0][3], 'foo');
+ assert.strictEqual(stubHandler.args[0][4], 'bar');
+ });
}); // dispatch
describe('parseBody', function () {
assert.strictEqual(e, 'foo');
}
});
+ it('limits size', async function () {
+ const p = dingus.bodyData(res, 8);
+ resEvents['data'](Buffer.from('foobar'));
+ resEvents['data'](Buffer.from('bazquux'));
+ try {
+ await p;
+ assert.fail(noExpectedException);
+ } catch (e) {
+ assert.strictEqual(e.statusCode, 413);
+ }
+ });
+ it('provides buffer', async function () {
+ const p = dingus.bodyData(res, 0, false);
+ const expected = Buffer.from('bleat');
+ resEvents['data'](expected);
+ resEvents['end']();
+ const result = await p;
+ assert.deepStrictEqual(result, expected);
+ });
}); // bodyData
describe('ingestBody', function () {
- it('covers', async function () {
+ it('ingests json', async function () {
const req = {};
const res = {};
const ctx = {};
sinon.stub(Dingus, 'getRequestContentType').returns(Enum.ContentType.ApplicationJson);
await dingus.ingestBody(req, res, ctx);
assert.deepStrictEqual(ctx.parsedBody, { foo: 'bar' });
+ assert.deepStrictEqual(ctx.rawBody, undefined);
+ });
+ it('persists rawBody', async function () {
+ const req = {};
+ const res = {};
+ const ctx = {};
+ const body = '{"foo":"bar"}';
+ sinon.stub(dingus, 'bodyData').resolves(body);
+ sinon.stub(Dingus, 'getRequestContentType').returns(Enum.ContentType.ApplicationJson);
+ await dingus.ingestBody(req, res, ctx, { persistRawBody: true });
+ assert.deepStrictEqual(ctx.parsedBody, { foo: 'bar' });
+ assert.deepStrictEqual(ctx.rawBody, body);
+ });
+ it('skips parsing empty body', async function () {
+ const req = {};
+ const res = {};
+ const ctx = {};
+ const body = '';
+ sinon.stub(dingus, 'bodyData').resolves(body);
+ sinon.stub(Dingus, 'getRequestContentType').returns(Enum.ContentType.ApplicationJson);
+ sinon.spy(dingus, 'parseBody');
+ await dingus.ingestBody(req, res, ctx, { parseEmptyBody: false });
+ assert.deepStrictEqual(ctx.parsedBody, undefined);
+ assert(dingus.parseBody.notCalled);
});
}); // ingestBody
dingus.strictAccept = false;
dingus.setResponseType(['my/type'], req, res, ctx);
assert.strictEqual(ctx.responseType, 'my/type');
- });
+ });
}); // setResponseType
size: 8,
blocks: 17,
atimeMs: 1613253436842.815,
- mtimeMs: 1603485933192.8610,
- ctimeMs: 1603485933192.8610,
+ mtimeMs: 1603485933192.861,
+ ctimeMs: 1603485933192.861,
birthtimeMs: 0,
atime: '2021-02-13T21:57:16.843Z',
mtime: '2020-10-23T13:45:33.193Z',
await dingus.serveFile(req, res, ctx, directory, fileName);
assert(dingus.handlerNotFound.called);
});
+ it('requires directory be specified', async function () {
+ await dingus.serveFile(req, res, ctx, '', fileName);
+ assert(!fs.promises.readFile.called);
+ assert(dingus.handlerNotFound.called);
+ });
it('covers fs error', async function () {
const expectedException = new Error('blah');
fs.promises.stat.restore();
await dingus.serveFile(req, res, ctx, directory, fileName);
assert(res.end.called);
});
+ it('handles misconfigured encoding', async function () {
+ Enum.EncodingType.Flarp = 'flarp';
+ req._headers[Enum.Header.AcceptEncoding] = 'flarp, gzip';
+ await dingus.serveFile(req, res, ctx, directory, fileName);
+ delete Enum.EncodingType.Flarp;
+ assert(res.end.called);
+ });
}); // serveFile
describe('renderError', function () {
assert(pfxDingus.handlerNotFound.called);
});
}); // proxyPrefix
+
+ describe('handlerRedirect', function () {
+ let req, res, ctx;
+ beforeEach(function () {
+ req = {
+ getHeader: sinon.stub(),
+ };
+ res = {
+ setHeader: sinon.stub(),
+ end: sinon.stub(),
+ };
+ ctx = {};
+ });
+ it('covers', async function () {
+ await dingus.handlerRedirect(req, res, ctx);
+ assert(res.setHeader.called);
+ assert(res.end.called);
+ });
+ it('covers non-defaults', async function () {
+ await dingus.handlerRedirect(req, res, ctx, 308);
+ assert(res.setHeader.called);
+ assert(res.end.called);
+ });
+ }); // handlerRedirect
+
+ describe('handlerGetStaticFile', function () {
+ let req, res, ctx;
+ beforeEach(function () {
+ req = {
+ getHeader: sinon.stub(),
+ };
+ res = {
+ setHeader: sinon.stub(),
+ };
+ ctx = {
+ params: {
+ file: '',
+ },
+ };
+ sinon.stub(dingus, 'serveFile');
+ });
+ it('covers', async function () {
+ await dingus.handlerGetStaticFile(req, res, ctx);
+ assert(dingus.serveFile.called);
+ });
+ it('covers specified file', async function () {
+ await dingus.handlerGetStaticFile(req, res, ctx, 'file.txt');
+ assert(dingus.serveFile.called);
+ });
+ }); // handlerGetStaticFile
});
\ No newline at end of file