Merge pull request #100 from kreatemore/add-jest-support

Shallow-render should now support both Jest & Jasmine

Author: getsaf

lib/models/mock-of-provider.ts

@@ -1,11 +1,12 @@
 import { Provider } from '@angular/core';
+import { testFramework } from '../test-framework';
 
 export class MockOfProvider {
   constructor(public mockOf: Provider, stubs: any = {}) {
     Object.assign(this, stubs);
     Object.keys(stubs).forEach(key => {
-      if (typeof (this as any)[key] === 'function' && !(jasmine as any).isSpy((this as any)[key])) {
-        spyOn(this as any, key).and.callThrough();
+      if (typeof (this as any)[key] === 'function' && !testFramework.isSpy((this as any)[key])) {
+        testFramework.spyOn(this as any, key);
       }
     });
   }

lib/models/renderer.ts

@@ -1,6 +1,7 @@
 import { Directive, EventEmitter, Type } from '@angular/core';
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 import { By } from '@angular/platform-browser';
+import { testFramework } from '../test-framework';
 import { copyTestModule } from '../tools/copy-test-module';
 import { createContainer } from '../tools/create-container';
 import { mockProvider } from '../tools/mock-provider';
@@ -45,12 +46,12 @@ export class Renderer<TComponent> {
         .checkMockForStaticProperties(stubs);
       Object.keys(stubs).forEach(key => {
         const stub = stubs[key];
-        if (!(jasmine as any).isSpy(obj[key])) {
-          spyOn(obj, key).and.callFake(stub);
+        if (!testFramework.isSpy(obj[key])) {
+          testFramework.spyOn(obj, key, stub);
         } else {
-          const spy = obj[key] as jasmine.Spy;
-          spy.calls.reset();
-          spy.and.callFake(stub);
+          const spy = obj[key];
+          testFramework.resetSpy(spy);
+          testFramework.mockImplementation(spy, stub);
         }
       });
     });

lib/shallow.ts

@@ -5,7 +5,7 @@ import { RecursivePartial } from './models/recursive-partial';
 import { InvalidStaticPropertyMockError, Renderer } from './models/renderer';
 import { Rendering, RenderOptions } from './models/rendering';
 import { TestSetup } from './models/test-setup';
-import './tools/jasmine-matchers';
+import './test-frameworks/matchers';
 
 export class Shallow<TTestComponent> {
   readonly setup: TestSetup<TTestComponent>;

lib/test-framework.ts

@@ -0,0 +1,9 @@
+import { TestFramework } from './test-frameworks';
+import { JasmineFramework } from './test-frameworks/jasmine.framework';
+import { JestFramework } from './test-frameworks/jest.framework';
+
+declare var jest: any;
+
+export const testFramework: TestFramework = typeof jest === 'undefined'
+  ? new JasmineFramework()
+  : new JestFramework();

lib/test-frameworks/index.ts

@@ -0,0 +1,52 @@
+export interface TestFramework {
+  isSpy(mockFunction: AnyFunction): boolean;
+
+  spyOn<T>(object: T, method: keyof T, mockImplementation?: AnyFunction): any;
+
+  resetSpy<T>(spy: T): void;
+
+  mockImplementation<T>(spy: T, mockImplementation: AnyFunction): void;
+
+  addMatchers(matcherFactories: CustomMatcherFactories): void;
+}
+
+export type AnyFunction = (args?: any) => any;
+
+export interface CustomMatcher {
+  compare<T>(actual: T, expected: T, ...args: any[]): CustomMatcherResult;
+
+  compare(actual: any, ...expected: any[]): CustomMatcherResult;
+}
+
+export interface CustomMatcherFactories {
+  [index: string]: CustomMatcherFactory;
+}
+
+export type CustomMatcherFactory = (
+  util: MatchersUtil,
+  customEqualityTesters: CustomEqualityTester[],
+) => CustomMatcher;
+
+export interface MatchersUtil {
+  equals(a: any, b: any, customTesters?: CustomEqualityTester[]): boolean;
+
+  contains<T>(
+    haystack: ArrayLike<T> | string,
+    needle: any,
+    customTesters?: CustomEqualityTester[],
+  ): boolean;
+
+  buildFailureMessage(
+    matcherName: string,
+    isNot: boolean,
+    actual: any,
+    ...expected: any[]
+  ): string;
+}
+
+export type CustomEqualityTester = (first: any, second: any) => boolean | void;
+
+export interface CustomMatcherResult {
+  pass: boolean;
+  message?: string;
+}

lib/test-frameworks/jasmine.framework.ts

@@ -0,0 +1,38 @@
+import { AnyFunction, CustomMatcherFactories, TestFramework } from './index';
+import { BaseArrayLikeMatchers } from './matchers';
+
+declare var jasmine: any;
+
+export class JasmineFramework implements TestFramework {
+  isSpy = (mockFunction: AnyFunction): boolean => jasmine.isSpy(mockFunction);
+
+  spyOn<T>(object: T, method: keyof T, mockImplementation?: AnyFunction) {
+    const spy = spyOn(object, method);
+
+    if (!mockImplementation) {
+      return spy.and.callThrough();
+    }
+
+    this.mockImplementation(spy, mockImplementation);
+
+    return spy;
+  }
+
+  mockImplementation(spy: any, mockImplementation: (args?: any) => any): void {
+    spy.and.callFake(mockImplementation);
+  }
+
+  resetSpy(spy: any): void {
+    spy.calls.reset();
+  }
+
+  addMatchers(matcherFactories: CustomMatcherFactories): void {
+    jasmine.addMatchers(matcherFactories);
+  }
+}
+
+declare global {
+  namespace jasmine {
+    export interface ArrayLikeMatchers<T> extends BaseArrayLikeMatchers<T> {}
+  }
+}

lib/test-frameworks/jest.framework.ts

@@ -0,0 +1,37 @@
+import { AnyFunction, CustomMatcherFactories, TestFramework } from './index';
+import { BaseArrayLikeMatchers } from './matchers';
+
+declare var jest: any;
+declare var expect: any;
+
+export class JestFramework implements TestFramework {
+  isSpy = (mockFunction: any): boolean => jest.isMockFunction(mockFunction);
+
+  spyOn<T>(object: T, method: keyof T, mockImplementation?: AnyFunction) {
+    const spy = jest.spyOn(object, method);
+
+    if (!!mockImplementation) {
+      this.mockImplementation(spy, mockImplementation);
+    }
+
+    return spy;
+  }
+
+  mockImplementation(spy: any, mockImplementation: AnyFunction): void {
+    spy.mockImplementation(mockImplementation);
+  }
+
+  resetSpy(spy: any): void {
+    spy.mockReset();
+  }
+
+  addMatchers(matcherFactories: CustomMatcherFactories): void {
+    expect.extend(matcherFactories);
+  }
+}
+
+declare global {
+  namespace jest {
+    export interface ArrayLikeMatchers<T> extends BaseArrayLikeMatchers<T> {}
+  }
+}

lib/tools/jasmine-matchers.spec.ts renamed to lib/test-frameworks/matchers.spec.ts

@@ -1,9 +1,18 @@
 import { QueryMatch } from '../models/query-match';
-// This import ensures JasmineMatchers are available any time
-// shallow is imported
-import './jasmine-matchers-namespace';
+import { testFramework } from '../test-framework';
+import { CustomMatcherFactories } from './index';
 
-const jasmineMatchers: jasmine.CustomMatcherFactories = {
+export interface BaseArrayLikeMatchers<T> {
+  toHaveFoundOne(): void;
+
+  toHaveFoundMoreThan(count: number): void;
+
+  toHaveFoundLessThan(count: number): void;
+
+  toHaveFound(count: number): void;
+}
+
+const matcherFactories: CustomMatcherFactories = {
   toHaveFound: () => ({
     compare: (actual: QueryMatch<any>, expected: number) => ({
       pass: actual.length === expected,
@@ -34,5 +43,5 @@ const jasmineMatchers: jasmine.CustomMatcherFactories = {
 };
 
 beforeAll(() => {
-  jasmine.addMatchers(jasmineMatchers);
+  testFramework.addMatchers(matcherFactories);
 });

lib/tools/jasmine-matchers.ts renamed to lib/test-frameworks/matchers.ts

@@ -1,9 +1,10 @@
 import { Component, Type } from '@angular/core';
+import { testFramework } from '../test-framework';
 
 const spyOnBindings = (bindings: any) => {
   Object.keys(bindings).forEach(key => {
-    if (typeof bindings[key] === 'function' && !(jasmine as any).isSpy(bindings[key])) {
-      spyOn(bindings, key).and.callThrough();
+    if (typeof bindings[key] === 'function' && !testFramework.isSpy(bindings[key])) {
+      testFramework.spyOn(bindings, key);
     }
   });
   return bindings;