strong-mock 8.0.0-beta.2 → 8.0.0

package/README.md

@@ -127,7 +127,7 @@ console.log(foo.bar(23)); // even more awesome
 
 ### Setting invocation count expectations
 
-By default, each call is expected to be called only once. You can expect a call to be made multiple times by using the invocation count helpers `between`, `atLeast`, `times`, `anyTimes` etc.:
+By default, each call is expected to be made only once. You can expect a call to be made multiple times by using the invocation count helpers `between`, `atLeast`, `times`, `anyTimes` etc.:
 
 ```typescript
 const fn = mock<(x: number) => number>();
@@ -177,7 +177,7 @@ console.log(fn(1)); // 2
 
 ### Mocking promises
 
-If you're mocking something that returns a promise then you'll be able to use the promise helpers to set the return value.
+If you're mocking something that returns a promise then you'll be able to use the `thenResolve` promise helper to set the return value.
 
 ```typescript
 type Fn = (x: number) => Promise<number>;
@@ -191,15 +191,21 @@ console.log(await fn()); // 2
 
 ### Throwing errors
 
+Use `thenThrow` or `thenReject` to throw an `Error` instance. You can customize the error message, or even pass a derived class.
+
 ```typescript
 type Fn = (x: number) => void;
 type FnWithPromise = (x: number) => Promise<void>;
 
+class MyError extends Error {}
+
 const fn = mock<Fn>();
 const fnWithPromise = mock<FnWithPromise>();
 
+// All of these will throw an Error instance.
 when(() => fn(1)).thenThrow();
-when(() => fnWithPromise(1)).thenReject();
+when(() => fn(2)).thenThrow(MyError);
+when(() => fnWithPromise(1)).thenReject('oops');
 ```
 
 ### Verifying expectations
@@ -423,18 +429,23 @@ console.log(fn(1)); // throws
 
 ### Concrete matcher
 
-You can set the matcher that will be used in expectations with concrete values e.g. `42` or `{ foo: "bar" }`. Passing in a [matcher argument](#argument-matchers) will always take priority.
+You can configure the [matcher](#argument-matchers) that will be used in expectations with concrete values e.g. `42` or `{ foo: "bar" }`. This matcher can always be overwritten inside an expectation with another matcher.
 
 ```typescript
 import { mock, when, It } from 'strong-mock';
 
 // Use strict equality instead of deep equality.
-const fn = mock<(x: number[]) => boolean>({
+const fn = mock<(x: number[], y: string) => boolean>({
   concreteMatcher: It.is
 });
-when(() => fn([1, 2, 3])).thenReturn(true);
+when(() => fn([1, 2, 3], 'foo')).thenReturn(true);
+
+fn([1, 2, 3], 'foo'); // throws because different array instances
 
-fn([1, 2, 3]); // throws because different array instances
+const arr = [1, 2, 3];
+// The matcher will only apply to non-matcher arguments.
+when(() => fn(arr, It.isString())).thenReturn(true);
+console.log(fn(arr, 'any string')); // true
 ```
 
 ## FAQ

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strong-mock",
-  "version": "8.0.0-beta.2",
+  "version": "8.0.0",
   "description": "Simple type safe mocking library",
   "keywords": [
     "tdd",