strong-mock 8.0.0-beta.1 → 8.0.0-beta.2

package/dist/index.js

@@ -168,151 +168,71 @@ ${snippet}`);
 
 }
 
-/**
- * Controls what happens when a property is accessed, or a call is made,
- * and there are no expectations set for it.
- */
-exports.Strictness = void 0;
+exports.UnexpectedProperty = void 0;
 
-(function (Strictness) {
+(function (UnexpectedProperty) {
   /**
-   * Any property that's accessed, or any call that's made, without a matching
-   * expectation, will throw immediately.
+   * Throw an error immediately.
    *
    * @example
-   * type Service = { foo: (x: number) => number };
-   * const service = mock<Service>();
-   *
-   * // This will throw.
+   * // Will throw "Didn't expect foo to be accessed".
    * const { foo } = service;
    *
    * // Will throw "Didn't expect foo to be accessed",
    * // without printing the arguments.
    * foo(42);
    */
-  Strictness[Strictness["SUPER_STRICT"] = 0] = "SUPER_STRICT";
+  UnexpectedProperty[UnexpectedProperty["THROW"] = 0] = "THROW";
   /**
-   * Properties with unmatched expectations will return functions that will
-   * throw if called. This can be useful if your code destructures a function
-   * but never calls it.
+   * Return a function that will throw if called. This can be useful if your
+   * code destructures a function but never calls it.
    *
    * It will also improve error messages for unexpected calls because arguments
    * will be captured instead of throwing immediately on the property access.
    *
-   * @example
-   * type Service = { foo: (x: number) => number };
-   * const service = mock<Service>();
+   * The function will be returned even if the property is not supposed to be a
+   * function. This could cause weird behavior at runtime, when your code expects
+   * e.g. a number and gets a function instead.
    *
-   * // This will not throw.
+   * @example
+   * // This will NOT throw.
    * const { foo } = service;
    *
+   * // This will NOT throw, and might produce unexpected results.
+   * foo > 0
+   *
    * // Will throw "Didn't expect foo(42) to be called".
    * foo(42);
    */
 
-  Strictness[Strictness["STRICT"] = 1] = "STRICT";
-})(exports.Strictness || (exports.Strictness = {}));
-
-const createProxy = traps => // eslint-disable-next-line no-empty-function
-new Proxy(
-/* istanbul ignore next */
-() => {}, {
-  get: (target, prop) => {
-    if (prop === 'bind') {
-      return (thisArg, ...args) => (...moreArgs) => traps.apply([...args, ...moreArgs]);
-    }
+  UnexpectedProperty[UnexpectedProperty["CALL_THROW"] = 1] = "CALL_THROW";
+})(exports.UnexpectedProperty || (exports.UnexpectedProperty = {}));
 
-    if (prop === 'apply') {
-      return (thisArg, args) => traps.apply(args || []);
-    }
-
-    if (prop === 'call') {
-      return (thisArg, ...args) => traps.apply(args);
-    }
-
-    return traps.property(prop);
-  },
-  apply: (target, thisArg, args) => traps.apply(args),
-  ownKeys: () => traps.ownKeys(),
-
-  getOwnPropertyDescriptor(target, prop) {
-    const keys = traps.ownKeys();
-
-    if (keys.includes(prop)) {
-      return {
-        configurable: true,
-        enumerable: true
-      };
-    }
-
-    return undefined;
-  }
-
-});
-
-/**
- * Since `when` doesn't receive the mock subject (because we can't make it
- * consistently return it from `mock()`, `mock.foo` and `mock.bar()`) we need
- * to store a global state for the currently active mock.
- *
- * We also want to throw in the following case:
- *
- * ```
- * when(() => mock()) // forgot returns here
- * when(() => mock()) // should throw
- * ```
- *
- * For that reason we can't just store the currently active mock, but also
- * whether we finished the expectation or not.
- */
-
-let activeMock;
-const setActiveMock = mock => {
-  activeMock = mock;
-};
-const getActiveMock = () => activeMock;
 /**
- * Store a global map of all mocks created and their state.
- *
- * This is needed because we can't reliably pass the state between `when`
- * and `thenReturn`.
- */
-
-const mockMap = new Map();
-const getMockState = mock => {
-  if (mockMap.has(mock)) {
-    return mockMap.get(mock);
-  }
-
-  throw new NotAMock();
-};
-const setMockState = (mock, state) => {
-  mockMap.set(mock, state);
-};
-const getAllMocks = () => Array.from(mockMap.entries());
-
-/**
- * Return the expectation's return value.
+ * Unbox the expectation's return value.
  *
  * If the value is an error then throw it.
  *
  * If the value is a promise then resolve/reject it.
  */
-
-const returnOrThrow = ({
+const unboxReturnValue = ({
   isError,
   isPromise,
   value
 }) => {
   if (isError) {
-    if (isPromise) {
-      return Promise.reject(value);
-    }
-
     if (value instanceof Error) {
+      if (isPromise) {
+        return Promise.reject(value);
+      }
+
       throw value;
     }
 
+    if (isPromise) {
+      return Promise.reject(new Error(value));
+    }
+
     throw new Error(value);
   }
 
@@ -322,67 +242,20 @@ const returnOrThrow = ({
 
   return value;
 };
-const createStub = (repo, pendingExpectation, getCurrentMode, concreteMatcher) => {
-  const stub = createProxy({
-    property: property => {
-      if (getCurrentMode() === Mode.CALL) {
-        return returnOrThrow(repo.get(property));
-      }
-
-      setActiveMock(stub);
-      pendingExpectation.start(repo, concreteMatcher); // eslint-disable-next-line no-param-reassign
-
-      pendingExpectation.property = property;
-      return createProxy({
-        property: childProp => {
-          pendingExpectation.clear();
-          throw new NestedWhen(property, childProp);
-        },
-        apply: args => {
-          // eslint-disable-next-line no-param-reassign
-          pendingExpectation.args = args;
-        },
-        ownKeys: () => {
-          throw new Error('Spreading during an expectation is not supported.');
-        }
-      });
-    },
-    apply: args => {
-      if (getCurrentMode() === Mode.CALL) {
-        return repo.apply(args);
-      }
-
-      setActiveMock(stub);
-      pendingExpectation.start(repo, concreteMatcher); // eslint-disable-next-line no-param-reassign
-
-      pendingExpectation.property = ApplyProp; // eslint-disable-next-line no-param-reassign
-
-      pendingExpectation.args = args;
-      return undefined;
-    },
-    ownKeys: () => {
-      if (getCurrentMode() === Mode.CALL) {
-        return repo.getAllProperties();
-      }
-
-      throw new Error('Spreading during an expectation is not supported.');
-    }
-  });
-  return stub;
-};
 
 /**
- * An expectation repository for configurable levels of strictness.
+ * An expectation repository with a configurable behavior for
+ * unexpected property access.
  */
 
 class FlexibleRepository {
-  constructor(strictness = exports.Strictness.SUPER_STRICT) {
-    this.strictness = void 0;
+  constructor(unexpectedProperty = exports.UnexpectedProperty.THROW) {
+    this.unexpectedProperty = void 0;
     this.expectations = new Map();
     this.expectedCallStats = new Map();
     this.unexpectedCallStats = new Map();
 
-    this.apply = args => this.get(ApplyProp).value(...args);
+    this.apply = args => this.get(ApplyProp)(...args);
 
     this.handlePropertyWithMatchingExpectations = (property, expectations) => {
       // Avoid recording call stats for function calls, since the property is an
@@ -397,64 +270,51 @@ class FlexibleRepository {
 
       if (propertyExpectation) {
         this.countAndConsume(propertyExpectation);
-        return propertyExpectation.expectation.returnValue;
+        return unboxReturnValue(propertyExpectation.expectation.returnValue);
       }
 
-      return {
-        value: (...args) => {
-          const callExpectation = expectations.find(e => e.expectation.matches(args));
-
-          if (callExpectation) {
-            this.recordExpected(property, args);
-            this.countAndConsume(callExpectation); // TODO: this is duplicated in stub
+      return (...args) => {
+        const callExpectation = expectations.find(e => e.expectation.matches(args));
 
-            return returnOrThrow(callExpectation.expectation.returnValue);
-          }
-
-          return this.getValueForUnexpectedCall(property, args);
+        if (callExpectation) {
+          this.recordExpected(property, args);
+          this.countAndConsume(callExpectation);
+          return unboxReturnValue(callExpectation.expectation.returnValue);
         }
+
+        return this.getValueForUnexpectedCall(property, args);
       };
     };
 
     this.handlePropertyWithNoExpectations = property => {
       switch (property) {
         case 'toString':
-          return {
-            value: () => 'mock'
-          };
+          return () => 'mock';
 
         case '@@toStringTag':
         case Symbol.toStringTag:
         case 'name':
-          return {
-            value: 'mock'
-          };
+          return 'mock';
         // pretty-format
 
         case '$$typeof':
         case 'constructor':
         case '@@__IMMUTABLE_ITERABLE__@@':
         case '@@__IMMUTABLE_RECORD__@@':
-          return {
-            value: null
-          };
+          return null;
 
         case MATCHER_SYMBOL:
-          return {
-            value: false
-          };
+          return false;
 
         case ApplyProp:
-          return {
-            value: (...args) => this.getValueForUnexpectedCall(property, args)
-          };
+          return (...args) => this.getValueForUnexpectedCall(property, args);
 
         default:
           return this.getValueForUnexpectedAccess(property);
       }
     };
 
-    this.strictness = strictness;
+    this.unexpectedProperty = unexpectedProperty;
   }
 
   add(expectation) {
@@ -474,6 +334,8 @@ class FlexibleRepository {
     this.unexpectedCallStats.clear();
   }
 
+  // TODO: this returns any, but the interface returns unknown
+  //   unknown causes errors in apply tests, and any causes bugs in bootstrapped SM
   get(property) {
     const expectations = this.expectations.get(property);
 
@@ -537,16 +399,14 @@ class FlexibleRepository {
   }
 
   getValueForUnexpectedAccess(property) {
-    if (this.strictness === exports.Strictness.SUPER_STRICT) {
+    if (this.unexpectedProperty === exports.UnexpectedProperty.THROW) {
       this.recordUnexpected(property, undefined);
       throw new UnexpectedAccess(property, this.getUnmet());
     }
 
-    return {
-      value: (...args) => {
-        this.recordUnexpected(property, args);
-        throw new UnexpectedCall(property, args, this.getUnmet());
-      }
+    return (...args) => {
+      this.recordUnexpected(property, args);
+      throw new UnexpectedCall(property, args, this.getUnmet());
     };
   }
 
@@ -565,16 +425,18 @@ class FlexibleRepository {
  */
 
 class StrongExpectation {
-  constructor(property, args, returnValue) {
+  constructor(property, args, returnValue, exactParams = false) {
     this.property = void 0;
     this.args = void 0;
     this.returnValue = void 0;
+    this.exactParams = void 0;
     this.matched = 0;
     this.min = 1;
     this.max = 1;
     this.property = property;
     this.args = args;
     this.returnValue = returnValue;
+    this.exactParams = exactParams;
   }
 
   setInvocationCount(min, max = 1) {
@@ -604,6 +466,12 @@ class StrongExpectation {
       return false;
     }
 
+    if (this.exactParams) {
+      if (this.args.length !== received.length) {
+        return false;
+      }
+    }
+
     return this.args.every((arg, i) => arg.matches(received[i]));
   }
 
@@ -613,55 +481,43 @@ class StrongExpectation {
 
 }
 
-class RepoSideEffectPendingExpectation {
-  constructor(createExpectation) {
+class PendingExpectationWithFactory {
+  constructor(createExpectation, concreteMatcher, exactParams) {
     this.createExpectation = void 0;
-    this._repo = void 0;
-    this._concreteMatcher = void 0;
-    this._args = void 0;
-    this._property = '';
+    this.concreteMatcher = void 0;
+    this.exactParams = void 0;
+    this.args = void 0;
+    this.property = void 0;
     this.createExpectation = createExpectation;
+    this.concreteMatcher = concreteMatcher;
+    this.exactParams = exactParams;
   }
 
-  start(repo, concreteMatcher) {
-    if (this._repo) {
+  setProperty(value) {
+    if (this.property) {
       throw new UnfinishedExpectation(this);
     }
 
-    this.clear();
-    this._repo = repo;
-    this._concreteMatcher = concreteMatcher;
+    this.property = value;
   }
 
-  set property(value) {
-    this._property = value;
-  }
-
-  set args(value) {
-    this._args = value;
+  setArgs(value) {
+    this.args = value;
   }
 
   finish(returnValue) {
-    if (!this._repo || !this._concreteMatcher) {
+    if (!this.property) {
       throw new MissingWhen();
     }
 
-    const expectation = this.createExpectation(this._property, this._args, returnValue, this._concreteMatcher);
-
-    this._repo.add(expectation);
-
-    this.clear();
+    const expectation = this.createExpectation(this.property, this.args, returnValue, this.concreteMatcher, this.exactParams);
+    this.property = undefined;
+    this.args = undefined;
     return expectation;
   }
 
-  clear() {
-    this._repo = undefined;
-    this._args = undefined;
-    this._property = '';
-  }
-
   toJSON() {
-    return printWhen(this._property, this._args);
+    return printWhen(this.property, this.args);
   }
 
 }
@@ -952,7 +808,8 @@ const It = {
 
 const defaults = {
   concreteMatcher: It.deepEquals,
-  strictness: exports.Strictness.STRICT
+  unexpectedProperty: exports.UnexpectedProperty.CALL_THROW,
+  exactParams: false
 };
 let currentDefaults = defaults;
 /**
@@ -967,8 +824,128 @@ const setDefaults = newDefaults => {
   currentDefaults = _extends({}, defaults, newDefaults);
 };
 
-const strongExpectationFactory = (property, args, returnValue, concreteMatcher) => new StrongExpectation(property, // Wrap every non-matcher in the default matcher.
-args == null ? void 0 : args.map(arg => isMatcher(arg) ? arg : concreteMatcher(arg)), returnValue);
+/**
+ * Since `when` doesn't receive the mock subject (because we can't make it
+ * consistently return it from `mock()`, `mock.foo` and `mock.bar()`) we need
+ * to store a global state for the currently active mock.
+ *
+ * We also want to throw in the following case:
+ *
+ * ```
+ * when(() => mock()) // forgot returns here
+ * when(() => mock()) // should throw
+ * ```
+ *
+ * For that reason we can't just store the currently active mock, but also
+ * whether we finished the expectation or not.
+ */
+
+let activeMock;
+const setActiveMock = mock => {
+  activeMock = mock;
+};
+const getActiveMock = () => activeMock;
+/**
+ * Store a global map of all mocks created and their state.
+ *
+ * This is needed because we can't reliably pass the state between `when`
+ * and `thenReturn`.
+ */
+
+const mockMap = new Map();
+const getMockState = mock => {
+  if (mockMap.has(mock)) {
+    return mockMap.get(mock);
+  }
+
+  throw new NotAMock();
+};
+const setMockState = (mock, state) => {
+  mockMap.set(mock, state);
+};
+const getAllMocks = () => Array.from(mockMap.entries());
+
+const createProxy = traps => // eslint-disable-next-line no-empty-function
+new Proxy(
+/* istanbul ignore next */
+() => {}, {
+  get: (target, prop) => {
+    if (prop === 'bind') {
+      return (thisArg, ...args) => (...moreArgs) => traps.apply([...args, ...moreArgs]);
+    }
+
+    if (prop === 'apply') {
+      return (thisArg, args) => traps.apply(args || []);
+    }
+
+    if (prop === 'call') {
+      return (thisArg, ...args) => traps.apply(args);
+    }
+
+    return traps.property(prop);
+  },
+  apply: (target, thisArg, args) => traps.apply(args),
+  ownKeys: () => traps.ownKeys(),
+
+  getOwnPropertyDescriptor(target, prop) {
+    const keys = traps.ownKeys();
+
+    if (keys.includes(prop)) {
+      return {
+        configurable: true,
+        enumerable: true
+      };
+    }
+
+    return undefined;
+  }
+
+});
+
+const createStub = (repo, pendingExpectation, getCurrentMode) => {
+  const stub = createProxy({
+    property: property => {
+      if (getCurrentMode() === Mode.CALL) {
+        return repo.get(property);
+      }
+
+      setActiveMock(stub);
+      pendingExpectation.setProperty(property);
+      return createProxy({
+        property: childProp => {
+          throw new NestedWhen(property, childProp);
+        },
+        apply: args => {
+          pendingExpectation.setArgs(args);
+        },
+        ownKeys: () => {
+          throw new Error('Spreading during an expectation is not supported.');
+        }
+      });
+    },
+    apply: args => {
+      if (getCurrentMode() === Mode.CALL) {
+        return repo.apply(args);
+      }
+
+      setActiveMock(stub);
+      pendingExpectation.setProperty(ApplyProp);
+      pendingExpectation.setArgs(args);
+      return undefined;
+    },
+    ownKeys: () => {
+      if (getCurrentMode() === Mode.CALL) {
+        return repo.getAllProperties();
+      }
+
+      throw new Error('Spreading during an expectation is not supported.');
+    }
+  });
+  return stub;
+};
+
+const strongExpectationFactory = (property, args, returnValue, concreteMatcher, exactParams) => new StrongExpectation(property, // Wrap every non-matcher in the default matcher.
+args == null ? void 0 : args.map(arg => isMatcher(arg) ? arg : concreteMatcher(arg)), returnValue, exactParams);
 
 var Mode;
 
@@ -981,6 +958,8 @@ let currentMode = Mode.CALL;
 const setMode = mode => {
   currentMode = mode;
 };
+
+const getMode = () => currentMode;
 /**
  * Create a type safe mock.
  *
@@ -988,9 +967,12 @@ const setMode = mode => {
  *
  * @param options Configure the options for this specific mock, overriding any
  *   defaults that were set with {@link setDefaults}.
- * @param options.strictness Controls what happens when a property is accessed,
- *   or a call is made, and there are no expectations set for it.
- * @param options.concreteMatcher The matcher that will be used when one isn't specified explicitly.
+ * @param options.unexpectedProperty Controls what happens when an unexpected
+ *   property is accessed.
+ * @param options.concreteMatcher The matcher that will be used when one isn't
+ *   specified explicitly.
+ * @param options.exactParams Controls whether the number of received arguments
+ *   has to match the expectation.
  *
  * @example
  * const fn = mock<() => number>();
@@ -1000,17 +982,20 @@ const setMode = mode => {
  * fn() === 23;
  */
 
+
 const mock = ({
-  strictness,
-  concreteMatcher
+  unexpectedProperty,
+  concreteMatcher,
+  exactParams
 } = {}) => {
-  const pendingExpectation = new RepoSideEffectPendingExpectation(strongExpectationFactory);
   const options = {
-    strictness: strictness != null ? strictness : currentDefaults.strictness,
-    concreteMatcher: concreteMatcher != null ? concreteMatcher : currentDefaults.concreteMatcher
+    unexpectedProperty: unexpectedProperty != null ? unexpectedProperty : currentDefaults.unexpectedProperty,
+    concreteMatcher: concreteMatcher != null ? concreteMatcher : currentDefaults.concreteMatcher,
+    exactParams: exactParams != null ? exactParams : currentDefaults.exactParams
   };
-  const repository = new FlexibleRepository(options.strictness);
-  const stub = createStub(repository, pendingExpectation, () => currentMode, options.concreteMatcher);
+  const repository = new FlexibleRepository(options.unexpectedProperty);
+  const pendingExpectation = new PendingExpectationWithFactory(strongExpectationFactory, options.concreteMatcher, options.exactParams);
+  const stub = createStub(repository, pendingExpectation, getMode);
   setMockState(stub, {
     repository,
     pendingExpectation,
@@ -1058,13 +1043,9 @@ const createInvocationCount = expectation => ({
 
 });
 
-/**
- * Set a return value for the currently pending expectation.
- */
-
-const finishPendingExpectation = (returnValue, pendingExpectation) => {
+const finishPendingExpectation = (returnValue, pendingExpectation, repo) => {
   const finishedExpectation = pendingExpectation.finish(returnValue);
-  pendingExpectation.clear();
+  repo.add(finishedExpectation);
   return createInvocationCount(finishedExpectation);
 };
 
@@ -1080,45 +1061,29 @@ const getError = errorOrMessage => {
   return new Error();
 };
 
-const createReturns = pendingExpectation => {
-  const nonPromiseStub = {
-    // TODO: merge this with the promise version
-    thenReturn:
-    /* istanbul ignore next: because this is overwritten by the promise version */
-    returnValue => finishPendingExpectation({
-      value: returnValue,
-      isError: false,
-      isPromise: false
-    }, pendingExpectation),
-    thenThrow: errorOrMessage => finishPendingExpectation({
-      value: getError(errorOrMessage),
-      isError: true,
-      isPromise: false
-    }, pendingExpectation)
-  };
-  const promiseStub = {
-    thenReturn: promise => finishPendingExpectation({
-      value: promise,
-      isError: false,
-      // We're setting this to false because we can't distinguish between a
-      // promise thenReturn and a normal thenReturn.
-      isPromise: false
-    }, pendingExpectation),
-    thenResolve: promiseValue => finishPendingExpectation({
-      value: promiseValue,
-      isError: false,
-      isPromise: true
-    }, pendingExpectation),
-    thenReject: errorOrMessage => finishPendingExpectation({
-      value: getError(errorOrMessage),
-      isError: true,
-      isPromise: true
-    }, pendingExpectation)
-  }; // @ts-expect-error because the return type is a conditional, and we're merging
-  // both branches here
-
-  return _extends({}, nonPromiseStub, promiseStub);
-};
+const createReturns = (pendingExpectation, repository) => ({
+  thenReturn: returnValue => finishPendingExpectation( // This will handle both thenReturn(23) and thenReturn(Promise.resolve(3)).
+  {
+    value: returnValue,
+    isError: false,
+    isPromise: false
+  }, pendingExpectation, repository),
+  thenThrow: errorOrMessage => finishPendingExpectation({
+    value: getError(errorOrMessage),
+    isError: true,
+    isPromise: false
+  }, pendingExpectation, repository),
+  thenResolve: promiseValue => finishPendingExpectation({
+    value: promiseValue,
+    isError: false,
+    isPromise: true
+  }, pendingExpectation, repository),
+  thenReject: errorOrMessage => finishPendingExpectation({
+    value: getError(errorOrMessage),
+    isError: true,
+    isPromise: true
+  }, pendingExpectation, repository)
+});
 
 /**
  * Set an expectation on a mock.
@@ -1145,16 +1110,16 @@ const createReturns = pendingExpectation => {
  * const fn = mock<(x: number) => Promise<number>();
  * when(() => fn(23)).thenResolve(42);
  */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars,no-unused-vars
 
 const when = expectation => {
   setMode(Mode.EXPECT);
   expectation();
   setMode(Mode.CALL);
   const {
-    pendingExpectation
+    pendingExpectation,
+    repository
   } = getMockState(getActiveMock());
-  return createReturns(pendingExpectation);
+  return createReturns(pendingExpectation, repository);
 };
 
 /**