Merge pull request #26 from XbyOrange/test-sources-catch

javierbrea · web-flow · commit c11e7c83d091 · 2019-10-14T08:32:08.000+02:00
Test sources catch
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -14,8 +14,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ## [TO BE DEPRECATED]
 - Last argument of Selectors will stop being assigned as "defaultValue". To define default value, it will be mandatory to pass an options object as last argument, containing a "defaultValue" property.
 
-## [1.3.0] - 2019-10-10
-
+## [1.3.0] - 2019-10-14
+- Add utility for testing catch functions of selector sources.
 
 ## [1.2.0] - 2019-10-14
 ### Added
diff --git a/docs/selector/testing.md b/docs/selector/testing.md
@@ -2,28 +2,40 @@
 
 Selectors provides a test api for making easier developing unit tests.
 
-#### Testing custom queries
+#### Testing selector functions
 
 ```js
-booksCollection.addCustomQuery({
-  myQuery: id => ({
+const mySelector = new Selector({
+  booksCollection
+}, results => results[0]);
+```
+
+```js
+expect(mySelector.test.selector(["foo"])).toEqual("foo");
+```
+
+#### Testing selector queries
+
+```js
+const mySelector = new Selector({
+  source: booksCollection,
+  query: id => {
     params: {
       id
     }
-  })
-});
-
+  }
+}, result => result);
 ```
 
 ```js
-expect(booksCollection.test.customQueries.myQuery("foo")).toEqual({
+expect(mySelector.test.queries[0]("foo")).toEqual({
   params: {
     id: "foo"
   }
 });
 ```
 
-#### Testing selector queries
+#### Testing selector sources "catch" methods
 
 ```js
 const mySelector = new Selector({
@@ -32,26 +44,77 @@ const mySelector = new Selector({
     params: {
       id
     }
-  }
+  },
+  catch: err => err.message
 }, result => result);
 ```
 
 ```js
-expect(mySelector.test.queries[0]("foo")).toEqual({
+expect(mySelector.test.catches[0](new Error("foo"))).toEqual("foo");
+```
+
+#### Testing selector queries and catches when sources are concurrent
+
+For concurrent sources, testing objects will be exposed inside an array in the same order than sources are declared.
+
+```js
+const mySelector = new Selector(
+  [{
+    source: booksCollection,
+    query: id => {
+      params: {
+        bookId
+      }
+    },
+    catch: () => "Error retrieving books";
+  },
+  {
+    source: authorsCollection,
+    query: id => {
+      params: {
+        authorId
+      }
+    },
+    catch: () => "Error retrieving authors";
+  }]
+  , result => result);
+```
+
+```js
+expect(mySelector.test.queries[0][0]("foo")).toEqual({
   params: {
-    id: "foo"
+    bookId: "foo"
+  }
+});
+
+expect(mySelector.test.queries[0][1]("foo")).toEqual({
+  params: {
+    authorId: "foo"
   }
 });
+
+expect(mySelector.test.catches[0][0]()).toEqual("Error retrieving books");
+
+expect(mySelector.test.catches[0][1]()).toEqual("Error retrieving authors");
 ```
 
-#### Testing selector functions
+#### Testing custom queries
 
 ```js
-const mySelector = new Selector({
-  booksCollection
-}, results => results[0]);
+booksCollection.addCustomQuery({
+  myQuery: id => ({
+    params: {
+      id
+    }
+  })
+});
+
 ```
 
 ```js
-expect(mySelector.test.selector(["foo"])).toEqual("foo");
+expect(booksCollection.test.customQueries.myQuery("foo")).toEqual({
+  params: {
+    id: "foo"
+  }
+});
 ```
