350 lines
9.2 KiB
JavaScript
350 lines
9.2 KiB
JavaScript
'use strict';
|
|
|
|
const httpRequest = require('../lib/cloud-code/httpRequest'),
|
|
HTTPResponse = require('../lib/cloud-code/HTTPResponse').default,
|
|
bodyParser = require('body-parser'),
|
|
express = require('express');
|
|
|
|
const port = 13371;
|
|
const httpRequestServer = 'http://localhost:' + port;
|
|
|
|
function startServer(done) {
|
|
const app = express();
|
|
app.use(bodyParser.json({ type: '*/*' }));
|
|
app.get('/hello', function(req, res) {
|
|
res.json({ response: 'OK' });
|
|
});
|
|
|
|
app.get('/404', function(req, res) {
|
|
res.status(404);
|
|
res.send('NO');
|
|
});
|
|
|
|
app.get('/301', function(req, res) {
|
|
res.status(301);
|
|
res.location('/hello');
|
|
res.send();
|
|
});
|
|
|
|
app.post('/echo', function(req, res) {
|
|
res.json(req.body);
|
|
});
|
|
|
|
app.get('/qs', function(req, res) {
|
|
res.json(req.query);
|
|
});
|
|
|
|
return app.listen(13371, undefined, done);
|
|
}
|
|
|
|
describe('httpRequest', () => {
|
|
let server;
|
|
beforeAll(done => {
|
|
server = startServer(done);
|
|
});
|
|
|
|
afterAll(done => {
|
|
server.close(done);
|
|
});
|
|
|
|
it('should do /hello', done => {
|
|
httpRequest({
|
|
url: httpRequestServer + '/hello',
|
|
}).then(
|
|
function(httpResponse) {
|
|
expect(httpResponse.status).toBe(200);
|
|
expect(httpResponse.buffer).toEqual(new Buffer('{"response":"OK"}'));
|
|
expect(httpResponse.text).toEqual('{"response":"OK"}');
|
|
expect(httpResponse.data.response).toEqual('OK');
|
|
done();
|
|
},
|
|
function() {
|
|
fail('should not fail');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should do /hello with callback and promises', done => {
|
|
let calls = 0;
|
|
httpRequest({
|
|
url: httpRequestServer + '/hello',
|
|
success: function() {
|
|
calls++;
|
|
},
|
|
error: function() {
|
|
calls++;
|
|
},
|
|
}).then(
|
|
function(httpResponse) {
|
|
expect(calls).toBe(1);
|
|
expect(httpResponse.status).toBe(200);
|
|
expect(httpResponse.buffer).toEqual(new Buffer('{"response":"OK"}'));
|
|
expect(httpResponse.text).toEqual('{"response":"OK"}');
|
|
expect(httpResponse.data.response).toEqual('OK');
|
|
done();
|
|
},
|
|
function() {
|
|
fail('should not fail');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should do not follow redirects by default', done => {
|
|
httpRequest({
|
|
url: httpRequestServer + '/301',
|
|
}).then(
|
|
function(httpResponse) {
|
|
expect(httpResponse.status).toBe(301);
|
|
done();
|
|
},
|
|
function() {
|
|
fail('should not fail');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should follow redirects when set', done => {
|
|
httpRequest({
|
|
url: httpRequestServer + '/301',
|
|
followRedirects: true,
|
|
}).then(
|
|
function(httpResponse) {
|
|
expect(httpResponse.status).toBe(200);
|
|
expect(httpResponse.buffer).toEqual(new Buffer('{"response":"OK"}'));
|
|
expect(httpResponse.text).toEqual('{"response":"OK"}');
|
|
expect(httpResponse.data.response).toEqual('OK');
|
|
done();
|
|
},
|
|
function() {
|
|
fail('should not fail');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should fail on 404', done => {
|
|
let calls = 0;
|
|
httpRequest({
|
|
url: httpRequestServer + '/404',
|
|
success: function() {
|
|
calls++;
|
|
fail('should not succeed');
|
|
done();
|
|
},
|
|
error: function(httpResponse) {
|
|
calls++;
|
|
expect(calls).toBe(1);
|
|
expect(httpResponse.status).toBe(404);
|
|
expect(httpResponse.buffer).toEqual(new Buffer('NO'));
|
|
expect(httpResponse.text).toEqual('NO');
|
|
expect(httpResponse.data).toBe(undefined);
|
|
done();
|
|
},
|
|
});
|
|
});
|
|
|
|
it('should post on echo', done => {
|
|
let calls = 0;
|
|
httpRequest({
|
|
method: 'POST',
|
|
url: httpRequestServer + '/echo',
|
|
body: {
|
|
foo: 'bar',
|
|
},
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
},
|
|
success: function() {
|
|
calls++;
|
|
},
|
|
error: function() {
|
|
calls++;
|
|
},
|
|
}).then(
|
|
function(httpResponse) {
|
|
expect(calls).toBe(1);
|
|
expect(httpResponse.status).toBe(200);
|
|
expect(httpResponse.data).toEqual({ foo: 'bar' });
|
|
done();
|
|
},
|
|
function() {
|
|
fail('should not fail');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should encode a query string body by default', done => {
|
|
const options = {
|
|
body: { foo: 'bar' },
|
|
};
|
|
const result = httpRequest.encodeBody(options);
|
|
expect(result.body).toEqual('foo=bar');
|
|
expect(result.headers['Content-Type']).toEqual(
|
|
'application/x-www-form-urlencoded'
|
|
);
|
|
done();
|
|
});
|
|
|
|
it('should encode a JSON body', done => {
|
|
const options = {
|
|
body: { foo: 'bar' },
|
|
headers: { 'Content-Type': 'application/json' },
|
|
};
|
|
const result = httpRequest.encodeBody(options);
|
|
expect(result.body).toEqual('{"foo":"bar"}');
|
|
done();
|
|
});
|
|
it('should encode a www-form body', done => {
|
|
const options = {
|
|
body: { foo: 'bar', bar: 'baz' },
|
|
headers: { 'cOntent-tYpe': 'application/x-www-form-urlencoded' },
|
|
};
|
|
const result = httpRequest.encodeBody(options);
|
|
expect(result.body).toEqual('foo=bar&bar=baz');
|
|
done();
|
|
});
|
|
it('should not encode a wrong content type', done => {
|
|
const options = {
|
|
body: { foo: 'bar', bar: 'baz' },
|
|
headers: { 'cOntent-tYpe': 'mime/jpeg' },
|
|
};
|
|
const result = httpRequest.encodeBody(options);
|
|
expect(result.body).toEqual({ foo: 'bar', bar: 'baz' });
|
|
done();
|
|
});
|
|
|
|
it('should fail gracefully', done => {
|
|
httpRequest({
|
|
url: 'http://not a good url',
|
|
success: function() {
|
|
fail('should not succeed');
|
|
done();
|
|
},
|
|
error: function(error) {
|
|
expect(error).not.toBeUndefined();
|
|
expect(error).not.toBeNull();
|
|
done();
|
|
},
|
|
});
|
|
});
|
|
|
|
it('should params object to query string', done => {
|
|
httpRequest({
|
|
url: httpRequestServer + '/qs',
|
|
params: {
|
|
foo: 'bar',
|
|
},
|
|
}).then(
|
|
function(httpResponse) {
|
|
expect(httpResponse.status).toBe(200);
|
|
expect(httpResponse.data).toEqual({ foo: 'bar' });
|
|
done();
|
|
},
|
|
function() {
|
|
fail('should not fail');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should params string to query string', done => {
|
|
httpRequest({
|
|
url: httpRequestServer + '/qs',
|
|
params: 'foo=bar&foo2=bar2',
|
|
}).then(
|
|
function(httpResponse) {
|
|
expect(httpResponse.status).toBe(200);
|
|
expect(httpResponse.data).toEqual({ foo: 'bar', foo2: 'bar2' });
|
|
done();
|
|
},
|
|
function() {
|
|
fail('should not fail');
|
|
done();
|
|
}
|
|
);
|
|
});
|
|
|
|
it('should not crash with undefined body', () => {
|
|
const httpResponse = new HTTPResponse({});
|
|
expect(httpResponse.body).toBeUndefined();
|
|
expect(httpResponse.data).toBeUndefined();
|
|
expect(httpResponse.text).toBeUndefined();
|
|
expect(httpResponse.buffer).toBeUndefined();
|
|
});
|
|
|
|
it('serialized httpResponse correctly with body string', () => {
|
|
const httpResponse = new HTTPResponse({}, 'hello');
|
|
expect(httpResponse.text).toBe('hello');
|
|
expect(httpResponse.data).toBe(undefined);
|
|
expect(httpResponse.body).toBe('hello');
|
|
|
|
const serialized = JSON.stringify(httpResponse);
|
|
const result = JSON.parse(serialized);
|
|
expect(result.text).toBe('hello');
|
|
expect(result.data).toBe(undefined);
|
|
expect(result.body).toBe(undefined);
|
|
});
|
|
|
|
it('serialized httpResponse correctly with body object', () => {
|
|
const httpResponse = new HTTPResponse({}, { foo: 'bar' });
|
|
Parse._encode(httpResponse);
|
|
const serialized = JSON.stringify(httpResponse);
|
|
const result = JSON.parse(serialized);
|
|
|
|
expect(httpResponse.text).toEqual('{"foo":"bar"}');
|
|
expect(httpResponse.data).toEqual({ foo: 'bar' });
|
|
expect(httpResponse.body).toEqual({ foo: 'bar' });
|
|
|
|
expect(result.text).toEqual('{"foo":"bar"}');
|
|
expect(result.data).toEqual({ foo: 'bar' });
|
|
expect(result.body).toEqual(undefined);
|
|
});
|
|
|
|
it('serialized httpResponse correctly with body buffer string', () => {
|
|
const httpResponse = new HTTPResponse({}, new Buffer('hello'));
|
|
expect(httpResponse.text).toBe('hello');
|
|
expect(httpResponse.data).toBe(undefined);
|
|
|
|
const serialized = JSON.stringify(httpResponse);
|
|
const result = JSON.parse(serialized);
|
|
expect(result.text).toBe('hello');
|
|
expect(result.data).toBe(undefined);
|
|
});
|
|
|
|
it('serialized httpResponse correctly with body buffer JSON Object', () => {
|
|
const json = '{"foo":"bar"}';
|
|
const httpResponse = new HTTPResponse({}, new Buffer(json));
|
|
const serialized = JSON.stringify(httpResponse);
|
|
const result = JSON.parse(serialized);
|
|
expect(result.text).toEqual('{"foo":"bar"}');
|
|
expect(result.data).toEqual({ foo: 'bar' });
|
|
});
|
|
|
|
it('serialized httpResponse with Parse._encode should be allright', () => {
|
|
const json = '{"foo":"bar"}';
|
|
const httpResponse = new HTTPResponse({}, new Buffer(json));
|
|
const encoded = Parse._encode(httpResponse);
|
|
let foundData,
|
|
foundText,
|
|
foundBody = false;
|
|
for (const key in encoded) {
|
|
if (key == 'data') {
|
|
foundData = true;
|
|
}
|
|
if (key == 'text') {
|
|
foundText = true;
|
|
}
|
|
if (key == 'body') {
|
|
foundBody = true;
|
|
}
|
|
}
|
|
expect(foundData).toBe(true);
|
|
expect(foundText).toBe(true);
|
|
expect(foundBody).toBe(false);
|
|
});
|
|
});
|