Fix additional promise methods and expect.it

Author: papandreou

lib/addAdditionalPromiseMethods.js

@@ -1,3 +1,5 @@
+const Context = require('./Context');
+
 function addAdditionalPromiseMethods(promise, expect, subject) {
   promise.and = function (...args) {
     function executeAnd() {
@@ -19,6 +21,47 @@ function addAdditionalPromiseMethods(promise, expect, subject) {
     }
   };
 
+  const camelCaseMethods = expect._camelCaser(expect.context || new Context());
+  Object.keys(camelCaseMethods).forEach((methodName) => {
+    promise[methodName] = function (...args) {
+      function execute(shiftedSubject) {
+        if (expect.findTypeOf(args[0]).is('expect.it')) {
+          return addAdditionalPromiseMethods(
+            args[0](shiftedSubject),
+            expect,
+            subject
+          );
+        } else {
+          return camelCaseMethods[methodName](shiftedSubject)(...args);
+        }
+      }
+
+      if (this.isFulfilled()) {
+        return execute(this.value());
+      } else {
+        return addAdditionalPromiseMethods(this.then(execute), expect, subject);
+      }
+    };
+
+    promise[
+      `and${methodName.replace(/^[a-z]/, ($0) => $0.toUpperCase())}`
+    ] = function (...args) {
+      function execute() {
+        if (expect.findTypeOf(args[0]).is('expect.it')) {
+          return addAdditionalPromiseMethods(args[0](subject), expect, subject);
+        } else {
+          return camelCaseMethods[methodName](subject)(...args);
+        }
+      }
+
+      if (this.isFulfilled()) {
+        return execute(this.value());
+      } else {
+        return addAdditionalPromiseMethods(this.then(execute), expect, subject);
+      }
+    };
+  });
+
   return promise;
 }
 

lib/createTopLevelExpect.js

@@ -244,6 +244,32 @@ function createExpectIt(expect, expectations, forwardedFlags) {
     copiedExpectations.push(OR, args);
     return createExpectIt(expect, copiedExpectations, forwardedFlags);
   };
+
+  const camelCaseMethods = expect._camelCaser(expect.context || new Context());
+  Object.keys(camelCaseMethods).forEach((methodName) => {
+    expectIt[
+      `and${methodName.replace(/^[a-z]/, ($0) => $0.toUpperCase())}`
+    ] = function (...args) {
+      const copiedExpectations = expectations.slice();
+      copiedExpectations.push([
+        methodName.replace(/[A-Z]/g, ($0) => ` ${$0.toLowerCase()}`), // Eeeeek, fix this
+        ...args,
+      ]);
+      return createExpectIt(expect, copiedExpectations, forwardedFlags);
+    };
+
+    expectIt[
+      `or${methodName.replace(/^[a-z]/, ($0) => $0.toUpperCase())}`
+    ] = function (...args) {
+      const copiedExpectations = expectations.slice();
+      copiedExpectations.push(OR, [
+        methodName.replace(/[A-Z]/g, ($0) => ` ${$0.toLowerCase()}`), // Eeeeek, fix this
+        ...args,
+      ]);
+      return createExpectIt(expect, copiedExpectations, forwardedFlags);
+    };
+  });
+
   return expectIt;
 }
 
@@ -730,7 +756,7 @@ expectPrototype.addAssertion = function (
     ] = (...args) =>
       createExpectIt(
         this._topLevelExpect,
-        [[testDescriptionString, ...args]],
+        [[handler.testDescriptionString, ...args]],
         this.flags
       );
 
@@ -1323,7 +1349,11 @@ expectPrototype._createWrappedExpect = function (
     if (arguments.length === 0) {
       throw new Error('The expect function requires at least one parameter.');
     } else if (arguments.length === 1) {
-      return parentExpect._camelCaser(subject, context);
+      return parentExpect._camelCaser(
+        context,
+        parentExpect.findTypeOf(subject),
+        subject
+      );
     } else if (typeof testDescriptionString === 'function') {
       wrappedExpect.errorMode = 'nested';
       return wrappedExpect.withError(
@@ -1460,28 +1490,34 @@ expectPrototype._executeExpect = function (
   return oathbreaker(assertionRule.handler(wrappedExpect, subject, ...args));
 };
 
-expectPrototype._camelCaser = function (subject, context) {
-  const subjectType = this.findTypeOf(subject);
+expectPrototype._camelCaser = function (context, subjectType, subject) {
   const methods = {};
   let instance = this;
   while (instance) {
     Object.keys(instance.assertions).forEach((testDescriptionString) => {
       if (
+        !subjectType ||
         instance.assertions[testDescriptionString].some((assertion) =>
           subjectType.is(assertion.subject.type)
         )
       ) {
-        methods[
-          testDescriptionString.replace(/ [a-z]/g, ($0) =>
-            $0.charAt(1).toUpperCase()
-          )
-        ] = (...args) => {
+        let method = (subject) => (...args) => {
           return this._expect(context, [
             subject,
             testDescriptionString,
             ...args,
           ]);
         };
+
+        if (subjectType) {
+          method = method(subject);
+        }
+
+        methods[
+          testDescriptionString.replace(/ [a-z]/g, ($0) =>
+            $0.charAt(1).toUpperCase()
+          )
+        ] = method;
       }
     });
     instance = instance.parent;
@@ -1496,7 +1532,7 @@ expectPrototype._expect = function (context, args, forwardedFlags) {
   if (args.length < 1) {
     throw new Error('The expect function requires at least one parameter.');
   } else if (args.length === 1) {
-    return this._camelCaser(subject, context);
+    return this._camelCaser(context, this.findTypeOf(subject), subject);
   } else if (typeof testDescriptionString === 'function') {
     return this.withError(
       () => testDescriptionString(subject),