diff --git a/src/Selector.js b/src/Selector.js
@@ -35,29 +35,39 @@ export class Selector extends Origin {
 
     const sourceIds = [];
 
-    const getTestQueries = sourcesOfLevel => {
+    const getTestObjects = sourcesOfLevel => {
       const queries = [];
+      const catches = [];
       sourcesOfLevel.forEach(source => {
         if (Array.isArray(source)) {
-          queries.push(getTestQueries(source));
+          const testObjects = getTestObjects(source);
+          queries.push(testObjects.queries);
+          catches.push(testObjects.catches);
         } else {
-          const hasQuery = !!source.source;
-          sourceIds.push(hasQuery ? source.source._id : source._id);
-          if (hasQuery) {
+          const isSourceObject = !!source.source;
+          sourceIds.push(isSourceObject ? source.source._id : source._id);
+          if (isSourceObject && source.query) {
             queries.push(source.query);
           }
+          if (isSourceObject && source.catch) {
+            catches.push(source.catch);
+          }
         }
       });
-      return queries;
+      return {
+        queries,
+        catches
+      };
     };
 
-    const testQueries = getTestQueries(sources);
+    const testObjects = getTestObjects(sources);
 
     super(`select:${sourceIds.join(":")}`, defaultValue, options);
 
     this._sources = sources;
     this._resultsParser = args[lastIndex];
-    this.test.queries = testQueries;
+    this.test.queries = testObjects.queries;
+    this.test.catches = testObjects.catches;
     this.test.selector = this._resultsParser;
   }
 
diff --git a/test/Selector.testMethods.js b/test/Selector.testMethods.js
@@ -15,7 +15,8 @@ test.describe("Selector test methods", () => {
     sandbox = test.sinon.createSandbox();
     spies = {
       query: sandbox.spy(),
-      selector: sandbox.spy()
+      catch: sandbox.spy(),
+      selector: sandbox.stub().callsFake(result => result)
     };
     TestOrigin = class extends Origin {
       _read() {
@@ -29,12 +30,13 @@ test.describe("Selector test methods", () => {
         query: query => {
           spies.query();
           return query;
+        },
+        catch: err => {
+          spies.catch();
+          return err;
         }
       },
-      originResult => {
-        spies.selector();
-        return originResult;
-      }
+      spies.selector
     );
   });
 
@@ -43,15 +45,15 @@ test.describe("Selector test methods", () => {
     sources.clear();
   });
 
-  test.describe("origin query functions", () => {
+  test.describe("sources query functions", () => {
     test.describe("when there are no concurrent queries", () => {
       test.it("should be avaible for testing at the test.queries property", () => {
         test.expect(testSelector.test.queries[0]("foo")).to.equal("foo");
         test.expect(spies.query).to.have.been.called();
       });
     });
 
-    test.describe("when there are concurrent queries", () => {
+    test.describe("when there are concurrent sources", () => {
       test.it("should be avaible for testing at the test.queries property as an array", () => {
         const testOrigin2 = new TestOrigin();
         testSelector = new Selector(
@@ -71,10 +73,7 @@ test.describe("Selector test methods", () => {
               }
             }
           ],
-          originResult => {
-            spies.selector();
-            return originResult;
-          }
+          spies.selector
         );
         test.expect(testSelector.test.queries[0][0]("foo")).to.equal("foo-1");
         test.expect(testSelector.test.queries[0][1]("foo")).to.equal("foo-2");
@@ -110,10 +109,7 @@ test.describe("Selector test methods", () => {
               }
             ]
           ],
-          originResult => {
-            spies.selector();
-            return originResult;
-          }
+          spies.selector
         );
         test.expect(testSelector.test.queries[0][0]("foo")).to.equal("foo-1");
         test.expect(testSelector.test.queries[0][1][0]("foo")).to.equal("foo-2");
@@ -123,6 +119,80 @@ test.describe("Selector test methods", () => {
     });
   });
 
+  test.describe("sources catch functions", () => {
+    test.describe("when there are no concurrent sources", () => {
+      test.it("should be avaible for testing at the test.catches property", () => {
+        test.expect(testSelector.test.catches[0]("foo")).to.equal("foo");
+        test.expect(spies.catch).to.have.been.called();
+      });
+    });
+
+    test.describe("when there are concurrent sources", () => {
+      test.it("should be avaible for testing at the test.catches property as an array", () => {
+        const testOrigin2 = new TestOrigin();
+        testSelector = new Selector(
+          [
+            {
+              source: testOrigin,
+              catch: err => {
+                spies.catch();
+                return `${err}-a`;
+              }
+            },
+            {
+              source: testOrigin2,
+              catch: err => {
+                spies.catch();
+                return `${err}-b`;
+              }
+            }
+          ],
+          spies.selector
+        );
+        test.expect(testSelector.test.catches[0][0]("foo")).to.equal("foo-a");
+        test.expect(testSelector.test.catches[0][1]("foo")).to.equal("foo-b");
+        test.expect(spies.catch).to.have.been.calledTwice();
+      });
+
+      test.it("should have all concurrent catches available recursively", () => {
+        const testOrigin2 = new TestOrigin();
+        const testOrigin3 = new TestOrigin();
+        testSelector = new Selector(
+          [
+            {
+              source: testOrigin,
+              catch: err => {
+                spies.catch();
+                return `${err}-a`;
+              }
+            },
+            [
+              {
+                source: testOrigin2,
+                catch: err => {
+                  spies.catch();
+                  return `${err}-b`;
+                }
+              },
+              {
+                source: testOrigin3,
+                catch: err => {
+                  spies.catch();
+                  return `${err}-c`;
+                }
+              }
+            ]
+          ],
+          spies.selector
+        );
+        test.expect(testSelector.test.catches[0][0]("foo")).to.equal("foo-a");
+        test.expect(testSelector.test.catches[0][1][0]("foo")).to.equal("foo-b");
+        test.expect(testSelector.test.catches[0][1][1]("foo")).to.equal("foo-c");
+        test.expect(spies.catch.callCount).to.equal(3);
+      });
+    });
+  });
+
   test.describe("selector function", () => {
     test.it("should be avaible for testing at the test.selector property", () => {
       test.expect(testSelector.test.selector("foo")).to.equal("foo");
