it('should reject invalid data and stop request cycle', async done => {
expect.assertions(2);
const app = new Koa();
const data = {
id: 1,
name: 'John Smith',
comment: 'A long comment about this generic person',
};
// Add middlewares
app.use((ctx, next) => {
(ctx.request as any).body = data; // Hack to inject a body
return next();
});
app.use(ensureSchema(exampleSchema));
app.use(ctx => fail('should not continue requests'));
const response = await request(app.callback()).get('/');
// Assertions
expect(response.status).toBe(500);
expect(response.text).toEqual('Internal Server Error');
// Done
done();
});
it('should log latency in milliseconds', async done => {
expect.assertions(3);
const app = new Koa();
const spy = jest.fn();
// Add middlewares
app.use((ctx, next) => {
// Add mock data
ctx.request.startAt = Date.now();
ctx.request.log = { info: spy } as any;
return next();
});
app.use(requestLogger());
app.use((ctx, next) => new Promise(resolve => setTimeout(resolve, 125)).then(next));
const response = await request(app.callback()).get('/');
// Assertions
expect(spy).toHaveBeenCalledTimes(1);
expect(spy.mock.calls[0][0].latency).toBeGreaterThan(120);
expect(spy.mock.calls[0][0].latency).toBeLessThan(1200);
// Done
done();
});
it('works', function(done){
let app = new Koa();
app.use(k(r.get('/hello', hello)));
app.use(k(r.get('/bye', bye)));
let request = Request.agent(listen(app));
// request.get('/else')
// .expect(404)
// .end(error=>{
// if(error) throw error;
// })
// request.get('/hello')
// .expect(200)
// .expect('hello')
// .end(error=>{
// if(error) throw error;
// });
request.get('/bye')
.expect(200)
.expect('bye')
.end((error, response) =>{
if(error) throw error;
done();
})
})
it('should hide "additionalDevelopmentData" in production', async done => {
expect.assertions(2);
const app = new Koa();
app.env = 'production';
// Add middlewares
app.use(errorHandler());
app.use(ctx => {
throw new Error('A custom error');
});
const response = await request(app.callback()).get('/');
// Assertions
expect(response.status).toBe(500);
expect(response.body).toEqual({
error: {
code: '',
error: 'Internal Server Error',
message: 'An internal server error occurred',
status: 500,
},
});
// Done
done();
});
public async register<T>(endPoint: EndPoint): Promise<void> {
// routes
const router = endPoint.getRouter();
if (router) {
this.app.use(router.getRouter().routes());
this.app.use(router.getRouter().allowedMethods());
// pretty print registered paths with methods
const methods: Map<string, string[]> = new Map<string, string[]>();
router.getRouter().stack.forEach(layer => methods.set(layer.path, [ ...methods.get(layer.path) || [], ...layer.methods ]));
uniq(router.getRouter().stack.map(layer => layer.path)).sort().forEach(path => {
logger.info(null, ' %s (%s)', path, methods.get(path).join(','));
});
}
// register model and serializer
endPoint
.registerModel()
.registerSerializer();
// import data
await endPoint.import();
// invalidate VP cache
await apiCache.invalidateVp();
}
it('should forward boom errors directly', async done => {
expect.assertions(2);
const app = new Koa();
// Add middlewares
app.use(errorHandler());
app.use(() => {
throw unauthorized();
});
const response = await request(app.callback()).get('/');
// Assertions
expect(response.status).toBe(401);
expect(response.body).toEqual({
error: {
additionalDevelopmentData: {},
code: '',
error: 'Unauthorized',
message: 'Unauthorized',
status: 401,
},
});
// Done
done();
});
beforeAll((done)=> {
jasmine.DEFAULT_TIMEOUT_INTERVAL=1000;
const Koa = require('koa');
const busboy = new KoaBusBoy({
limits: {
fields: 1,
fileSize: 1
}
});
const app = new Koa();
app.use(busboy);
app.use((ctx: any)=> {
if (ctx.formData) {
ctx.body = ctx.formData;
} else {
ctx.body = 'hello world';
}
});
app.on('error', (error: Error, ctx: any)=> {
ctx.status = 400;
ctx.body = error.message;
});
app.listen(3001, ()=> {
done();
});
});
it('should accept valid data', async done => {
expect.assertions(2);
const app = new Koa();
const data = {
id: 1,
name: 'John Smith',
isCool: false,
comment: 'A long comment about this generic person',
};
// Add middlewares
app.use((ctx, next) => {
(ctx.request as any).body = data; // Hack to inject a body
return next();
});
app.use(ensureSchema(exampleSchema));
app.use(ctx => {
ctx.body = 'success';
});
const response = await request(app.callback()).get('/');
// Assertions
expect(response.status).toBe(200);
expect(response.text).toBe('success');
// Done
done();
});
it('should reject invalid data', async done => {
expect.assertions(2);
const app = new Koa();
const data = {
id: 1,
name: 'John Smith',
comment: 'A long comment about this generic person',
};
// Add middlewares
app.use((ctx, next) => {
(ctx.request as any).body = data; // Hack to inject a body
return expect(next()).rejects.toThrow('Invalid data provided');
});
app.use(ensureSchema(exampleSchema));
app.use(ctx => fail('should not continue requests'));
const response = await request(app.callback()).get('/');
// Assertions
expect(response.status).toBe(404); // 404 because we do not let the exception bubble up from the assertion
// Done
done();
});
it('should encapsulate generic errors', async done => {
expect.assertions(2);
const app = new Koa();
// Add middlewares
app.use(errorHandler());
app.use(ctx => {
throw new Error('A custom error');
});
const response = await request(app.callback()).get('/');
// Assertions
expect(response.status).toBe(500);
expect(response.body).toEqual({
error: {
additionalDevelopmentData: {
stack: expect.stringContaining('Error: A custom error'),
},
code: '',
error: 'Internal Server Error',
message: 'An internal server error occurred',
status: 500,
},
});
// Done
done();
});
