Skip to content

Commit

Permalink
Tests for hooks
Browse files Browse the repository at this point in the history
  • Loading branch information
Maxim Lebedev committed Feb 26, 2020
1 parent 058677e commit 167bcef
Showing 1 changed file with 218 additions and 68 deletions.
286 changes: 218 additions & 68 deletions packages/http-api/test/http-server.spec.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,105 +2,255 @@
/* eslint sonarjs/no-identical-functions: 0 */

import * as chai from 'chai';
import { HttpMessageType, IHttpResponse } from '@testring/types';
import { HttpMessageType, HttpServerPlugins, IHttpRequest, IHttpRequestMessage, IHttpResponse } from '@testring/types';
import { TransportMock } from '@testring/test-utils';
import { HttpServer } from '../src/http-server';

// TODO (flops) add tests for cookies and hooks
// TODO (flops) add tests for cookies

describe('HttpServer', () => {
it('Should get data from broadcast', (callback) => {
const responseMock: IHttpResponse = {
statusCode: 200,
statusMessage: '',
body: null,
headers: {},
cookies: [],
};

const requestHandler = () => Promise.resolve(responseMock);
const transport = new TransportMock();
const httpServer = new HttpServer(transport, requestHandler);

transport.on(HttpMessageType.reject, (error) => {
callback(error);
describe('General', () => {
it('Should get data from broadcast', (callback) => {
const responseMock: IHttpResponse = {
statusCode: 200,
statusMessage: '',
body: null,
headers: {},
cookies: [],
};

const requestHandler = () => Promise.resolve(responseMock);
const transport = new TransportMock();
const httpServer = new HttpServer(transport, requestHandler);

transport.on(HttpMessageType.reject, (error) => {
callback(error);
});

transport.on(HttpMessageType.response, (response) => {
httpServer.kill();

try {
chai.expect(response.response).to.be.equal(responseMock);
callback();
} catch (err) {
callback(err);
}
});

transport.broadcast(HttpMessageType.send, {
uid: 'test',
request: {},
});
});

transport.on(HttpMessageType.response, (response) => {
httpServer.kill();
it('Should throw exception if data isn`t correct', (callback) => {
const rp = () => Promise.resolve();
const transport = new TransportMock();

try {
chai.expect(response.response).to.be.equal(responseMock);
callback();
} catch (err) {
callback(err);
}
const httpServer = new HttpServer(transport, rp as any);

transport.on(HttpMessageType.reject, (response) => {
httpServer.kill();

try {
chai.expect(response.error).to.be.instanceOf(Error);
callback();
} catch (err) {
callback(err);
}
});

transport.on(HttpMessageType.response, (response) => {
callback(`request complete somehow ${response}`);
});

transport.broadcast(HttpMessageType.send, {
uid: 'test',
request: null,
});
});

transport.broadcast(HttpMessageType.send, {
uid: 'test',
request: {},
it('Should throw exception if response isn`t correct', (callback) => {
const rp = () => Promise.resolve();

const transport = new TransportMock();

const httpServer = new HttpServer(transport, rp as any);

transport.on(HttpMessageType.reject, (response) => {
httpServer.kill();

try {
chai.expect(response.error).to.be.instanceOf(Error);
callback();
} catch (err) {
callback(err);
}
});

transport.on(HttpMessageType.response, (response) => {
try {
chai.expect(response.status < 400, 'Response error').to.equal(true);
} catch (err) {
callback(err);
}

callback(`request complete somehow ${response}`);
});

transport.broadcast(HttpMessageType.send, {
uid: 'test',
request: {},
});
});
});

it('Should throw exception if data isn`t correct', (callback) => {
const rp = () => Promise.resolve();
const transport = new TransportMock();
describe('Hooks', () => {
it('beforeRequest', (done) => {
const responseMock: IHttpResponse = {
statusCode: 200,
statusMessage: '',
body: null,
headers: {},
cookies: [],
};

const httpServer = new HttpServer(transport, rp as any);
let receivedRequest;

transport.on(HttpMessageType.reject, (response) => {
httpServer.kill();
const mockBody = 'mock body from test';
const requestHandler = (request) => {
receivedRequest = request;
return Promise.resolve(responseMock);
};
const transport = new TransportMock();
const httpServer = new HttpServer(transport, requestHandler);

try {
chai.expect(response.error).to.be.instanceOf(Error);
callback();
} catch (err) {
callback(err);
const testWriteHook = (request: IHttpRequest, data: IHttpRequestMessage): IHttpRequest => {
const result = { ...request };
result.body = mockBody;

return result;
};

const hook = httpServer.getHook(HttpServerPlugins.beforeRequest);
if (!hook) {
done(new Error('Hook not found'));
return;
}
});

transport.on(HttpMessageType.response, (response) => {
callback(`request complete somehow ${response}`);
});
hook.writeHook('test', testWriteHook);

transport.on(HttpMessageType.reject, (error) => done(error));
transport.on(HttpMessageType.response, (response) => {
httpServer.kill();

transport.broadcast(HttpMessageType.send, {
uid: 'test',
request: null,
try {
chai.expect(receivedRequest.body).to.deep.equal(mockBody);
done();
} catch (e) {
done(e);
}
});

transport.broadcast(HttpMessageType.send, {
request: {},
uid: 'test',
});
});
});

it('Should throw exception if response isn`t correct', (callback) => {
const rp = () => Promise.resolve();
it('beforeResponse', (done) => {
const responseMock: IHttpResponse = {
statusCode: 200,
statusMessage: '',
body: null,
headers: {},
cookies: [],
};
const mockRequest: IHttpRequest = {
body: 'test',
url: 'test',
};
const mockRequestData = { uid: 'test', request: mockRequest };

const transport = new TransportMock();
const mockHeaders = { 'mocked': true };
const requestHandler = () => Promise.resolve(responseMock);
const transport = new TransportMock();
const httpServer = new HttpServer(transport, requestHandler);

const httpServer = new HttpServer(transport, rp as any);
const writeHook = (
response: IHttpResponse,
data: IHttpRequestMessage,
request: IHttpRequest,
): IHttpResponse => {
chai.expect(request).to.deep.equal(mockRequest);
chai.expect(data).to.deep.equal(mockRequestData);

transport.on(HttpMessageType.reject, (response) => {
httpServer.kill();
return {
...response,
headers: mockHeaders,
};
};

try {
chai.expect(response.error).to.be.instanceOf(Error);
callback();
} catch (err) {
callback(err);
const hook = httpServer.getHook(HttpServerPlugins.beforeResponse);
if (!hook) {
done(new Error('Hook not found'));
return;
}

hook.writeHook('test', writeHook);

transport.on(HttpMessageType.reject, (error) => done(error));
transport.on(HttpMessageType.response, (response) => {
httpServer.kill();

try {
chai.expect(response.response.headers).to.deep.equal(mockHeaders);
done();
} catch (e) {
done(e);
}
});

transport.broadcast(HttpMessageType.send, mockRequestData);
});

transport.on(HttpMessageType.response, (response) => {
try {
chai.expect(response.status < 400, 'Response error').to.equal(true);
} catch (err) {
callback(err);
it('beforeError', (done) => {
const transport = new TransportMock();
const requestHandler = (): any => Promise.resolve();
const httpServer = new HttpServer(transport, requestHandler);
const mockErrorMessage = 'mock message';
const mockRequest = {};
const mockRequestData = { uid: 'test', request: mockRequest };

transport.on(HttpMessageType.reject, (error) => {
httpServer.kill();

try {
chai.expect(error.error).to.be.instanceOf(Error);
chai.expect(error.error.message).to.equal(mockErrorMessage);
done();
} catch (e) {
done(e);
}
});

const errorWriteHook = (error, data, request) => {
chai.expect(data).to.deep.equal(mockRequestData);
chai.expect(request).to.deep.equal(mockRequest);

return new Error(mockErrorMessage);
};

const hook = httpServer.getHook(HttpServerPlugins.beforeError);
if (!hook) {
done(new Error('Hook not found'));
return;
}

callback(`request complete somehow ${response}`);
});
hook.writeHook('test', errorWriteHook);

transport.broadcast(HttpMessageType.send, {
uid: 'test',
request: {},
transport.broadcast(HttpMessageType.send, mockRequestData);
});
});
});

0 comments on commit 167bcef

Please sign in to comment.