Handle rejections properly

wojtekmaj · wojtekmaj · commit 96511b1ec48e · 2022-05-05T21:08:18.000+02:00
diff --git a/src/every.js b/src/every.js
@@ -2,25 +2,32 @@ import asyncForEach from './forEach';
 
 export default function asyncSome(arr, fn) {
   let resolved;
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
     asyncForEach(
       arr,
       (cur, idx, arr2) =>
-        new Promise((resolve2) => {
+        new Promise((resolve2, reject2) => {
           if (resolved) {
             return;
           }
-          fn(cur, idx, arr2).then((result) => {
-            if (!result) {
-              resolve(false);
-              resolved = true;
-            }
-            resolve2();
-          });
+          fn(cur, idx, arr2)
+            .then((result) => {
+              if (!result) {
+                resolve(false);
+                resolved = true;
+              }
+              resolve2();
+            })
+            .catch(reject2);
         }),
-    ).then(() => {
-      resolve(true);
-      resolved = true;
-    });
+    )
+      .then(() => {
+        resolve(true);
+        resolved = true;
+      })
+      .catch((error) => {
+        reject(error);
+        resolved = true;
+      });
   });
 }
diff --git a/src/every.spec.js b/src/every.spec.js
@@ -6,6 +6,7 @@ import {
   largerThanOneHundred,
   largerThanOneHundredInRandomTime,
   makeDelayed,
+  throws,
 } from '../test-utils';
 
 function largerOrEqualThanZero(x) {
@@ -102,4 +103,16 @@ describe('asyncEvery()', () => {
 
     expect(result).toEqual(false);
   });
+
+  it.skip('assertions below are valid for synchronous .every()', () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    expect(() => inputArr.every(mapper)).toThrow('Some error');
+  });
+
+  it('throws if function passed throws', async () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    await expect(() => asyncEvery(inputArr, mapper)).rejects.toThrow('Some error');
+  });
 });
diff --git a/src/every_strict.js b/src/every_strict.js
@@ -2,25 +2,32 @@ import asyncForEachStrict from './forEach_strict';
 
 export default function asyncEveryStrict(arr, fn) {
   let resolved;
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
     asyncForEachStrict(
       arr,
       (cur, idx, arr2) =>
-        new Promise((resolve2) => {
+        new Promise((resolve2, reject2) => {
           if (resolved) {
             return;
           }
-          fn(cur, idx, arr2).then((result) => {
-            if (!result) {
-              resolve(false);
-              resolved = true;
-            }
-            resolve2();
-          });
+          fn(cur, idx, arr2)
+            .then((result) => {
+              if (!result) {
+                resolve(false);
+                resolved = true;
+              }
+              resolve2();
+            })
+            .catch(reject2);
         }),
-    ).then(() => {
-      resolve(true);
-      resolved = true;
-    });
+    )
+      .then(() => {
+        resolve(true);
+        resolved = true;
+      })
+      .catch((error) => {
+        reject(error);
+        resolved = true;
+      });
   });
 }
diff --git a/src/every_strict.spec.js b/src/every_strict.spec.js
@@ -9,6 +9,7 @@ import {
   makeDelayed,
   makePushDuplicate,
   makePushDuplicateInRandomTime,
+  throws,
 } from '../test-utils';
 
 function largerOrEqualThanZero(x) {
@@ -137,4 +138,16 @@ describe('asyncEveryStrict()', () => {
 
     expect(result).toEqual(false);
   });
+
+  it.skip('assertions below are valid for synchronous .every()', () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    expect(() => inputArr.every(mapper)).toThrow('Some error');
+  });
+
+  it('throws if function passed throws', async () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    await expect(() => asyncEveryStrict(inputArr, mapper)).rejects.toThrow('Some error');
+  });
 });
