Cancel group of requests (+ remastered requests management)

README.md

@@ -85,7 +85,45 @@ const promise2 = axios.get(url, {
 // logs `resolved promise 2`
 ```
 
-Multiple requests with different `requestId`, cancell all
+Multiple requests with same `requestGroup`, cancel all
+```javascript
+...
+
+const requestGroup = 'my_sample_request_group_1';
+const promise1 = axios.get(url, {
+  requestGroup: requestGroup
+})
+  .then((res) => {
+    console.log('resolved promise 1');
+  }).catch((thrown) => {
+    if (axios.isCancel(thrown)) {
+      console.log('request 1 cancelled');
+    } else {
+      console.log('some other reason');
+    }
+  });
+
+const promise2 = axios.get(url, {
+  requestGroup: requestGroup
+})
+  .then((res) => {
+    console.log('resolved promise 2');
+  }).catch((thrown) => {
+    if (axios.isCancel(thrown)) {
+      console.log('request 2 cancelled');
+    } else {
+      console.log('some other reason');
+    }
+  });
+
+axios.cancel(requestGroup);
+
+// aborts all HTTP requests with same `requestGroup`, and cancels all promises
+// logs `request 1 cancelled`
+// logs `request 2 cancelled`
+```
+
+Multiple requests with different `requestId`, cancel all
 ```javascript
 ...
 
@@ -108,7 +146,7 @@ const promise2 = axios.get(url, {
   requestId: requestId2
 })
   .then((res) => {
-    console.log('resolved promise 1');
+    console.log('resolved promise 2');
   }).catch((thrown) => {
     if (axios.isCancel(thrown)) {
       console.log('request 2 cancelled');
@@ -132,7 +170,7 @@ axios.cancelAll();
 *options*
 - debug _(enables logging)_
 
-*axios.cancel(requestId: string[, reason: string])*
+*axios.cancel(requestId[requestGroup]: string[, reason: string])*
 
 *axios.cancelAll([reason: string])*
 

__tests__/request-manager.test.js

@@ -2,88 +2,93 @@ import RequestManager from '../lib/RequestManager';
 
 describe('RequestManager', () => {
   let requestManager;
+  const requestId = 'REQUEST_ID'
+  const requestGroup = 'REQUEST_GROUP'
 
   beforeEach(() => {
     requestManager = new RequestManager();
   });
 
   test('adds a request', () => {
-    const reqId = 'request_id';
+    requestManager.addRequest({requestId});
 
-    requestManager.addRequest(reqId, () => { });
-    expect(requestManager.has(reqId)).toBeTruthy();
+    expect(requestManager.has(requestId)).toBeTruthy();
   });
 
   test('removes a request', () => {
-    const reqId = 'request_id';
 
-    requestManager.addRequest(reqId, () => { });
-    expect(requestManager.has(reqId)).toBeTruthy();
-
-    requestManager.removeRequest(reqId);
-    expect(requestManager.has(reqId)).toBeFalsy();
+    requestManager.addRequest({requestId});
+    expect(requestManager.has(requestId)).toBeTruthy();
+
+    requestManager.removeRequest(requestId);
+    expect(requestManager.has(requestId)).toBeFalsy();
+  });
+
+  test('cancels a request with `requestId`', () => {
+    const cancelFn = jest.fn();
+
+    requestManager.addRequest({requestId, cancel: cancelFn});
+    requestManager.cancelRequest(requestId);
+    expect(cancelFn).toHaveBeenCalled();
+    expect(requestManager.has(requestId)).toBeFalsy();
   });
 
-  test('cancels a request', () => {
+  test('cancels a request with `requestGroup`', () => {
     const cancelFn = jest.fn();
-    const reqId = 'request_id';
 
-    requestManager.addRequest(reqId, cancelFn);
-    requestManager.cancelRequest(reqId);
+    requestManager.addRequest({requestGroup, cancel: cancelFn});
+    requestManager.cancelRequest(requestGroup);
     expect(cancelFn).toHaveBeenCalled();
-    expect(requestManager.has(reqId)).toBeFalsy();
+    expect(requestManager.has(requestGroup)).toBeFalsy();
   });
 
   test('cancels a request with default `reason` message', () => {
     const cancelFn = jest.fn();
-    const reqId = 'request_id';
-    const reason = `\`cancelRequest(${reqId})\` from \`RequestManager.cancelRequest\``;
+    const reason = `\`cancelRequest(${requestId})\` from \`RequestManager.cancelRequest\``;
 
-    requestManager.addRequest(reqId, cancelFn);
-    requestManager.cancelRequest(reqId);
+    requestManager.addRequest({requestId, cancel: cancelFn});
+    requestManager.cancelRequest(requestId);
     expect(cancelFn).toHaveBeenCalledWith(reason);
   });
 
   test('cancels a request with custom `reason` message', () => {
     const cancelFn = jest.fn();
-    const reqId = 'request_id';
     const reason = `some reason`;
 
-    requestManager.addRequest(reqId, cancelFn);
-    requestManager.cancelRequest(reqId, reason);
+    requestManager.addRequest({requestId, cancel: cancelFn});
+    requestManager.cancelRequest(requestId, reason);
     expect(cancelFn).toHaveBeenCalledWith(reason);
   });
 
 
   test('cancels the precedent request if same `requestId` is sent before removal', () => {
     const cancelFn1 = jest.fn();
     const cancelFn2 = jest.fn();
-    const reqId = 'request_id';
 
-    requestManager.addRequest(reqId, cancelFn1);
-    requestManager.addRequest(reqId, cancelFn2);
+    requestManager.addRequest({ requestId, cancel: cancelFn1 });
+    requestManager.addRequest({ requestId, cancel: cancelFn2 });
     expect(cancelFn1).toHaveBeenCalled();
 
-    requestManager.cancelRequest(reqId);
+    requestManager.cancelRequest(requestId);
     expect(cancelFn2).toHaveBeenCalled();
   });
 
   test('cancels all requests', () => {
     const cancelFn1 = jest.fn();
     const cancelFn2 = jest.fn();
     const cancelFn3 = jest.fn();
-    const reqId1 = 'request_id_1';
-    const reqId2 = 'request_id_2';
-    const reqId3 = 'request_id_3';
-
-    requestManager.addRequest(reqId1, cancelFn1);
-    requestManager.addRequest(reqId2, cancelFn2);
-    requestManager.addRequest(reqId3, cancelFn3);
-    
+    const reqId1 = 'REQUEST_ID_1';
+    const reqId2 = 'REQUEST_ID_2';
+    const reqId3 = 'REQUEST_ID_3';
+
+    requestManager.addRequest({ requestId: reqId1, cancel: cancelFn1 });
+    requestManager.addRequest({ requestId: reqId2, cancel: cancelFn2 });
+    requestManager.addRequest({ requestId: reqId3, cancel: cancelFn3 });
+
     requestManager.cancelAllRequests();
 
-    expect(cancelFn1).toHaveBeenCalled();
-    expect(cancelFn2).toHaveBeenCalled();
-    expect(cancelFn3).toHaveBeenCalled();
+    expect(cancelFn1).toHaveBeenCalledWith(`\`cancelRequest(${reqId1})\` from \`RequestManager.cancelAllRequests\``);
+    //expect(cancelFn2).toHaveBeenCalledWith(`\`cancelRequest(${reqId2})\` from \`RequestManager.cancelAllRequests\``);
+    expect(cancelFn3).toHaveBeenCalledWith(`\`cancelRequest(${reqId3})\` from \`RequestManager.cancelAllRequests\``);
   });
-});
+});

__tests__/test.js

@@ -28,11 +28,25 @@ describe('axios cancel', () => {
       });
   });
 
-  test('request with requestId', () => {
+  test('request with `requestId`', () => {
 
     const requestId = 'request_id';
     return axios.get(url, {
-      requestId: requestId
+      requestId
+    })
+      .then((res) => {
+        const {data} = res;
+        expect(data.users).toBeTruthy();
+      }).catch((thrown) => {
+        expect(thrown).toBeNull();
+      });
+  });
+
+  test('request with `requestGroup`', () => {
+
+    const requestGroup = 'request_group';
+    return axios.get(url, {
+      requestGroup
     })
       .then((res) => {
         const {data} = res;
@@ -42,7 +56,7 @@ describe('axios cancel', () => {
       });
   });
 
-  test('cancel a single request with requestId', () => {
+  test('cancel a single request with `requestId`', () => {
 
     const successCallback = jest.fn();
     const cancelCallback = jest.fn();
@@ -63,7 +77,41 @@ describe('axios cancel', () => {
     return promise;
   });
 
-  test('validate that cancellation err is of type axios.Cancel', () => {
+  test('cancel group of requests with `requestGroup`', () => {
+
+    const successCallback1 = jest.fn();
+    const cancelCallback1 = jest.fn();
+
+    const successCallback2 = jest.fn();
+    const cancelCallback2 = jest.fn();
+
+    const requestGroup = 'request_group';
+
+    axios.get(url, {
+      requestGroup
+    })
+      .then(successCallback1)
+      .catch(cancelCallback1);
+
+    const promise = axios.get(url, {
+      requestGroup
+    })
+      .then(successCallback2)
+      .catch(cancelCallback2);
+
+    setTimeout(() => {
+      axios.cancel(requestGroup);
+      expect(successCallback1).not.toHaveBeenCalled();
+      expect(cancelCallback1).toHaveBeenCalled();
+
+      expect(successCallback2).not.toHaveBeenCalled();
+      expect(cancelCallback2).toHaveBeenCalled();
+    }, 100);
+
+    return promise;
+  });
+
+  test('validate that cancellation err is of type `axios.Cancel`', () => {
     const requestId = 'request_id';
     const promise = axios.get(url, {
       requestId: requestId
@@ -110,18 +158,52 @@ describe('axios cancel', () => {
     return promise;
   });
 
+  test('do not cancel a request with subsequent requests with same `requestGroup`', () => {
+
+    const successCallback1 = jest.fn();
+    const successCallback2 = jest.fn();
+    const cancelCallback1 = jest.fn();
+    const cancelCallback2 = jest.fn();
+
+    const requestGroup = 'request_group';
+    axios.get(url, {
+      requestGroup
+    })
+      .then(successCallback1)
+      .catch(cancelCallback1);
+
+    const promise = axios.get(url, {
+      requestGroup
+    })
+      .then(successCallback2)
+      .catch(cancelCallback2);
+
+    setTimeout(() => {
+      expect(successCallback1).toHaveBeenCalled();
+      expect(cancelCallback1).not.toHaveBeenCalled();
+
+      expect(successCallback2).toHaveBeenCalled();
+      expect(cancelCallback2).not.toHaveBeenCalled();
+    }, 100);
+
+    return promise;
+  });
+
   test('cancel all requests', () => {
 
     const successCallback1 = jest.fn();
     const successCallback2 = jest.fn();
     const successCallback3 = jest.fn();
+    const successCallback4 = jest.fn();
     const cancelCallback1 = jest.fn();
     const cancelCallback2 = jest.fn();
     const cancelCallback3 = jest.fn();
+    const cancelCallback4 = jest.fn();
 
     const requestId1 = 'request_id_1';
     const requestId2 = 'request_id_2';
     const requestId3 = 'request_id_3';
+    const requestGroup = 'request_group'
 
     axios.get(url, {
       requestId: requestId1
@@ -135,12 +217,18 @@ describe('axios cancel', () => {
       .then(successCallback2)
       .catch(cancelCallback2);
 
-    const promise = axios.get(url, {
+    axios.get(url, {
       requestId: requestId3
     })
       .then(successCallback3)
       .catch(cancelCallback3);
 
+    const promise = axios.get(url, {
+      requestGroup
+    })
+      .then(successCallback4)
+      .catch(cancelCallback4);
+
     setTimeout(() => {
 
       axios.cancelAll();
@@ -153,6 +241,9 @@ describe('axios cancel', () => {
 
       expect(successCallback3).not.toHaveBeenCalled();
       expect(cancelCallback3).toHaveBeenCalled();
+
+      expect(successCallback4).not.toHaveBeenCalled();
+      expect(cancelCallback4).toHaveBeenCalled();
     }, 100);
 
     return promise;