react-http-fetch
Version:
An http library for React JS built on top of native JS fetch
593 lines (592 loc) • 34.7 kB
JavaScript
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
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 } from '@testing-library/react';
import { defaultHttpReqConfig, HttpContext, HttpContextToken, HttpError, HttpMethod, RequestErroredEvent, RequestStartedEvent, RequestSuccededEvent, useHttpClient, useHttpEvent, } from '..';
import { HttpClientProviderConfigFixture } from './fixtures/http-client-config-provider.fixture';
var fetch = global.fetch;
describe('use-http-client', function () {
var fetchResponse = {
name: 'Phelony',
role: 'Admin',
};
beforeEach(function () {
jest.useFakeTimers();
jest.spyOn(global, 'setTimeout');
});
afterEach(function () {
cleanup();
fetch.resetMocks();
jest.runAllTimers();
});
test('should perform a http request', function () { return __awaiter(void 0, void 0, void 0, function () {
var result, request, baseUrlOverride, relativeUrl, httpMethod, res, _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 useHttpClient(); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
request = result.current.request;
baseUrlOverride = 'https://phelony.com';
relativeUrl = 'todos/1';
httpMethod = HttpMethod.Get;
return [4 /*yield*/, request({
baseUrlOverride: baseUrlOverride,
relativeUrl: relativeUrl,
requestOptions: {
method: httpMethod,
},
})];
case 1:
res = _c.sent();
expect(res).toEqual(fetchResponse);
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("".concat(baseUrlOverride, "/").concat(relativeUrl));
expect(fetchMethod).toBe(httpMethod);
expect(fetchHeaders).toEqual(defaultHttpReqConfig.reqOptions.headers);
expect(fetchCredentials).toBeUndefined();
expect(fetchBody).toBeNull();
expect(fetchSignal).toBeUndefined();
return [2 /*return*/];
}
});
}); });
test('should allow to override provider request params', function () { return __awaiter(void 0, void 0, void 0, function () {
var result, request, baseUrlOverride, relativeUrl, httpMethod, headers, res, _a, fetchUrl, fetchParams, _b, fetchMethod, fetchHeaders, fetchSignal, fetchBody, fetchCredentials;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
fetch.mockResponseOnce(JSON.stringify(fetchResponse));
result = renderHook(function () { return useHttpClient(); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
request = result.current.request;
baseUrlOverride = 'https://phelony.com';
relativeUrl = 'todos/1';
httpMethod = HttpMethod.Get;
headers = {
'Content-Type': 'multipart/form-data;',
};
return [4 /*yield*/, request({
baseUrlOverride: baseUrlOverride,
relativeUrl: relativeUrl,
requestOptions: {
method: httpMethod,
headers: headers,
},
})];
case 1:
res = _c.sent();
expect(res).toEqual(fetchResponse);
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, fetchSignal = _b.signal, fetchBody = _b.body, fetchCredentials = _b.credentials;
expect(fetchUrl).toBe("".concat(baseUrlOverride, "/").concat(relativeUrl));
expect(fetchMethod).toBe(httpMethod);
expect(fetchHeaders).toEqual(headers);
expect(fetchSignal).toBeUndefined();
expect(fetchBody).toBeNull();
expect(fetchCredentials).toBeUndefined();
return [2 /*return*/];
}
});
}); });
test('should return a http error if the response has errors', function () { return __awaiter(void 0, void 0, void 0, function () {
var fetchError, result, showGlobalLoader, reqContext, request, error_1, _a, fetchUrl, fetchParams;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
fetchError = new Error('Fetch error');
fetch.mockRejectOnce(fetchError);
result = renderHook(function () { return useHttpClient(); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
showGlobalLoader = new HttpContextToken(true);
reqContext = new HttpContext().set(showGlobalLoader, false);
request = result.current.request;
_b.label = 1;
case 1:
_b.trys.push([1, 3, , 4]);
return [4 /*yield*/, request({ context: reqContext })];
case 2:
_b.sent();
return [3 /*break*/, 4];
case 3:
error_1 = _b.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.request.context).toBe(reqContext);
expect(error_1.nativeError).toBe(fetchError);
return [3 /*break*/, 4];
case 4:
expect(fetch.mock.calls.length).toEqual(1);
_a = fetch.mock.calls[0], fetchUrl = _a[0], fetchParams = _a[1];
expect(fetchUrl).toBe('/');
expect(fetchParams === null || fetchParams === void 0 ? void 0 : fetchParams.headers).toEqual(defaultHttpReqConfig.reqOptions.headers);
expect(fetchParams === null || fetchParams === void 0 ? void 0 : fetchParams.method).toBe(defaultHttpReqConfig.reqOptions.method);
expect(fetchParams === null || fetchParams === void 0 ? void 0 : fetchParams.body).toBeNull();
expect(fetchParams === null || fetchParams === void 0 ? void 0 : fetchParams.credentials).toBeUndefined();
expect(fetchParams === null || fetchParams === void 0 ? void 0 : fetchParams.signal).toBeUndefined();
return [2 /*return*/];
}
});
}); });
test('should dispatch events when the request starts and succeeds', function () { return __awaiter(void 0, void 0, void 0, function () {
function checkHttpEventHandlerReqParam(httpRequest) {
expect(httpRequest.baseUrl).toBe('');
expect(httpRequest.body).toBeUndefined();
expect(httpRequest.credentials).toBeUndefined();
expect(httpRequest.headers).toEqual(defaultHttpReqConfig.reqOptions.headers);
expect(httpRequest.maxAge).toBe(0);
expect(httpRequest.method).toBe(defaultHttpReqConfig.reqOptions.method);
expect(httpRequest.queryParams).toBeUndefined();
expect(httpRequest.relativeUrl).toBe('');
expect(httpRequest.signal).toBeUndefined();
expect(httpRequest.url).toBe('/');
expect(httpRequest.serializedQueryParams).toBe('');
expect(httpRequest.urlWithParams).toBe('/');
}
var useHttpClientResult, requestStartedEventHandler, requestSuccededEventHandler, requestErroredEventHandler, startedEventRequestParam, _a, succededEventRequestParam, succededEventResponseParam, fetchCalls, _b, fetchUrl, fetchParams;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
fetch.mockResponseOnce(JSON.stringify(fetchResponse));
useHttpClientResult = renderHook(function () { return useHttpClient(); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
requestStartedEventHandler = jest.fn();
renderHook(function () { return useHttpEvent(RequestStartedEvent, requestStartedEventHandler); });
requestSuccededEventHandler = jest.fn();
renderHook(function () { return useHttpEvent(RequestSuccededEvent, requestSuccededEventHandler); });
requestErroredEventHandler = jest.fn();
renderHook(function () { return useHttpEvent(RequestErroredEvent, requestSuccededEventHandler); });
return [4 /*yield*/, useHttpClientResult.current.request({})];
case 1:
_c.sent();
startedEventRequestParam = requestStartedEventHandler.mock.calls[0][0];
expect(requestStartedEventHandler.mock.calls.length).toBe(1);
checkHttpEventHandlerReqParam(startedEventRequestParam);
_a = requestSuccededEventHandler.mock.calls[0][0], succededEventRequestParam = _a.request, succededEventResponseParam = _a.response;
expect(requestSuccededEventHandler.mock.calls.length).toBe(1);
expect(succededEventResponseParam).toEqual(fetchResponse);
checkHttpEventHandlerReqParam(succededEventRequestParam);
expect(requestErroredEventHandler.mock.calls.length).toBe(0);
fetchCalls = fetch.mock.calls;
expect(fetchCalls.length).toBe(1);
_b = fetchCalls[0], fetchUrl = _b[0], fetchParams = _b[1];
expect(fetchUrl).toBe('/');
expect(fetchParams).toEqual(__assign(__assign({}, defaultHttpReqConfig.reqOptions), { method: HttpMethod.Get, body: null, credentials: undefined, maxAge: 0, signal: undefined, queryParams: undefined }));
return [2 /*return*/];
}
});
}); });
test('should dispatch events when the request starts and goes in error', function () { return __awaiter(void 0, void 0, void 0, function () {
function checkHttpEventHandlerReqParam(httpRequest) {
expect(httpRequest.baseUrl).toBe('');
expect(httpRequest.body).toBeUndefined();
expect(httpRequest.credentials).toBeUndefined();
expect(httpRequest.headers).toEqual(defaultHttpReqConfig.reqOptions.headers);
expect(httpRequest.maxAge).toBe(0);
expect(httpRequest.method).toBe(defaultHttpReqConfig.reqOptions.method);
expect(httpRequest.queryParams).toEqual(queryParams);
expect(httpRequest.relativeUrl).toBe('');
expect(httpRequest.signal).toBeUndefined();
expect(httpRequest.url).toBe('/');
expect(httpRequest.serializedQueryParams).toBe('orderBy=age%2B');
expect(httpRequest.urlWithParams).toBe('/?orderBy=age%2B');
}
var fetchError, queryParams, useHttpClientResult, requestStartedEventHandler, requestSuccededEventHandler, requestErroredEventHandler, error_2, startedEventRequestParam, httpError, fetchCalls, _a, fetchUrl, fetchParams;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
fetchError = new Error('Fetch error');
fetch.mockRejectOnce(fetchError);
queryParams = { orderBy: 'age+' };
useHttpClientResult = renderHook(function () { return useHttpClient(); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
requestStartedEventHandler = jest.fn();
renderHook(function () { return useHttpEvent(RequestStartedEvent, requestStartedEventHandler); });
requestSuccededEventHandler = jest.fn();
renderHook(function () { return useHttpEvent(RequestSuccededEvent, requestSuccededEventHandler); });
requestErroredEventHandler = jest.fn();
renderHook(function () { return useHttpEvent(RequestErroredEvent, requestErroredEventHandler); });
_b.label = 1;
case 1:
_b.trys.push([1, 3, , 4]);
return [4 /*yield*/, useHttpClientResult.current.request({
requestOptions: { queryParams: queryParams },
})];
case 2:
_b.sent();
return [3 /*break*/, 4];
case 3:
error_2 = _b.sent();
return [3 /*break*/, 4];
case 4:
startedEventRequestParam = requestStartedEventHandler.mock.calls[0][0];
expect(requestStartedEventHandler.mock.calls.length).toBe(1);
checkHttpEventHandlerReqParam(startedEventRequestParam);
expect(requestErroredEventHandler.mock.calls.length).toBe(1);
httpError = requestErroredEventHandler.mock.calls[0][0];
expect(httpError).toBeInstanceOf(HttpError);
checkHttpEventHandlerReqParam(httpError.request);
expect(httpError.message).toEqual(fetchError.message);
expect(httpError.status).toBeUndefined();
expect(httpError.statusText).toBeUndefined();
expect(httpError.response).toBeUndefined();
expect(requestSuccededEventHandler.mock.calls.length).toBe(0);
fetchCalls = fetch.mock.calls;
expect(fetchCalls.length).toBe(1);
_a = fetchCalls[0], fetchUrl = _a[0], fetchParams = _a[1];
expect(fetchUrl).toBe('/?orderBy=age%2B');
expect(fetchParams).toEqual(__assign(__assign({}, defaultHttpReqConfig.reqOptions), { method: HttpMethod.Get, body: null, credentials: undefined, maxAge: 0, signal: undefined, queryParams: queryParams }));
return [2 /*return*/];
}
});
}); });
test('should put the request response in the cache', function () { return __awaiter(void 0, void 0, void 0, function () {
var result, request, res1, fetchCalls, _a, fetchUrl, fetchParams, res2;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
fetch.mockResponseOnce(JSON.stringify(fetchResponse));
result = renderHook(function () { return useHttpClient(); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
request = result.current.request;
return [4 /*yield*/, request({
requestOptions: { maxAge: 6000 },
})];
case 1:
res1 = _b.sent();
expect(res1).toEqual(fetchResponse);
fetchCalls = fetch.mock.calls;
expect(fetchCalls.length).toBe(1);
_a = fetchCalls[0], fetchUrl = _a[0], fetchParams = _a[1];
expect(fetchUrl).toBe('/');
expect(fetchParams).toEqual(__assign(__assign({}, defaultHttpReqConfig.reqOptions), { method: HttpMethod.Get, body: null, credentials: undefined, maxAge: 6000, signal: undefined, queryParams: undefined }));
return [4 /*yield*/, request({})];
case 2:
res2 = _b.sent();
expect(res2).toEqual(fetchResponse);
expect(fetch.mock.calls.length).toBe(1);
return [2 /*return*/];
}
});
}); });
test('should allow to abort a request', function () { return __awaiter(void 0, void 0, void 0, function () {
var result, abortableRequest, _a, requestPromise, abortController, error_3, fetchCalls, _b, fetchUrl, fetchParams;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
fetch.mockAbortOnce();
result = renderHook(function () { return useHttpClient(); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
abortableRequest = result.current.abortableRequest;
_a = abortableRequest({
relativeUrl: 'posts',
}), requestPromise = _a[0], abortController = _a[1];
_c.label = 1;
case 1:
_c.trys.push([1, 3, , 4]);
abortController.abort();
return [4 /*yield*/, requestPromise];
case 2:
_c.sent();
return [3 /*break*/, 4];
case 3:
error_3 = _c.sent();
expect(error_3).toBeInstanceOf(HttpError);
expect(error_3.status).toBeUndefined();
expect(error_3.statsuText).toBeUndefined();
expect(error_3.response).toBeUndefined();
expect(error_3.message.trim()).toBe('The operation was aborted.');
expect(error_3.request.url).toBe('/posts');
expect(error_3.nativeError.name).toBe('AbortError');
fetchCalls = fetch.mock.calls;
expect(fetchCalls.length).toBe(1);
_b = fetchCalls[0], fetchUrl = _b[0], fetchParams = _b[1];
expect(fetchUrl).toBe('/posts');
expect(fetchParams).toEqual(__assign(__assign({}, defaultHttpReqConfig.reqOptions), { method: HttpMethod.Get, body: null, credentials: undefined, maxAge: 0, signal: abortController.signal, queryParams: undefined }));
return [3 /*break*/, 4];
case 4: return [2 /*return*/];
}
});
}); });
test('should perform a post request', function () { return __awaiter(void 0, void 0, void 0, function () {
var result, post, postBody, res1, fetchCalls, _a, fetchUrl, fetchParams;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
fetch.mockResponseOnce('');
result = renderHook(function () { return useHttpClient(); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
post = result.current.post;
postBody = { body: { name: 'Rico' } };
return [4 /*yield*/, post({
requestOptions: postBody,
parser: function (fetchRes) {
return fetchRes.text();
},
})];
case 1:
res1 = _b.sent();
expect(res1).toBe('');
fetchCalls = fetch.mock.calls;
expect(fetchCalls.length).toBe(1);
_a = fetchCalls[0], fetchUrl = _a[0], fetchParams = _a[1];
expect(fetchUrl).toBe('/');
expect(fetchParams).toEqual(__assign(__assign({}, defaultHttpReqConfig.reqOptions), { method: HttpMethod.Post, body: JSON.stringify(postBody.body), credentials: undefined, maxAge: 0, signal: undefined, queryParams: undefined }));
return [2 /*return*/];
}
});
}); });
test('should perform a patch request', function () { return __awaiter(void 0, void 0, void 0, function () {
var result, patch, patchBody, res1, fetchCalls, _a, fetchUrl, fetchParams;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
fetch.mockResponseOnce('');
result = renderHook(function () { return useHttpClient(); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
patch = result.current.patch;
patchBody = { body: { name: 'Rico' } };
return [4 /*yield*/, patch({
requestOptions: patchBody,
parser: function (fetchRes) {
return fetchRes.text();
},
})];
case 1:
res1 = _b.sent();
expect(res1).toBe('');
fetchCalls = fetch.mock.calls;
expect(fetchCalls.length).toBe(1);
_a = fetchCalls[0], fetchUrl = _a[0], fetchParams = _a[1];
expect(fetchUrl).toBe('/');
expect(fetchParams).toEqual(__assign(__assign({}, defaultHttpReqConfig.reqOptions), { method: HttpMethod.Patch, body: JSON.stringify(patchBody.body), credentials: undefined, maxAge: 0, signal: undefined, queryParams: undefined }));
return [2 /*return*/];
}
});
}); });
test('should perform a put request', function () { return __awaiter(void 0, void 0, void 0, function () {
var result, put, putBody, res1, fetchCalls, _a, fetchUrl, fetchParams;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
fetch.mockResponseOnce('');
result = renderHook(function () { return useHttpClient(); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
put = result.current.put;
putBody = { body: { name: 'Rico' } };
return [4 /*yield*/, put({
requestOptions: putBody,
parser: function (fetchRes) {
return fetchRes.text();
},
})];
case 1:
res1 = _b.sent();
expect(res1).toBe('');
fetchCalls = fetch.mock.calls;
expect(fetchCalls.length).toBe(1);
_a = fetchCalls[0], fetchUrl = _a[0], fetchParams = _a[1];
expect(fetchUrl).toBe('/');
expect(fetchParams).toEqual(__assign(__assign({}, defaultHttpReqConfig.reqOptions), { method: HttpMethod.Put, body: JSON.stringify(putBody.body), credentials: undefined, maxAge: 0, signal: undefined, queryParams: undefined }));
return [2 /*return*/];
}
});
}); });
test('should perform a delete request', function () { return __awaiter(void 0, void 0, void 0, function () {
var result, deleteReq, res1, fetchCalls, _a, fetchUrl, fetchParams;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
fetch.mockResponseOnce('');
result = renderHook(function () { return useHttpClient(); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
deleteReq = result.current.deleteReq;
return [4 /*yield*/, deleteReq({
relativeUrl: 'posts/1',
parser: function (fetchRes) {
return fetchRes.text();
},
})];
case 1:
res1 = _b.sent();
expect(res1).toBe('');
fetchCalls = fetch.mock.calls;
expect(fetchCalls.length).toBe(1);
_a = fetchCalls[0], fetchUrl = _a[0], fetchParams = _a[1];
expect(fetchUrl).toBe('/posts/1');
expect(fetchParams).toEqual(__assign(__assign({}, defaultHttpReqConfig.reqOptions), { method: HttpMethod.Delete, body: null, credentials: undefined, maxAge: 0, signal: undefined, queryParams: undefined }));
return [2 /*return*/];
}
});
}); });
test('should perform a get request', function () { return __awaiter(void 0, void 0, void 0, function () {
var result, get, res1, fetchCalls, _a, fetchUrl, fetchParams;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
fetch.mockResponseOnce(JSON.stringify(fetchResponse));
result = renderHook(function () { return useHttpClient(); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
get = result.current.get;
return [4 /*yield*/, get({
relativeUrl: 'posts/1',
})];
case 1:
res1 = _b.sent();
expect(res1).toEqual(fetchResponse);
fetchCalls = fetch.mock.calls;
expect(fetchCalls.length).toBe(1);
_a = fetchCalls[0], fetchUrl = _a[0], fetchParams = _a[1];
expect(fetchUrl).toBe('/posts/1');
expect(fetchParams).toEqual(__assign(__assign({}, defaultHttpReqConfig.reqOptions), { method: HttpMethod.Get, body: null, credentials: undefined, maxAge: 0, signal: undefined, queryParams: undefined }));
return [2 /*return*/];
}
});
}); });
test('should perform an abortable get request', function () { return __awaiter(void 0, void 0, void 0, function () {
var result, abortableGet, _a, requestPromise, abortController, error_4, fetchCalls, _b, fetchUrl, fetchParams;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
fetch.mockAbortOnce();
result = renderHook(function () { return useHttpClient(); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
abortableGet = result.current.abortableGet;
_a = abortableGet({
relativeUrl: 'posts',
}), requestPromise = _a[0], abortController = _a[1];
_c.label = 1;
case 1:
_c.trys.push([1, 3, , 4]);
abortController.abort();
return [4 /*yield*/, requestPromise];
case 2:
_c.sent();
return [3 /*break*/, 4];
case 3:
error_4 = _c.sent();
expect(error_4).toBeInstanceOf(HttpError);
expect(error_4.status).toBeUndefined();
expect(error_4.statusText).toBeUndefined();
expect(error_4.response).toBeUndefined();
expect(error_4.message.trim()).toBe('The operation was aborted.');
expect(error_4.request.url).toBe('/posts');
expect(error_4.nativeError.name).toBe('AbortError');
fetchCalls = fetch.mock.calls;
expect(fetchCalls.length).toBe(1);
_b = fetchCalls[0], fetchUrl = _b[0], fetchParams = _b[1];
expect(fetchUrl).toBe('/posts');
expect(fetchParams).toEqual(__assign(__assign({}, defaultHttpReqConfig.reqOptions), { method: HttpMethod.Get, body: null, credentials: undefined, maxAge: 0, signal: abortController.signal, queryParams: undefined }));
return [3 /*break*/, 4];
case 4: return [2 /*return*/];
}
});
}); });
test('should perform an abortable post request', function () { return __awaiter(void 0, void 0, void 0, function () {
var result, fetchBody, abortablePost, _a, requestPromise, abortController, error_5, fetchCalls, _b, fetchUrl, fetchParams;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
fetch.mockAbortOnce();
result = renderHook(function () { return useHttpClient(); }, {
wrapper: HttpClientProviderConfigFixture.create(),
}).result;
fetchBody = { title: 'The post title' };
abortablePost = result.current.abortablePost;
_a = abortablePost({
requestOptions: { body: fetchBody },
relativeUrl: 'posts/1',
}), requestPromise = _a[0], abortController = _a[1];
_c.label = 1;
case 1:
_c.trys.push([1, 3, , 4]);
abortController.abort();
return [4 /*yield*/, requestPromise];
case 2:
_c.sent();
return [3 /*break*/, 4];
case 3:
error_5 = _c.sent();
expect(error_5).toBeInstanceOf(HttpError);
expect(error_5.status).toBeUndefined();
expect(error_5.statusText).toBeUndefined();
expect(error_5.response).toBeUndefined();
expect(error_5.message.trim()).toBe('The operation was aborted.');
expect(error_5.request.url).toBe('/posts/1');
expect(error_5.nativeError.name).toBe('AbortError');
fetchCalls = fetch.mock.calls;
expect(fetchCalls.length).toBe(1);
_b = fetchCalls[0], fetchUrl = _b[0], fetchParams = _b[1];
expect(fetchUrl).toBe('/posts/1');
expect(fetchParams).toEqual(__assign(__assign({}, defaultHttpReqConfig.reqOptions), { method: HttpMethod.Post, body: JSON.stringify(fetchBody), credentials: undefined, maxAge: 0, signal: abortController.signal, queryParams: undefined }));
return [3 /*break*/, 4];
case 4: return [2 /*return*/];
}
});
}); });
});