diff --git a/src/filter.js b/src/filter.js
@@ -6,13 +6,15 @@ export default function asyncSome(arr, fn) {
   return asyncForEach(
     arr,
     (cur, idx, arr2) =>
-      new Promise((resolve) => {
-        fn(cur, idx, arr2).then((cond) => {
-          if (cond) {
-            result[idx] = cur;
-          }
-          resolve();
-        });
+      new Promise((resolve, reject) => {
+        fn(cur, idx, arr2)
+          .then((cond) => {
+            if (cond) {
+              result[idx] = cur;
+            }
+            resolve();
+          })
+          .catch(reject);
       }),
   ).then(() => result.filter((cur, idx) => idx in result));
 }
diff --git a/src/filter.spec.js b/src/filter.spec.js
@@ -6,6 +6,7 @@ import {
   largerThanTwo,
   largerThanTwoInRandomTime,
   makeDelayed,
+  throws,
 } from '../test-utils';
 
 describe('asyncFilter()', () => {
@@ -74,4 +75,16 @@ describe('asyncFilter()', () => {
 
     expect(result).toEqual([3, 4, 5, 6, 7, 8, 9, 10]);
   });
+
+  it.skip('assertions below are valid for synchronous .filter()', () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    expect(() => inputArr.filter(mapper)).toThrow('Some error');
+  });
+
+  it('throws if function passed throws', async () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    await expect(() => asyncFilter(inputArr, mapper)).rejects.toThrow('Some error');
+  });
 });
diff --git a/src/filter_strict.js b/src/filter_strict.js
@@ -6,13 +6,15 @@ export default function asyncFilterStrict(arr, fn) {
   return asyncForEachStrict(
     arr,
     (cur, idx, arr2) =>
-      new Promise((resolve) => {
-        fn(cur, idx, arr2).then((cond) => {
-          if (cond) {
-            result[idx] = cur;
-          }
-          resolve();
-        });
+      new Promise((resolve, reject) => {
+        fn(cur, idx, arr2)
+          .then((cond) => {
+            if (cond) {
+              result[idx] = cur;
+            }
+            resolve();
+          })
+          .catch(reject);
       }),
   ).then(() => result.filter((cur, idx) => idx in result));
 }
diff --git a/src/filter_strict.spec.js b/src/filter_strict.spec.js
@@ -9,6 +9,7 @@ import {
   makeDelayed,
   makePushDuplicate,
   makePushDuplicateInRandomTime,
+  throws,
 } from '../test-utils';
 
 describe('asyncFilterStrict()', () => {
@@ -68,7 +69,7 @@ describe('asyncFilterStrict()', () => {
     });
   });
 
-  it.skip('assertions below are valid for synchronous .map()', () => {
+  it.skip('assertions below are valid for synchronous .filter()', () => {
     const [arr, pushDuplicate] = makePushDuplicate();
     const mapper = jest.fn().mockImplementation(pushDuplicate);
 
@@ -103,4 +104,16 @@ describe('asyncFilterStrict()', () => {
 
     expect(result).toEqual([3, 4, 5, 6, 7, 8, 9, 10]);
   });
+
+  it.skip('assertions below are valid for synchronous .filter()', () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    expect(() => inputArr.filter(mapper)).toThrow('Some error');
+  });
+
+  it('throws if function passed throws', async () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    await expect(() => asyncFilterStrict(inputArr, mapper)).rejects.toThrow('Some error');
+  });
 });
diff --git a/src/forEach.js b/src/forEach.js
@@ -1,7 +1,9 @@
 import asyncMap from './map';
 
 export default function asyncForEach(arr, fn) {
-  return new Promise((resolve) => {
-    asyncMap(arr, fn).then(() => resolve());
+  return new Promise((resolve, reject) => {
+    asyncMap(arr, fn)
+      .then(() => resolve())
+      .catch(reject);
   });
 }
diff --git a/src/forEach.spec.js b/src/forEach.spec.js
@@ -6,6 +6,7 @@ import {
   makeDelayed,
   makePushDuplicate,
   makePushDuplicateInRandomTime,
+  throws,
 } from '../test-utils';
 
 describe('asyncForEach()', () => {
@@ -85,4 +86,16 @@ describe('asyncForEach()', () => {
 
     expect(result).toBe(undefined);
   });
+
+  it.skip('assertions below are valid for synchronous .forEach()', () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    expect(() => inputArr.forEach(mapper)).toThrow('Some error');
+  });
+
+  it('throws if function passed throws', async () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    await expect(() => asyncForEach(inputArr, mapper)).rejects.toThrow('Some error');
+  });
 });
diff --git a/src/forEach_strict.js b/src/forEach_strict.js
@@ -1,7 +1,9 @@
 import asyncMapStrict from './map_strict';
 
 export default function asyncForEachStrict(arr, fn) {
-  return new Promise((resolve) => {
-    asyncMapStrict(arr, fn).then(() => resolve());
+  return new Promise((resolve, reject) => {
+    asyncMapStrict(arr, fn)
+      .then(() => resolve())
+      .catch(reject);
   });
 }
diff --git a/src/forEach_strict.spec.js b/src/forEach_strict.spec.js
@@ -6,6 +6,7 @@ import {
   makeDelayed,
   makePushDuplicate,
   makePushDuplicateInRandomTime,
+  throws,
 } from '../test-utils';
 
 describe('asyncForEachStrict()', () => {
@@ -109,4 +110,16 @@ describe('asyncForEachStrict()', () => {
 
     expect(result).toBe(undefined);
   });
+
+  it.skip('assertions below are valid for synchronous .forEach()', () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    expect(() => inputArr.forEach(mapper)).toThrow('Some error');
+  });
+
+  it('throws if function passed throws', async () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    await expect(() => asyncForEachStrict(inputArr, mapper)).rejects.toThrow('Some error');
+  });
 });
diff --git a/src/map.js b/src/map.js
@@ -1,3 +1,5 @@
 export default function asyncMap(arr, fn) {
-  return Promise.all(arr.map(fn));
+  return new Promise((resolve, reject) => {
+    Promise.all(arr.map(fn)).then(resolve).catch(reject);
+  });
 }
diff --git a/src/map.spec.js b/src/map.spec.js
@@ -7,6 +7,7 @@ import {
   getTimer,
   inputArr,
   makeDelayed,
+  throws,
 } from '../test-utils';
 
 describe('asyncMap()', () => {
@@ -75,4 +76,16 @@ describe('asyncMap()', () => {
 
     expect(result).toEqual(doubleInputArr);
   });
+
+  it.skip('assertions below are valid for synchronous .map()', () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    expect(() => inputArr.map(mapper)).toThrow('Some error');
+  });
+
+  it('throws if function passed throws', async () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    await expect(() => asyncMap(inputArr, mapper)).rejects.toThrow('Some error');
+  });
 });
