2020-07-02 20:46:54 -04:00
|
|
|
/**
|
|
|
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
|
|
|
* or more contributor license agreements. See the NOTICE file
|
|
|
|
|
* distributed with this work for additional information
|
|
|
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
|
|
|
* to you under the Apache License, Version 2.0 (the
|
|
|
|
|
* "License"); you may not use this file except in compliance
|
|
|
|
|
* with the License. You may obtain a copy of the License at
|
|
|
|
|
*
|
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
|
*
|
|
|
|
|
* Unless required by applicable law or agreed to in writing,
|
|
|
|
|
* software distributed under the License is distributed on an
|
|
|
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
|
|
|
* KIND, either express or implied. See the License for the
|
|
|
|
|
* specific language governing permissions and limitations
|
|
|
|
|
* under the License.
|
|
|
|
|
*/
|
2018-09-07 21:36:47 -04:00
|
|
|
import fetchMock from 'fetch-mock';
|
2022-01-07 20:16:24 -05:00
|
|
|
import callApi from '../../../src/connection/callApi/callApi';
|
|
|
|
|
import parseResponse from '../../../src/connection/callApi/parseResponse';
|
2018-09-07 21:36:47 -04:00
|
|
|
|
|
|
|
|
import { LOGIN_GLOB } from '../fixtures/constants';
|
|
|
|
|
|
|
|
|
|
describe('parseResponse()', () => {
|
|
|
|
|
beforeAll(() => {
|
2021-03-01 16:46:25 -05:00
|
|
|
fetchMock.get(LOGIN_GLOB, { result: '1234' });
|
2018-09-07 21:36:47 -04:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
afterAll(fetchMock.restore);
|
|
|
|
|
|
|
|
|
|
const mockGetUrl = '/mock/get/url';
|
|
|
|
|
const mockPostUrl = '/mock/post/url';
|
|
|
|
|
const mockErrorUrl = '/mock/error/url';
|
2019-01-14 14:25:35 -05:00
|
|
|
const mockNoParseUrl = '/mock/noparse/url';
|
2018-09-07 21:36:47 -04:00
|
|
|
|
|
|
|
|
const mockGetPayload = { get: 'payload' };
|
|
|
|
|
const mockPostPayload = { post: 'payload' };
|
|
|
|
|
const mockErrorPayload = { status: 500, statusText: 'Internal error' };
|
|
|
|
|
|
|
|
|
|
fetchMock.get(mockGetUrl, mockGetPayload);
|
|
|
|
|
fetchMock.post(mockPostUrl, mockPostPayload);
|
|
|
|
|
fetchMock.get(mockErrorUrl, () => Promise.reject(mockErrorPayload));
|
2019-01-14 14:25:35 -05:00
|
|
|
fetchMock.get(mockNoParseUrl, new Response('test response'));
|
2018-09-07 21:36:47 -04:00
|
|
|
|
|
|
|
|
afterEach(fetchMock.reset);
|
|
|
|
|
|
|
|
|
|
it('returns a Promise', () => {
|
|
|
|
|
const apiPromise = callApi({ url: mockGetUrl, method: 'GET' });
|
|
|
|
|
const parsedResponsePromise = parseResponse(apiPromise);
|
2020-05-07 15:53:36 -04:00
|
|
|
expect(parsedResponsePromise).toBeInstanceOf(Promise);
|
2018-09-07 21:36:47 -04:00
|
|
|
});
|
|
|
|
|
|
2020-07-02 20:46:54 -04:00
|
|
|
it('resolves to { json, response } if the request succeeds', async () => {
|
2020-05-07 15:53:36 -04:00
|
|
|
expect.assertions(4);
|
2021-11-09 07:42:28 -05:00
|
|
|
const args = await parseResponse(
|
|
|
|
|
callApi({ url: mockGetUrl, method: 'GET' }),
|
|
|
|
|
);
|
2020-07-02 20:46:54 -04:00
|
|
|
expect(fetchMock.calls(mockGetUrl)).toHaveLength(1);
|
|
|
|
|
const keys = Object.keys(args);
|
|
|
|
|
expect(keys).toContain('response');
|
|
|
|
|
expect(keys).toContain('json');
|
2021-11-09 07:42:28 -05:00
|
|
|
expect(args.json).toEqual(
|
|
|
|
|
expect.objectContaining(mockGetPayload) as typeof args.json,
|
|
|
|
|
);
|
2018-09-07 21:36:47 -04:00
|
|
|
});
|
|
|
|
|
|
2020-07-02 20:46:54 -04:00
|
|
|
it('throws if `parseMethod=json` and .json() fails', async () => {
|
2018-09-07 21:36:47 -04:00
|
|
|
expect.assertions(3);
|
|
|
|
|
|
|
|
|
|
const mockTextUrl = '/mock/text/url';
|
|
|
|
|
const mockTextResponse =
|
|
|
|
|
'<html><head></head><body>I could be a stack trace or something</body></html>';
|
|
|
|
|
fetchMock.get(mockTextUrl, mockTextResponse);
|
|
|
|
|
|
2021-01-13 01:09:58 -05:00
|
|
|
let error;
|
2020-07-02 20:46:54 -04:00
|
|
|
try {
|
|
|
|
|
await parseResponse(callApi({ url: mockTextUrl, method: 'GET' }));
|
2021-01-13 01:09:58 -05:00
|
|
|
} catch (err) {
|
|
|
|
|
error = err as Error;
|
|
|
|
|
} finally {
|
2020-07-02 20:46:54 -04:00
|
|
|
expect(fetchMock.calls(mockTextUrl)).toHaveLength(1);
|
2021-01-13 01:09:58 -05:00
|
|
|
expect(error?.stack).toBeDefined();
|
|
|
|
|
expect(error?.message).toContain('Unexpected token');
|
2020-07-02 20:46:54 -04:00
|
|
|
}
|
2018-09-07 21:36:47 -04:00
|
|
|
});
|
|
|
|
|
|
2020-07-02 20:46:54 -04:00
|
|
|
it('resolves to { text, response } if the `parseMethod=text`', async () => {
|
2020-05-07 15:53:36 -04:00
|
|
|
expect.assertions(4);
|
2018-09-07 21:36:47 -04:00
|
|
|
|
2018-09-18 00:53:14 -04:00
|
|
|
// test with json + bigint to ensure that it was not first parsed as json
|
|
|
|
|
const mockTextParseUrl = '/mock/textparse/url';
|
|
|
|
|
const mockTextJsonResponse = '{ "value": 9223372036854775807 }';
|
|
|
|
|
fetchMock.get(mockTextParseUrl, mockTextJsonResponse);
|
2018-09-07 21:36:47 -04:00
|
|
|
|
2021-11-09 07:42:28 -05:00
|
|
|
const args = await parseResponse(
|
|
|
|
|
callApi({ url: mockTextParseUrl, method: 'GET' }),
|
|
|
|
|
'text',
|
|
|
|
|
);
|
2020-07-02 20:46:54 -04:00
|
|
|
expect(fetchMock.calls(mockTextParseUrl)).toHaveLength(1);
|
|
|
|
|
const keys = Object.keys(args);
|
|
|
|
|
expect(keys).toContain('response');
|
|
|
|
|
expect(keys).toContain('text');
|
|
|
|
|
expect(args.text).toBe(mockTextJsonResponse);
|
2018-09-18 00:53:14 -04:00
|
|
|
});
|
|
|
|
|
|
2020-07-02 20:46:54 -04:00
|
|
|
it('throws if parseMethod is not null|json|text', async () => {
|
|
|
|
|
expect.assertions(1);
|
2021-01-13 01:09:58 -05:00
|
|
|
|
|
|
|
|
let error;
|
2020-07-02 20:46:54 -04:00
|
|
|
try {
|
|
|
|
|
await parseResponse(
|
|
|
|
|
callApi({ url: mockNoParseUrl, method: 'GET' }),
|
|
|
|
|
'something-else' as never,
|
|
|
|
|
);
|
2021-01-13 01:09:58 -05:00
|
|
|
} catch (err) {
|
|
|
|
|
error = err;
|
|
|
|
|
} finally {
|
2021-11-09 07:42:28 -05:00
|
|
|
expect(error.message).toEqual(
|
|
|
|
|
expect.stringContaining('Expected parseResponse=json'),
|
|
|
|
|
);
|
2020-07-02 20:46:54 -04:00
|
|
|
}
|
2019-01-14 14:25:35 -05:00
|
|
|
});
|
|
|
|
|
|
2020-07-02 20:46:54 -04:00
|
|
|
it('resolves to unmodified `Response` object if `parseMethod=null|raw`', async () => {
|
|
|
|
|
expect.assertions(3);
|
2021-11-09 07:42:28 -05:00
|
|
|
const responseNull = await parseResponse(
|
|
|
|
|
callApi({ url: mockNoParseUrl, method: 'GET' }),
|
|
|
|
|
null,
|
|
|
|
|
);
|
|
|
|
|
const responseRaw = await parseResponse(
|
|
|
|
|
callApi({ url: mockNoParseUrl, method: 'GET' }),
|
|
|
|
|
'raw',
|
|
|
|
|
);
|
2020-07-02 20:46:54 -04:00
|
|
|
expect(fetchMock.calls(mockNoParseUrl)).toHaveLength(2);
|
|
|
|
|
expect(responseNull.bodyUsed).toBe(false);
|
|
|
|
|
expect(responseRaw.bodyUsed).toBe(false);
|
2018-09-07 21:36:47 -04:00
|
|
|
});
|
2018-09-18 20:30:01 -04:00
|
|
|
|
2022-10-26 18:04:20 -04:00
|
|
|
it('resolves to big number value if `parseMethod=json-bigint`', async () => {
|
|
|
|
|
const mockBigIntUrl = '/mock/get/bigInt';
|
|
|
|
|
const mockGetBigIntPayload =
|
2022-11-02 04:04:17 -04:00
|
|
|
'{ "value": 9223372036854775807, "minus": { "value": -483729382918228373892, "str": "something" }, "number": 1234, "floatValue": { "plus": 0.3452211361231223, "minus": -0.3452211361231223 } }';
|
2022-10-26 18:04:20 -04:00
|
|
|
fetchMock.get(mockBigIntUrl, mockGetBigIntPayload);
|
|
|
|
|
const responseBigNumber = await parseResponse(
|
|
|
|
|
callApi({ url: mockBigIntUrl, method: 'GET' }),
|
|
|
|
|
'json-bigint',
|
|
|
|
|
);
|
|
|
|
|
expect(`${responseBigNumber.json.value}`).toEqual('9223372036854775807');
|
2022-11-02 04:04:17 -04:00
|
|
|
expect(`${responseBigNumber.json.minus.value}`).toEqual(
|
2022-10-26 18:04:20 -04:00
|
|
|
'-483729382918228373892',
|
|
|
|
|
);
|
2022-10-31 13:20:43 -04:00
|
|
|
expect(responseBigNumber.json.number).toEqual(1234);
|
2022-11-02 04:04:17 -04:00
|
|
|
expect(responseBigNumber.json.floatValue.plus).toEqual(0.3452211361231223);
|
|
|
|
|
expect(responseBigNumber.json.floatValue.minus).toEqual(
|
|
|
|
|
-0.3452211361231223,
|
|
|
|
|
);
|
2022-10-31 13:20:43 -04:00
|
|
|
expect(
|
2022-11-02 04:04:17 -04:00
|
|
|
responseBigNumber.json.floatValue.plus +
|
|
|
|
|
responseBigNumber.json.floatValue.minus,
|
2022-10-31 13:20:43 -04:00
|
|
|
).toEqual(0);
|
|
|
|
|
expect(
|
2022-11-02 04:04:17 -04:00
|
|
|
responseBigNumber.json.floatValue.plus /
|
|
|
|
|
responseBigNumber.json.floatValue.minus,
|
2022-10-31 13:20:43 -04:00
|
|
|
).toEqual(-1);
|
2022-11-02 04:04:17 -04:00
|
|
|
expect(Math.min(responseBigNumber.json.floatValue.plus, 0)).toEqual(0);
|
|
|
|
|
expect(Math.abs(responseBigNumber.json.floatValue.minus)).toEqual(
|
|
|
|
|
responseBigNumber.json.floatValue.plus,
|
|
|
|
|
);
|
2022-10-26 18:04:20 -04:00
|
|
|
});
|
|
|
|
|
|
2020-07-02 20:46:54 -04:00
|
|
|
it('rejects if request.ok=false', async () => {
|
|
|
|
|
expect.assertions(3);
|
2018-09-18 20:30:01 -04:00
|
|
|
const mockNotOkayUrl = '/mock/notokay/url';
|
|
|
|
|
fetchMock.get(mockNotOkayUrl, 404); // 404s result in not response.ok=false
|
|
|
|
|
|
|
|
|
|
const apiPromise = callApi({ url: mockNotOkayUrl, method: 'GET' });
|
|
|
|
|
|
2021-01-13 01:09:58 -05:00
|
|
|
let error;
|
2020-07-02 20:46:54 -04:00
|
|
|
try {
|
|
|
|
|
await parseResponse(apiPromise);
|
2021-01-13 01:09:58 -05:00
|
|
|
} catch (err) {
|
|
|
|
|
error = err as { ok: boolean; status: number };
|
|
|
|
|
} finally {
|
2020-07-02 20:46:54 -04:00
|
|
|
expect(fetchMock.calls(mockNotOkayUrl)).toHaveLength(1);
|
2021-01-13 01:09:58 -05:00
|
|
|
expect(error?.ok).toBe(false);
|
|
|
|
|
expect(error?.status).toBe(404);
|
2020-07-02 20:46:54 -04:00
|
|
|
}
|
2018-09-18 20:30:01 -04:00
|
|
|
});
|
2018-09-07 21:36:47 -04:00
|
|
|
});
|
