Wrote flat map function and test

Author: JoelCodes

answers/chaining-promises.js

@@ -1,2 +1,24 @@
+/**
+ * 
+ * EXERCISE 1
+ * 
+ * Just as we did with mapPromise, we want to envision a new way of transforming promises: chaining them.  We want to be able to have one promise resolve, then when it's done, use its value to start a second async process that returns a promise.
+ * 
+ * WE DON'T WANT TO START THAT SECOND PROCESS UNTIL AFTER THAT FIRST PROCESS RESOLVES!  In this way, we can imagine that we may need some artifact from the first process before we can start the second.  For instance, we may want to create a User object in a database, get an id back, and then use that UserId to create a series of, say, services that this user can access.
+ * 
+ * This chaining is a common problem in async, so let's create a function to do this.
+ * 
+ * @param {Promise} promise 
+ * @param {*} asyncTransformer 
+ */
+function flatMapPromise(promise, asyncTransformer){
+  return new Promise((resolve, reject) => {
+    promise
+      .then(/* IMPLEMENT ME! */);
+  });
+}
 
-module.exports = {};
+
+module.exports = {
+  flatMapPromise,
+};

test/chaining-promises.test.js

@@ -1,4 +1,38 @@
 /* eslint-env mocha */
 
 const assert = require('assert');
-const {} = require('../answers/chaining-promises.js');
+const {flatMapPromise} = require('../answers/chaining-promises.js');
+
+describe('Chaining Promises with .then(cb) and .catch(cb)', () => {
+  describe('#flatMapPromise(promise, asyncTransformer) => Promise', () => {
+    context('If the first promise resolves', () => {
+      const firstPromise = Promise.resolve(3);
+      it('resolves with the value of the second promise', () => {
+        const resolveAndSquare = (val) => Promise.resolve(val * val);
+        return flatMapPromise(firstPromise, resolveAndSquare)
+          .then((val) => {
+            assert.equal(val, 9);
+          });
+      });
+      it('rejects with the error of the second promise', () => {
+        const freakOut = (val) => Promise.reject(`Boo! ${val}`);
+        return flatMapPromise(firstPromise, freakOut)
+          .then((val) => {
+            assert.fail(`This should not have resolved!  It resolved with ${val}`);
+          }, (err) => {
+            assert.equal(err, 'Boo! 3');
+          });
+      });  
+    });
+    context('If the first promise rejects', () => {
+      it('rejects with the error of the first promise', () => {
+        return flatMapPromise(Promise.reject('Boo!'), (val) => Promise.reject(val))
+          .then((val) => {
+            assert.fail(`This should not have resolved!  It resolved with ${val}`);
+          }, (err) => {
+            assert.equal(err, 'Boo!');
+          });
+      });
+    });
+  });
+});