diff --git a/src/map_strict.js b/src/map_strict.js
@@ -1,5 +1,5 @@
 export default function asyncMapStrict(arr, fn) {
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
     const result = [];
     arr
       .reduce(
@@ -11,6 +11,7 @@ export default function asyncMapStrict(arr, fn) {
           ),
         Promise.resolve(),
       )
-      .then(() => resolve(result));
+      .then(() => resolve(result))
+      .catch(reject);
   });
 }
diff --git a/src/map_strict.spec.js b/src/map_strict.spec.js
@@ -9,6 +9,7 @@ import {
   makeDelayed,
   makePushDuplicate,
   makePushDuplicateInRandomTime,
+  throws,
 } from '../test-utils';
 
 describe('asyncMapStrict()', () => {
@@ -103,4 +104,16 @@ describe('asyncMapStrict()', () => {
 
     expect(result).toEqual(doubleInputArr);
   });
+
+  it.skip('assertions below are valid for synchronous .map()', () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    expect(() => inputArr.map(mapper)).toThrow('Some error');
+  });
+
+  it('throws if function passed throws', async () => {
+    const mapper = jest.fn().mockImplementation(throws);
+
+    await expect(() => asyncMapStrict(inputArr, mapper)).rejects.toThrow('Some error');
+  });
 });
diff --git a/src/reduce.js b/src/reduce.js
diff --git a/src/reduce.spec.js b/src/reduce.spec.js
diff --git a/src/some.js b/src/some.js
diff --git a/src/some.spec.js b/src/some.spec.js
diff --git a/src/some_strict.js b/src/some_strict.js
diff --git a/src/some_strict.spec.js b/src/some_strict.spec.js
diff --git a/test-utils.js b/test-utils.js
