react-http-fetch
Version:
An http library for React JS built on top of native JS fetch
359 lines (358 loc) • 21.9 kB
JavaScript
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
import { cleanup, renderHook, act, waitFor } from '@testing-library/react';
import { defaultHttpReqConfig, HttpContext, HttpContextToken, HttpError, HttpMethod, useHttpRequest, } from '..';
import { HttpClientProviderConfigFixture } from './fixtures/http-client-config-provider.fixture';
var fetch = global.fetch;
describe('use-http-request', function () {
var fetchResponse = {
name: 'Phelony',
role: 'Admin',
};
beforeEach(function () {
jest.useFakeTimers();
jest.spyOn(global, 'setTimeout');
});
afterEach(function () {
cleanup();
fetch.resetMocks();
jest.runAllTimers();
});
test('should update request state when it is in progress and completes', function () { return __awaiter(void 0, void 0, void 0, function () {
var result, _a, performRequest, reqResult, _b, fetchUrl, fetchParams, _c, fetchMethod, fetchHeaders, fetchCredentials, fetchBody, fetchSignal;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
fetch.mockResponseOnce(JSON.stringify(fetchResponse));
result = renderHook(function () { return useHttpRequest({}); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
_a = result.current, performRequest = _a[2];
expect(result.current[0].data).toBeUndefined();
expect(result.current[0].error).toBeNull();
expect(result.current[0].errored).toBe(false);
expect(result.current[0].isLoading).toBe(false);
expect(result.current[0].pristine).toBe(true);
act(function () {
reqResult = performRequest();
});
expect(result.current[0].data).toBeUndefined();
expect(result.current[0].error).toBeNull();
expect(result.current[0].errored).toBe(false);
expect(result.current[0].isLoading).toBe(true);
expect(result.current[0].pristine).toBe(false);
return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
var res;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, reqResult];
case 1:
res = _a.sent();
expect(res).toEqual(fetchResponse);
return [2 /*return*/];
}
});
}); })];
case 1:
_d.sent();
expect(result.current[0].data).toEqual(fetchResponse);
expect(result.current[0].error).toBeNull();
expect(result.current[0].errored).toBe(false);
expect(result.current[0].isLoading).toBe(false);
expect(result.current[0].pristine).toBe(false);
expect(fetch.mock.calls.length).toEqual(1);
_b = fetch.mock.calls[0], fetchUrl = _b[0], fetchParams = _b[1];
_c = fetchParams || {}, fetchMethod = _c.method, fetchHeaders = _c.headers, fetchCredentials = _c.credentials, fetchBody = _c.body, fetchSignal = _c.signal;
expect(fetchUrl).toBe('/');
expect(fetchMethod).toBe(HttpMethod.Get);
expect(fetchHeaders).toEqual(defaultHttpReqConfig.reqOptions.headers);
expect(fetchCredentials).toBeUndefined();
expect(fetchBody).toBeNull();
expect(fetchSignal).toBeUndefined();
return [2 /*return*/];
}
});
}); });
test('should update the request state when it goes in error', function () { return __awaiter(void 0, void 0, void 0, function () {
var fetchError, result, _a, performRequest, reqResult, _b, fetchUrl, fetchParams, _c, fetchMethod, fetchHeaders, fetchCredentials, fetchBody, fetchSignal;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
fetchError = new Error('Fetch error');
fetch.mockRejectOnce(fetchError);
result = renderHook(function () { return useHttpRequest({}); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
_a = result.current, performRequest = _a[2];
expect(result.current[0].data).toBeUndefined();
expect(result.current[0].error).toBeNull();
expect(result.current[0].errored).toBe(false);
expect(result.current[0].isLoading).toBe(false);
expect(result.current[0].pristine).toBe(true);
act(function () {
reqResult = performRequest();
});
expect(result.current[0].data).toBeUndefined();
expect(result.current[0].error).toBeNull();
expect(result.current[0].errored).toBe(false);
expect(result.current[0].isLoading).toBe(true);
expect(result.current[0].pristine).toBe(false);
return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
var error_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 2, , 3]);
return [4 /*yield*/, reqResult];
case 1:
_a.sent();
return [3 /*break*/, 3];
case 2:
error_1 = _a.sent();
expect(error_1).toBeInstanceOf(HttpError);
expect(error_1.message).toBe(fetchError.message);
expect(error_1.status).toBeUndefined();
expect(error_1.statusText).toBeUndefined();
expect(error_1.response).toBeUndefined();
expect(error_1.request.url).toBe('/');
expect(error_1.nativeError).toBe(fetchError);
return [3 /*break*/, 3];
case 3: return [2 /*return*/];
}
});
}); })];
case 1:
_d.sent();
expect(result.current[0].data).toBeUndefined();
expect(result.current[0].error).toEqual(fetchError);
expect(result.current[0].errored).toBe(true);
expect(result.current[0].isLoading).toBe(false);
expect(result.current[0].pristine).toBe(false);
expect(fetch.mock.calls.length).toEqual(1);
_b = fetch.mock.calls[0], fetchUrl = _b[0], fetchParams = _b[1];
_c = fetchParams || {}, fetchMethod = _c.method, fetchHeaders = _c.headers, fetchCredentials = _c.credentials, fetchBody = _c.body, fetchSignal = _c.signal;
expect(fetchUrl).toBe('/');
expect(fetchMethod).toBe(HttpMethod.Get);
expect(fetchHeaders).toEqual(defaultHttpReqConfig.reqOptions.headers);
expect(fetchCredentials).toBeUndefined();
expect(fetchBody).toBeNull();
expect(fetchSignal).toBeUndefined();
return [2 /*return*/];
}
});
}); });
test('should automatically perform the request on mount', function () { return __awaiter(void 0, void 0, void 0, function () {
var result, _a, fetchUrl, fetchParams, _b, fetchMethod, fetchHeaders, fetchCredentials, fetchBody, fetchSignal;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
fetch.mockResponseOnce(JSON.stringify(fetchResponse));
result = renderHook(function () { return useHttpRequest({ fetchOnBootstrap: true, initialData: {} }); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
expect(result.current[0].data).toEqual({});
expect(result.current[0].error).toBeNull();
expect(result.current[0].errored).toBe(false);
expect(result.current[0].isLoading).toBe(true);
expect(result.current[0].pristine).toBe(false);
// await waitForNextUpdate();
return [4 /*yield*/, waitFor(function () {
expect(result.current[0].isLoading).toBe(false);
}, { interval: 1 })];
case 1:
// await waitForNextUpdate();
_c.sent();
expect(result.current[0].data).toEqual(fetchResponse);
expect(result.current[0].error).toBeNull();
expect(result.current[0].errored).toBe(false);
expect(result.current[0].isLoading).toBe(false);
expect(result.current[0].pristine).toBe(false);
expect(fetch.mock.calls.length).toEqual(1);
_a = fetch.mock.calls[0], fetchUrl = _a[0], fetchParams = _a[1];
_b = fetchParams || {}, fetchMethod = _b.method, fetchHeaders = _b.headers, fetchCredentials = _b.credentials, fetchBody = _b.body, fetchSignal = _b.signal;
expect(fetchUrl).toBe('/');
expect(fetchMethod).toBe(HttpMethod.Get);
expect(fetchHeaders).toEqual(defaultHttpReqConfig.reqOptions.headers);
expect(fetchCredentials).toBeUndefined();
expect(fetchBody).toBeNull();
expect(fetchSignal).toBeUndefined();
return [2 /*return*/];
}
});
}); });
test('should merge params provided on hook declaration with the ones provided on request run', function () { return __awaiter(void 0, void 0, void 0, function () {
var result, _a, performRequest, reqResult, _b, fetchUrl, fetchParams, _c, fetchMethod, fetchHeaders, fetchCredentials, fetchBody, fetchSignal;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
fetch.mockResponseOnce('Phelony');
result = renderHook(function () {
return useHttpRequest({
baseUrlOverride: 'https://phelony.com',
relativeUrl: 'api/v1',
parser: function (res) { return res.text(); },
requestOptions: {
headers: {
'Content-Type': 'application/json',
},
},
});
}, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
_a = result.current, performRequest = _a[2];
expect(result.current[0].data).toBeUndefined();
expect(result.current[0].error).toBeNull();
expect(result.current[0].errored).toBe(false);
expect(result.current[0].isLoading).toBe(false);
expect(result.current[0].pristine).toBe(true);
act(function () {
reqResult = performRequest();
});
expect(result.current[0].data).toBeUndefined();
expect(result.current[0].error).toBeNull();
expect(result.current[0].errored).toBe(false);
expect(result.current[0].isLoading).toBe(true);
expect(result.current[0].pristine).toBe(false);
return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
var res;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, reqResult];
case 1:
res = _a.sent();
expect(res).toBe('Phelony');
return [2 /*return*/];
}
});
}); })];
case 1:
_d.sent();
expect(result.current[0].data).toBe('Phelony');
expect(result.current[0].error).toBeNull();
expect(result.current[0].errored).toBe(false);
expect(result.current[0].isLoading).toBe(false);
expect(result.current[0].pristine).toBe(false);
expect(fetch.mock.calls.length).toEqual(1);
_b = fetch.mock.calls[0], fetchUrl = _b[0], fetchParams = _b[1];
_c = fetchParams || {}, fetchMethod = _c.method, fetchHeaders = _c.headers, fetchCredentials = _c.credentials, fetchBody = _c.body, fetchSignal = _c.signal;
expect(fetchUrl).toBe('https://phelony.com/api/v1');
expect(fetchMethod).toBe(HttpMethod.Get);
expect(fetchHeaders).toEqual({
'Content-Type': 'application/json',
});
expect(fetchCredentials).toBeUndefined();
expect(fetchBody).toBeNull();
expect(fetchSignal).toBeUndefined();
return [2 /*return*/];
}
});
}); });
test('should allow to abort the request', function () { return __awaiter(void 0, void 0, void 0, function () {
var showGlobalLoader, reqContext, result, _a, performRequest, reqResult, caughtError, _b, fetchUrl, fetchParams, _c, fetchMethod, fetchHeaders, fetchCredentials, fetchBody, fetchSignal;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
fetch.mockAbortOnce();
showGlobalLoader = new HttpContextToken(true);
reqContext = new HttpContext().set(showGlobalLoader, false);
result = renderHook(function () { return useHttpRequest({ context: reqContext }); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
_a = result.current, performRequest = _a[1];
expect(result.current[0].data).toBeUndefined();
expect(result.current[0].error).toBeNull();
expect(result.current[0].errored).toBe(false);
expect(result.current[0].isLoading).toBe(false);
expect(result.current[0].pristine).toBe(true);
act(function () {
var _a = performRequest(), performRequestRes = _a.reqResult, abortController = _a.abortController;
abortController.abort();
reqResult = performRequestRes;
});
expect(result.current[0].data).toBeUndefined();
expect(result.current[0].error).toBeNull();
expect(result.current[0].errored).toBe(false);
expect(result.current[0].isLoading).toBe(true);
expect(result.current[0].pristine).toBe(false);
return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
var error_2;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 2, , 3]);
return [4 /*yield*/, reqResult];
case 1:
_a.sent();
return [3 /*break*/, 3];
case 2:
error_2 = _a.sent();
caughtError = error_2;
expect(error_2).toBeInstanceOf(HttpError);
expect(error_2.status).toBeUndefined();
expect(error_2.statsuText).toBeUndefined();
expect(error_2.response).toBeUndefined();
expect(error_2.message.trim()).toBe('The operation was aborted.');
expect(error_2.request.url).toBe('/');
expect(error_2.request.context).toBe(reqContext);
expect(error_2.nativeError.name).toBe('AbortError');
return [3 /*break*/, 3];
case 3: return [2 /*return*/];
}
});
}); })];
case 1:
_d.sent();
expect(result.current[0].data).toBeUndefined();
expect(result.current[0].error).toEqual(caughtError);
expect(result.current[0].errored).toBe(true);
expect(result.current[0].isLoading).toBe(false);
expect(result.current[0].pristine).toBe(false);
expect(fetch.mock.calls.length).toEqual(1);
_b = fetch.mock.calls[0], fetchUrl = _b[0], fetchParams = _b[1];
_c = fetchParams || {}, fetchMethod = _c.method, fetchHeaders = _c.headers, fetchCredentials = _c.credentials, fetchBody = _c.body, fetchSignal = _c.signal;
expect(fetchUrl).toBe('/');
expect(fetchMethod).toBe(HttpMethod.Get);
expect(fetchHeaders).toEqual(defaultHttpReqConfig.reqOptions.headers);
expect(fetchCredentials).toBeUndefined();
expect(fetchBody).toBeNull();
expect(fetchSignal).toBeInstanceOf(AbortSignal);
return [2 /*return*/];
}
});
}); });
});