feat(matchers): add Date matchers

* Added `isBefore()` matcher
* Added `isAfter()` matcher
* Added `isBeforeOrEqual()` matcher
* Added `isAfterOrEqual()` matcher

These matchers can be used to stub methods or easily verify calls
without having to capture the method call

```ts
class User {
  updatedAt: Date;
}

class UserRepository {
  saveOne(user: User): Promise<void> {
    // update the user in the database
  }
}

class UserService {
  constructor(private readonly userRepository: UserRespository) {}

  save(user: User): Promise<User> {
    user.updatedAt = new Date();

    await this.userRepository.saveOne(user);
  }
}

const userRepository = mock(UserRepository);
const userService = new UserService(instance(userRepository));

when(userRepository.saveOne(anything())).thenResolve();

const now = new Date();
await userService.save(new User());

verify(userRepository.saveOne(objectContaining({ updatedAt: isAfterOrEqual(now) }))).once();
```

Author: leon19

package-lock.json

@@ -46,6 +46,7 @@
     "karma-typescript": "^5.2.0",
     "karma-typescript-preprocessor": "^0.4.0",
     "puppeteer": "^5.5.0",
+    "ts-expect": "^1.3.0",
     "ts-helpers": "^1.1.2",
     "ts-jest": "^26.0.0",
     "tslint": "^5.7.0",

package.json

@@ -0,0 +1,32 @@
+import {Matcher} from "../Matcher";
+
+export abstract class DateMatcher extends Matcher {
+    protected readonly date: Date;
+
+    constructor(date: MaybeDate) {
+        super();
+
+        this.date = new Date(date);
+
+        if (!isValidDate(this.date)) {
+            throw new InvalidDateError(date);
+        }
+    }
+}
+
+export class InvalidDateError extends Error {
+    public readonly name = this.constructor.name;
+
+    constructor(date: MaybeDate) {
+        super(`Invalid date: ${date}`);
+
+        Object.setPrototypeOf(this, InvalidDateError.prototype);
+    }
+}
+
+export type MaybeDate = number | string | Date;
+
+/** @internal */
+export function isValidDate(date: Date): date is Date {
+    return !Number.isNaN(date.getTime());
+}

src/matcher/type/date/DateMatcher.ts

@@ -0,0 +1,13 @@
+import {DateMatcher, isValidDate, MaybeDate} from "./DateMatcher";
+
+export class IsAfterMatcher extends DateMatcher {
+    public match(value: MaybeDate): boolean {
+        value = new Date(value);
+
+        return isValidDate(value) && value.getTime() > this.date.getTime();
+    }
+
+    public toString(): string {
+        return `isAfter(${this.date.toISOString()})`;
+    }
+}

src/matcher/type/date/IsAfterMatcher.ts

@@ -0,0 +1,13 @@
+import {DateMatcher, isValidDate, MaybeDate} from "./DateMatcher";
+
+export class IsAfterOrEqualMatcher extends DateMatcher {
+    public match(value: MaybeDate): boolean {
+        value = new Date(value);
+
+        return isValidDate(value) && value.getTime() >= this.date.getTime();
+    }
+
+    public toString(): string {
+        return `isAfterOrEqual(${this.date.toISOString()})`;
+    }
+}

src/matcher/type/date/IsAfterOrEqualMatcher.ts

@@ -0,0 +1,13 @@
+import {DateMatcher, isValidDate, MaybeDate} from "./DateMatcher";
+
+export class IsBeforeMatcher extends DateMatcher {
+    public match(value: MaybeDate): boolean {
+        value = new Date(value);
+
+        return isValidDate(value) && value.getTime() < this.date.getTime();
+    }
+
+    public toString(): string {
+        return `isBefore(${this.date.toISOString()})`;
+    }
+}

src/matcher/type/date/IsBeforeMatcher.ts

@@ -0,0 +1,13 @@
+import {DateMatcher, isValidDate, MaybeDate} from "./DateMatcher";
+
+export class IsBeforeOrEqualMatcher extends DateMatcher {
+    public match(value: MaybeDate): boolean {
+        value = new Date(value);
+
+        return isValidDate(value) && value.getTime() <= this.date.getTime();
+    }
+
+    public toString(): string {
+        return `isBeforeOrEqual(${this.date.toISOString()})`;
+    }
+}

src/matcher/type/date/IsBeforeOrEqualMatcher.ts

@@ -17,6 +17,11 @@ import {AnyOfClassMatcher} from "./matcher/type/AnyOfClassMatcher";
 import {AnyStringMatcher} from "./matcher/type/AnyStringMatcher";
 import {AnythingMatcher} from "./matcher/type/AnythingMatcher";
 import {BetweenMatcher} from "./matcher/type/BetweenMatcher";
+import {MaybeDate} from "./matcher/type/date/DateMatcher";
+import {IsAfterMatcher} from "./matcher/type/date/IsAfterMatcher";
+import {IsAfterOrEqualMatcher} from "./matcher/type/date/IsAfterOrEqualMatcher";
+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 {MatchingStringMatcher} from "./matcher/type/MatchingStringMatcher";
@@ -197,6 +202,22 @@ export function nextTick(): Promise<void> {
     return new Promise(resolve => originalSetTimeout(() => originalSetImmediate(resolve), 0));
 }
 
