fix

Author: papandreou

lib/addAdditionalPromiseMethods.js

@@ -4,7 +4,6 @@ const magicpen = require('magicpen');
 const extend = utils.extend;
 const ukkonen = require('ukkonen');
 const makePromise = require('./makePromise');
-const addAdditionalPromiseMethods = require('./addAdditionalPromiseMethods');
 const wrapPromiseIfNecessary = require('./wrapPromiseIfNecessary');
 const oathbreaker = require('./oathbreaker');
 const UnexpectedError = require('./UnexpectedError');
@@ -1321,6 +1320,112 @@ expectPrototype.setErrorMessage = function (err) {
   err.serializeMessage(this.outputFormat());
 };
 
+expectPrototype.addAdditionalPromiseMethods = function (
+  promise,
+  expect,
+  subject,
+  args,
+  wrappedExpect
+) {
+  // const expect = this;
+  promise.and = function (...args) {
+    function executeAnd() {
+      if (expect.findTypeOf(args[0]).is('expect.it')) {
+        return expect.addAdditionalPromiseMethods(
+          args[0](subject),
+          expect,
+          subject
+        );
+      } else {
+        return expect(subject, ...args);
+      }
+    }
+
+    if (this.isFulfilled()) {
+      return executeAnd();
+    } else {
+      return expect.addAdditionalPromiseMethods(
+        this.then(executeAnd),
+        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 expect.addAdditionalPromiseMethods(
+            args[0](shiftedSubject),
+            expect,
+            subject
+          );
+        } else {
+          if (wrappedExpect) {
+            return wrappedExpect.shifty(
+              shiftedSubject,
+              wrappedExpect.args || [],
+              [
+                methodName.replace(/[A-Z]/g, ($0) => ` ${$0.toLowerCase()}`),
+                ...args,
+              ],
+              true // legacy mode (FIXME)
+            );
+          } else {
+            // find ud af at fange konteksten
+            return expect._executeExpect(
+              new Context(),
+              shiftedSubject,
+              methodName.replace(/[A-Z]/g, ($0) => ` ${$0.toLowerCase()}`),
+              args,
+              {} // forwardedFlags
+            );
+          }
+        }
+      }
+
+      if (this.isFulfilled()) {
+        return execute(this.value());
+      } else {
+        return expect.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 expect.addAdditionalPromiseMethods(
+              args[0](subject),
+              expect,
+              subject
+            );
+          } else {
+            return camelCaseMethods[methodName](subject)(...args);
+          }
+        }
+
+        if (this.isFulfilled()) {
+          return execute(this.value());
+        } else {
+          return expect.addAdditionalPromiseMethods(
+            this.then(execute),
+            expect,
+            subject
+          );
+        }
+      };
+  });
+
+  return promise;
+};
+
 expectPrototype._createWrappedExpect = function (
   assertionRule,
   subject,
@@ -1336,7 +1441,7 @@ expectPrototype._createWrappedExpect = function (
     if (arguments.length === 0) {
       throw new Error('The expect function requires at least one parameter.');
     } else if (arguments.length === 1) {
-      return addAdditionalPromiseMethods(
+      return wrappedExpect.addAdditionalPromiseMethods(
         makePromise.resolve(subject),
         wrappedExpect,
         subject
@@ -1474,7 +1579,7 @@ expectPrototype._executeExpect = function (
         testDescriptionString,
         ...args,
       ]),
-      expect: wrappedExpect,
+      wrappedExpect,
     };
   }
 
@@ -1560,7 +1665,7 @@ expectPrototype._expect = function (context, args, forwardedFlags) {
     } else {
       result = makePromise.resolve(result);
     }
-    return addAdditionalPromiseMethods(
+    return wrappedExpect.addAdditionalPromiseMethods(
       result,
       this,
       subject,
@@ -1834,7 +1939,7 @@ expectPrototype._callInNestedContext = function (callback) {
     } else {
       result = makePromise.resolve(result);
     }
-    return addAdditionalPromiseMethods(result, this.execute, this.subject);
+    return this.addAdditionalPromiseMethods(result, this.execute, this.subject);
   } catch (e) {
     if (e && e._isUnexpected) {
       const wrappedError = new UnexpectedError(this, e);