Add jsonContaining() matcher

Author: johanblumenberg

README.md

@@ -41,6 +41,11 @@ Fork of [ts-mockito](https://github.com/NagRock/ts-mockito), which will be kept
 
 - [Improved argument capturing](#capture-by-matching-arguments)
 
+### 1.0.44
+
+- [Match by JSON string](#match-by-json)
+- [Custom matchers](#custom-matchers)
+
 ## Installation
 
 `npm install @johanblumenberg/ts-mockito --save-dev`
@@ -179,6 +184,56 @@ verify(mockedFoo.getBar(anything())).called();
 verify(mockedFoo.getBar(_)).called();
 ```
 
+### Match by JSON
+
+``` typescript
+// Creating mock
+let mockedFoo:Foo = mock(Foo);
+
+// Getting instance from mock
+let foo:Foo = instance(mockedFoo);
+
+// Using instance in source code
+foo.getBar('{"name": "John Doe", "age": 42}');
+foo.getBar('{"name": "John Smith", "age": 30}');
+
+// Match by part of JSON string
+verify(mockedFoo.getBar(jsonContaining({name: startsWith("John")}))).twice();
+verify(mockedFoo.getBar(jsonContaining({age: 42}))).once();
+```
+
+### Custom matchers
+
+Sometimes it is useful to define custom matchers, to be able to easily match on anything. This can be done by extending the `Matcher` class.
+
+```typescript
+class IsPalindromeMatcher extends Matcher {
+    public match(value: string): boolean {
+        return value === value.split("").reverse().join("");
+    }
+
+    public toString(): string {
+        return 'isPalindrome()';
+    }
+}
+
+function isPalindrome(): string {
+  return new IsPalindromeMatcher() as any;
+}
+
+// Creating mock
+let mockedFoo:Foo = mock(Foo);
+
+// Getting instance from mock
+let foo:Foo = instance(mockedFoo);
+
+// Using instance in source code
+foo.bar("racecar);
+
+// Match using the custom matcher
+verify(mockedFoo.bar(isPalindrome())).once();
+```
+
 ## Usage
 
 ### Basics

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@johanblumenberg/ts-mockito",
-  "version": "1.0.43",
+  "version": "1.0.44",
   "description": "Mocking library for TypeScript",
   "main": "lib/ts-mockito.js",
   "typings": "lib/ts-mockito",

package.json

@@ -0,0 +1,22 @@
+import * as _ from "lodash";
+import {Matcher} from "./Matcher";
+
+export class JsonContainingMatcher extends Matcher {
+    constructor(private expectedValue: any) {
+        super();
+    }
+
+    public match(value: string): boolean {
+        return _.isMatchWith(JSON.parse(value), this.expectedValue, (objValue, srcValue) => {
+          if (srcValue instanceof Matcher) {
+            return srcValue.match(objValue);
+          } else {
+            return undefined;
+          }
+        });
+    }
+
+    public toString(): string {
+        return `jsonContaining(${JSON.stringify(this.expectedValue)})`;
+    }
+}

src/matcher/type/JsonContainingMatcher.ts

@@ -12,6 +12,7 @@ import {IsBeforeMatcher} from "./matcher/type/date/IsBeforeMatcher";
 import {IsBeforeOrEqualMatcher} from "./matcher/type/date/IsBeforeOrEqualMatcher";
 import {DeepEqualMatcher} from "./matcher/type/DeepEqualMatcher";
 import {EndsWithMatcher} from "./matcher/type/EndsWithMatcher";
+import { JsonContainingMatcher } from "./matcher/type/JsonContainingMatcher";
 import {MatchingStringMatcher} from "./matcher/type/MatchingStringMatcher";
 import {NotNullMatcher} from "./matcher/type/NotNullMatcher";
 import {GreaterThanMatcher} from "./matcher/type/number/GreaterThanMatcher";
@@ -26,6 +27,7 @@ import {MethodStubVerificator} from "./MethodStubVerificator";
 import {MethodToStub} from "./MethodToStub";
 import {Mocker, MockPropertyPolicy, MockOptions} from "./Mock";
 import {Spy} from "./Spy";
+import {Matcher} from './matcher/type/Matcher';
 
 // Keep a reference to the original, in case it is replaced with fake timers
 // by some library like jest or lolex
@@ -158,6 +160,8 @@ export function resetCalls<T>(mockedValue: T): void {
     (mockedValue as any).__tsmockitoMocker.resetCalls();
 }
 
+export {Matcher} from './matcher/type/Matcher';
+
 export function anyOfClass<T>(expectedClass: new (...args: any[]) => T): any {
     return new AnyOfClassMatcher(expectedClass) as any;
 }
@@ -219,6 +223,10 @@ export function objectContaining<T>(expectedValue: RecursivePartial<T extends tr
     return new ObjectContainingMatcher(expectedValue) as any;
 }
 
+export function jsonContaining<T>(expectedValue: T): string {
+  return new JsonContainingMatcher(expectedValue) as any;
+}
+
 export type Deferred<T> = Promise<T> & {
     resolve: (value: T) => Promise<void>;
     reject: (err: any) => Promise<void>;
@@ -285,6 +293,7 @@ export default {
     reset,
     resetStubs,
     resetCalls,
+    Matcher,
     anyOfClass,
     anyFunction,
     anyNumber,
@@ -299,6 +308,7 @@ export default {
     startsWith,
     endsWith,
     objectContaining,
+    jsonContaining,
     MockPropertyPolicy,
     defer,
     nextTick,

src/ts-mockito.ts

@@ -0,0 +1,43 @@
+import {Matcher} from "../../../src/ts-mockito";
+
+class IsPalindromeMatcher extends Matcher {
+    constructor() {
+        super();
+    }
+
+    public match(value: string): boolean {
+        return value === value.split("").reverse().join("");
+    }
+
+    public toString(): string {
+        return 'isPalindrome()';
+    }
+}
+
+function isPalindrome(): string {
+  return new IsPalindromeMatcher() as any;
+}
+
+describe("Custom matcher", () => {
+    it("match returns true", () => {
+        // given
+        const testObj: Matcher = isPalindrome() as any;
+
+        // when
+        const result = testObj.match("racecar");
+
+        // then
+        expect(result).toBeTruthy();
+    });
+
+    it("no match returns false", () => {
+      // given
+      const testObj: Matcher = isPalindrome() as any;
+
+      // when
+      const result = testObj.match("taxi");
+
+      // then
+      expect(result).toBeFalsy();
+  });
+});

test/matcher/type/CustomMatcher.spec.ts

@@ -0,0 +1,64 @@
+import {Matcher} from "../../../src/matcher/type/Matcher";
+import {jsonContaining, objectContaining, startsWith} from "../../../src/ts-mockito";
+
+describe("JsonContainingMatcher", () => {
+    describe("checking if source object contains given object", () => {
+        const testObj: Matcher = jsonContaining({b: {c: "c", d: {}}}) as unknown as Matcher;
+
+        describe("when given value contains given object", () => {
+            it("returns true", () => {
+                // when
+                const result = testObj.match('{"a": "a", "b": {"c": "c", "d": {}}}');
+
+                // then
+                expect(result).toBeTruthy();
+            });
+
+            it("returns true", () => {
+                // when
+                const result = testObj.match('{"b": {"c": "c", "d": {}}}');
+
+                // then
+                expect(result).toBeTruthy();
+            });
+        });
+
+        describe("when given value doesn't contain given object", () => {
+            it("returns false", () => {
+                // when
+                const result = testObj.match('{"b": {"c": "c"}}');
+
+                // then
+                expect(result).toBeFalsy();
+            });
+        });
+    });
+
+    describe("accept matchers as values", () => {
+      it("should match using matcher as value", () => {
+        const testObj: Matcher = jsonContaining({ key: startsWith("abc") }) as unknown as Matcher;
+        const result = testObj.match('{"key": "abcdef"}');
+        expect(result).toBeTruthy();
+      });
+
+      it("should not match using matcher as value with mismatching value", () => {
+        const testObj: Matcher = jsonContaining({ key: startsWith("abc") }) as unknown as Matcher;
+        const result = testObj.match('{"key": "def"}');
+        expect(result).toBeFalsy();
+      });
+    });
+
+    describe("accept matchers as values in arrays", () => {
+      it("should match using matcher as value", () => {
+        const testObj: Matcher = jsonContaining({ key: [startsWith("abc")] }) as unknown as Matcher;
+        const result = testObj.match('{"key": ["abcdef"]}');
+        expect(result).toBeTruthy();
+      });
+
+      it("should not match using matcher as value with mismatching value", () => {
+        const testObj: Matcher = jsonContaining({ key: [startsWith("abc")] }) as unknown as Matcher;
+        const result = testObj.match('{"key": ["def"]}');
+        expect(result).toBeFalsy();
+      });
+    });
+});