+export function isAfter(date: MaybeDate): Date {
+    return new IsAfterMatcher(date) as any;
+}
+
+export function isAfterOrEqual(date: MaybeDate): Date {
+    return new IsAfterOrEqualMatcher(date) as any;
+}
+
+export function isBefore(date: MaybeDate): Date {
+    return new IsBeforeMatcher(date) as any;
+}
+
+export function isBeforeOrEqual(date: MaybeDate): Date {
+    return new IsBeforeOrEqualMatcher(date) as any;
+}
+
 // Export default object with all members (ember-browserify doesn't support named exports).
 export default {
     spy,
@@ -226,4 +247,8 @@ export default {
     MockPropertyPolicy,
     defer,
     nextTick,
+    isAfter,
+    isAfterOrEqual,
+    isBefore,
+    isBeforeOrEqual,
 };

src/ts-mockito.ts

@@ -0,0 +1,138 @@
+import {expectType} from "ts-expect";
+import {InvalidDateError, MaybeDate} from "../../../../src/matcher/type/date/DateMatcher";
+import {IsAfterMatcher} from "../../../../src/matcher/type/date/IsAfterMatcher";
+import {imock, instance, isAfter, when} from "../../../../src/ts-mockito";
+
+describe("IsAfterMatcher", () => {
+    describe("isAfter()", () => {
+        it("should be a IfAfterOrEqualMatcher instance", () => {
+            expect(isAfter(new Date()) instanceof IsAfterMatcher).toBe(true);
+        });
+
+        it("should be a date type", () => {
+            expectType<Date>(isAfter(new Date()));
+        });
+    });
+
+    describe("#constructor()", () => {
+        it("should accept a number", () => {
+            expect(() => new IsAfterMatcher(0)).not.toThrow();
+        });
+
+        it("should accept a string", () => {
+            expect(() => new IsAfterMatcher("2020-01-01")).not.toThrow();
+        });
+
+        it("should accept a date", () => {
+            expect(() => new IsAfterMatcher(new Date())).not.toThrow();
+        });
+
+        it("should throw an error when given value is not a valid date", () => {
+            const date = "asdfg";
+            expect(() => new IsAfterMatcher(date)).toThrow(new InvalidDateError(date));
+        });
+    });
+
+    describe("#match()", () => {
+        it("should return true when the given date is after the expected date", () => {
+            const date = "2020-01-01";
+
+            const matcher = new IsAfterMatcher(date);
+
+            const testDate = "2020-01-02";
+            expect(matcher.match(new Date(testDate))).toBe(true);
+            expect(matcher.match(testDate)).toBe(true);
+            expect(matcher.match(new Date(testDate).getTime())).toBe(true);
+        });
+
+        it("should return false when the given date is equal to the expected date", () => {
+            const date = "2020-01-01";
+
+            const matcher = new IsAfterMatcher(date);
+
+            const testDate = "2020-01-01";
+            expect(matcher.match(new Date(testDate))).toBe(false);
+            expect(matcher.match(testDate)).toBe(false);
+            expect(matcher.match(new Date(testDate).getTime())).toBe(false);
+        });
+
+        it("should return false when the given date is before the expected date", () => {
+            const date = "2020-01-02";
+
+            const matcher = new IsAfterMatcher(date);
+
+            const testDate = "2020-01-01";
+            expect(matcher.match(new Date(testDate))).toBe(false);
+            expect(matcher.match(testDate)).toBe(false);
+            expect(matcher.match(new Date(testDate).getTime())).toBe(false);
+        });
+
+        it("should return false when the given date is an invalid date", () => {
+            const matcher = new IsAfterMatcher(new Date());
+
+            expect(matcher.match(new Date("Invalid Date"))).toBe(false);
+        });
+    });
+
+    describe("#toString()", () => {
+        it("should correctly get the string representation", () => {
+            const date = new Date();
+
+            expect(new IsAfterMatcher(date).toString()).toBe(`isAfter(${date.toISOString()})`);
+        });
+    });
+
+    describe("stubbing a method", () => {
+        let testServiceMock: TestService;
+        let testService: TestService;
+
+        beforeEach(() => {
+            testServiceMock = imock();
+            testService = instance(testServiceMock);
+        });
+
+        it("should pass the verification when the given date is after the expected date", () => {
+            const date = new Date("2020-01-01");
+
+            when(testServiceMock.testMethod(isAfter(date))).thenReturn(true);
+
+            const result = testService.testMethod(new Date("2020-01-02"));
+
+            expect(result).toBe(true);
+        });
+
+        it("should not pass the verification when the given date is equal to the expected date", () => {
+            const date = new Date("2020-01-01");
+
+            when(testServiceMock.testMethod(isAfter(date))).thenReturn(true);
+
+            const result = testService.testMethod(new Date("2020-01-01"));
+
+            expect(result).toBeNull();
+        });
+
+        it("should not pass the verification when the given date is before the expected date", () => {
+            const date = new Date("2020-01-02");
+
+            when(testServiceMock.testMethod(isAfter(date))).thenReturn(true);
+
+            const result = testService.testMethod(new Date("2020-01-01"));
+
+            expect(result).toBeNull();
+        });
+
+        it("should not pass the verification false when the given date is an invalid date", () => {
+            const date = new Date("2020-01-01");
+
+            when(testServiceMock.testMethod(isAfter(date))).thenReturn(true);
+
+            const result = testService.testMethod(new Date("Invalid Date"));
+
+            expect(result).toBeNull();
+        });
+    });
+});
+
+interface TestService {
+    testMethod(date: MaybeDate): boolean;
+}