refactor: modernize HTTPRequest tests (#7604)

This commit is contained in:
Brandon Scott
2021-10-08 16:44:40 -04:00
committed by GitHub
parent caee281bc5
commit 197fcbda00
2 changed files with 86 additions and 111 deletions

View File

@@ -6,7 +6,7 @@ const httpRequest = require('../lib/cloud-code/httpRequest'),
express = require('express');
const port = 13371;
const httpRequestServer = 'http://localhost:' + port;
const httpRequestServer = `http://localhost:${port}`;
function startServer(done) {
const app = express();
@@ -51,167 +51,136 @@ describe('httpRequest', () => {
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();
}, done.fail);
it('should do /hello', async () => {
const httpResponse = await httpRequest({
url: `${httpRequestServer}/hello`,
});
expect(httpResponse.status).toBe(200);
expect(httpResponse.buffer).toEqual(Buffer.from('{"response":"OK"}'));
expect(httpResponse.text).toEqual('{"response":"OK"}');
expect(httpResponse.data.response).toEqual('OK');
});
it('should do not follow redirects by default', done => {
httpRequest({
url: httpRequestServer + '/301',
}).then(function (httpResponse) {
expect(httpResponse.status).toBe(301);
done();
}, done.fail);
it('should do not follow redirects by default', async () => {
const httpResponse = await httpRequest({
url: `${httpRequestServer}/301`,
});
expect(httpResponse.status).toBe(301);
});
it('should follow redirects when set', done => {
httpRequest({
url: httpRequestServer + '/301',
it('should follow redirects when set', async () => {
const httpResponse = await 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();
}, done.fail);
});
expect(httpResponse.status).toBe(200);
expect(httpResponse.buffer).toEqual(Buffer.from('{"response":"OK"}'));
expect(httpResponse.text).toEqual('{"response":"OK"}');
expect(httpResponse.data.response).toEqual('OK');
});
it('should fail on 404', done => {
let calls = 0;
httpRequest({
url: httpRequestServer + '/404',
}).then(
function () {
calls++;
fail('should not succeed');
done();
},
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 fail on 404', async () => {
await expectAsync(
httpRequest({
url: `${httpRequestServer}/404`,
})
).toBeRejectedWith(
jasmine.objectContaining({
status: 404,
buffer: Buffer.from('NO'),
text: 'NO',
data: undefined,
})
);
});
it('should post on echo', done => {
httpRequest({
it('should post on echo', async () => {
const httpResponse = await httpRequest({
method: 'POST',
url: httpRequestServer + '/echo',
url: `${httpRequestServer}/echo`,
body: {
foo: 'bar',
},
headers: {
'Content-Type': 'application/json',
},
}).then(
function (httpResponse) {
expect(httpResponse.status).toBe(200);
expect(httpResponse.data).toEqual({ foo: 'bar' });
done();
},
function () {
fail('should not fail');
done();
}
);
});
expect(httpResponse.status).toBe(200);
expect(httpResponse.data).toEqual({ foo: 'bar' });
});
it('should encode a query string body by default', done => {
it('should encode a query string body by default', () => {
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 => {
it('should encode a JSON body', () => {
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 => {
it('should encode a www-form body', () => {
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 => {
it('should not encode a wrong content type', () => {
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',
}).then(done.fail, function (error) {
expect(error).not.toBeUndefined();
expect(error).not.toBeNull();
done();
});
it('should fail gracefully', async () => {
await expectAsync(
httpRequest({
url: 'http://not a good url',
})
).toBeRejected();
});
it('should params object to query string', done => {
httpRequest({
url: httpRequestServer + '/qs',
it('should params object to query string', async () => {
const httpResponse = await 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();
}
);
});
expect(httpResponse.status).toBe(200);
expect(httpResponse.data).toEqual({ foo: 'bar' });
});
it('should params string to query string', done => {
httpRequest({
url: httpRequestServer + '/qs',
it('should params string to query string', async () => {
const httpResponse = await 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();
}
);
});
expect(httpResponse.status).toBe(200);
expect(httpResponse.data).toEqual({ foo: 'bar', foo2: 'bar2' });
});
it('should not crash with undefined body', () => {
@@ -230,6 +199,7 @@ describe('httpRequest', () => {
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);
@@ -251,43 +221,47 @@ describe('httpRequest', () => {
});
it('serialized httpResponse correctly with body buffer string', () => {
const httpResponse = new HTTPResponse({}, new Buffer('hello'));
const httpResponse = new HTTPResponse({}, Buffer.from('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 httpResponse = new HTTPResponse({}, Buffer.from(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 httpResponse = new HTTPResponse({}, Buffer.from(json));
const encoded = Parse._encode(httpResponse);
let foundData,
foundText,
foundBody = false;
for (const key in encoded) {
if (key == 'data') {
if (key === 'data') {
foundData = true;
}
if (key == 'text') {
if (key === 'text') {
foundText = true;
}
if (key == 'body') {
if (key === 'body') {
foundBody = true;
}
}
expect(foundData).toBe(true);
expect(foundText).toBe(true);
expect(foundBody).toBe(false);