feat(test): add jest timers patch, refactor jasmine.expect

Author: JiaLiPassion

lib/mocha/jasmine-bridge/jasmine.expect.ts

@@ -265,6 +265,14 @@ export function addJasmineSpy(jasmine: any, Mocha: any, global: any) {
       });
     }
 
+    clearAllSpies() {
+      if (this.registeredSpies.length === 0) {
+        return;
+      }
+      this.registeredSpies.forEach(spy => spy.unRegister());
+      this.registeredSpies.length = 0;
+    }
+
     clearSpies(testInfo: any) {
       if (this.registeredSpies.length === 0) {
         return;
@@ -289,6 +297,10 @@ export function addJasmineSpy(jasmine: any, Mocha: any, global: any) {
     spyRegistry.clearSpies(testInfo);
   };
 
+  Mocha.clearAllSpies = function() {
+    spyRegistry.clearAllSpies();
+  };
+
   jasmine.createSpy = function(spyName: string|Function, originalFn?: Function) {
     if (typeof spyName === 'function') {
       originalFn = spyName;

lib/mocha/jasmine-bridge/jasmine.spy.ts

@@ -135,7 +135,9 @@ export function eq(a: any, b: any) {
     if (Object.keys(a).length !== Object.keys(b).length) {
       return false;
     }
-
+    if (a instanceof Error && b instanceof Error) {
+      return a.message === b.message;
+    }
     let isEqual = true;
 
     for (let prop in a) {
@@ -154,10 +156,44 @@ export function eq(a: any, b: any) {
     return b.eq(a);
   }
 
+  if (a instanceof Error && typeof b === 'string') {
+    return a.message === b;
+  }
+  if (b instanceof Error && typeof a === 'string') {
+    return a === b.message;
+  }
+
   return false;
 }
 
 export function toMatch(actual: any, expected: any) {
-  const regExp = actual instanceof RegExp ? actual : new RegExp(actual);
-  return regExp.test(expected);
+  const regExp = expected instanceof RegExp ? expected : new RegExp(expected);
+  return regExp.test(actual);
+}
+
+const Mocha: any = typeof window === 'undefined' ? (global as any).Mocha : (window as any).Mocha;
+
+export function formatObject(obj: any) {
+  const stringify = Mocha.utils && Mocha.utils.stringify;
+  return stringify(obj);
+}
+
+export function buildFailureMessage(
+    matcherName: string, isNot: boolean, actual: any, ...expected: any[]) {
+  const englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) {
+    return ' ' + s.toLowerCase();
+  });
+
+  var message = 'Expected ' + formatObject(actual) + (isNot ? ' not ' : ' ') + englishyPredicate;
+
+  if (expected.length > 0) {
+    for (var i = 0; i < expected.length; i++) {
+      if (i > 0) {
+        message += ',';
+      }
+      message += ' ' + formatObject(expected[i]);
+    }
+  }
+
+  return message + '.';
 }

lib/mocha/jasmine-bridge/jasmine.util.ts

@@ -0,0 +1,95 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export function addJestTimer(jest: any, global: any) {
+  const {resetFakeAsyncZone, flushMicrotasks, discardPeriodicTasks, tick, flush, fakeAsync} =
+      (Zone as any)[Zone.__symbol__('fakeAsyncTest')];
+  const FakeAsyncTestZoneSpec = (Zone as any)['FakeAsyncTestZoneSpec'];
+  const ProxyZoneSpec = (Zone as any)['ProxyZoneSpec'];
+
+  function getFakeAsyncTestZoneSpec() {
+    return Zone.current.get('FakeAsyncTestZoneSpec');
+  }
+
+  jest.clearAllTimers = function() {
+    const zs = getFakeAsyncTestZoneSpec();
+    if (!zs) {
+      return;
+    }
+    // TODO: @JiaLiPassion, add clear method in fakeAsyncZoneSpec
+    // flush();
+  };
+
+  jest.runAllTimers = function() {
+    const zs = getFakeAsyncTestZoneSpec();
+    if (!zs) {
+      return;
+    }
+    // TODO: @JiaLiPassion, now flush can only flush
+    // non periodic timers, should flush periodic too.
+    flush();
+  };
+
+  jest.runAllImmediates = function() {
+    const zs = getFakeAsyncTestZoneSpec();
+    if (!zs) {
+      return;
+    }
+    // TODO: @JiaLiPassion, should we support this one?
+    flush();
+  };
+
+  jest.runOnlyPendingTimers = function() {
+    const zs = getFakeAsyncTestZoneSpec();
+    if (!zs) {
+      return;
+    }
+    // TODO: @JiaLiPassion, should we support this one?
+    flush();
+  };
+
+  jest.advanceTimersByTime = function(msToRun: number) {
+    const zs = getFakeAsyncTestZoneSpec();
+    if (!zs) {
+      return;
+    }
+    tick(msToRun);
+  };
+
+
+  jest.runAllTicks = function() {
+    const zs = getFakeAsyncTestZoneSpec();
+    if (!zs) {
+      return;
+    }
+    flushMicrotasks();
+  };
+
+  jest.useFakeTimers = function() {
+    const zs = getFakeAsyncTestZoneSpec();
+    if (zs) {
+      return;
+    }
+    const fakeAsyncTestZoneSpec = new FakeAsyncTestZoneSpec()
+    const proxyZoneSpec = ProxyZoneSpec.get();
+    jest.__zone_symbol__last_delegate_spec = proxyZoneSpec.getDelegate();
+    proxyZoneSpec.setDelegate(fakeAsyncTestZoneSpec);
+    fakeAsyncTestZoneSpec.lockDatePatch();
+  };
+
+  jest.useRealTimers = function() {
+    const zs = getFakeAsyncTestZoneSpec();
+    if (!zs) {
+      throw new Error('Must use real timers in the same block with useFakeTimers');
+    }
+    const proxyZoneSpec = ProxyZoneSpec.get();
+    const lastDelegate = jest.__zone_symbol__last_delegate_spec;
+    jest.__zone_symbol__last_delegate_spec = null;
+    proxyZoneSpec.setDelegate(lastDelegate);
+    zs.unlockDatePatch();
+  }
+}

lib/mocha/jest-bridge/jest.clock.ts

@@ -109,7 +109,7 @@ export function expandExpect(global: any) {
     if (b instanceof ObjectContaining) {
       Object.keys(b.expectedObject).forEach(key => {
         if (b.expectedObject.hasOwnProperty(key)) {
-          if (!eq(a[key], b.expectedObject[key]) || !toMatch(b.expectedObject[key], a[key])) {
+          if (!eq(a[key], b.expectedObject[key]) || !toMatch(a[key], b.expectedObject[key])) {
             return false;
           }
         }
@@ -131,7 +131,7 @@ export function expandExpect(global: any) {
       if (typeof a !== 'string') {
         astr = Object.prototype.toString.call(a);
       }
-      return toMatch(b.expectedMatcher, astr);
+      return toMatch(astr, b.expectedMatcher);
     }
   });
 
@@ -156,21 +156,21 @@ export function expandExpect(global: any) {
     toHaveBeenCalledTimes: function(util: any, customEqualityTester: any) {
       return {
         compare: function(actual: any, expected: any) {
-          return {pass: expected.calls.count() === actual};
+          return {pass: actual.calls.count() === expected};
         }
       };
     },
     lastCalledWith: function(util: any, customEqualityTester: any) {
       return {
         compare: function(actual: any, expected: any) {
-          return {pass: util.equals(actual, expected.calls.last().args)};
+          return {pass: util.equals(actual.calls.last().args, expected)};
         }
       };
     },
     toHaveBeenLastCalledWith: function(util: any, customEqualityTester: any) {
       return {
         compare: function(actual: any, expected: any) {
-          return {pass: util.equals(actual, expected.calls.last().args)};
+          return {pass: util.equals(actual.calls.last().args, expected)};
         }
       };
     },

lib/mocha/jest-bridge/jest.expect.ts

@@ -6,8 +6,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 export function mappingSpy(jest: any, jasmine: any, global: any) {
+  jest.__zone_symbol__mocks = [];
   function createSpy(spyFactory: (implFn?: Function) => any, implFn?: Function) {
-    const spy = jasmine.createSpy('jestSpy', implFn);
+    const spy = spyFactory(implFn);
     spy.defaultFn = implFn;
     const instances: any[] = [];
     const mockFn: any = function MockFn() {
@@ -101,6 +102,7 @@ export function mappingSpy(jest: any, jasmine: any, global: any) {
       global.Mocha.clearSpies(global.Mocha.__zone_symbol__current_ctx);
     };
 
+    jest.__zone_symbol__mocks.push(mockFn);
     return mockFn;
   }
 
@@ -112,4 +114,27 @@ export function mappingSpy(jest: any, jasmine: any, global: any) {
     return accessType ? createSpy(() => global['spyOnProperty'](obj, methodName, accessType)) :
                         createSpy(() => global['spyOn'](obj, methodName));
   };
+
+  jest.clearAllMocks = function() {
+    jest.__zone_symbol__mocks.forEach((mock: any) => {
+      mock.mockClear();
+    });
+    return jest;
+  };
+
+  jest.resetAllMocks = function() {
+    jest.__zone_symbol__mocks.forEach((mock: any) => {
+      mock.mockReset();
+    });
+    return jest;
+  };
+
+  jest.restoreAllMocks = function() {
+    global.Mocha.clearAllSpies();
+    return jest;
+  };
+
+  jest.isMockFunction = function(fn: Function) {
+    return jest.__zone_symbol__mocks.filter((m: any) => m === fn).length > 0;
+  };
 }

lib/mocha/jest-bridge/jest.spy.ts

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import {mappingBDD} from './jest.bdd';
+import {addJestTimer} from './jest.clock';
 import {expandExpect} from './jest.expect';
 import {mappingSpy} from './jest.spy';
 
@@ -16,6 +17,7 @@ Zone.__load_patch('jest2mocha', (global: any) => {
     return;
   }
   // TODO: @JiaLiPassion, now we only support jest in Mocha runner
+  // support jasmine later.
   if (global.Mocha['__zone_symbol__isBridge']) {
     return;
   }
@@ -26,4 +28,12 @@ Zone.__load_patch('jest2mocha', (global: any) => {
   mappingBDD(jest, global.Mocha, global);
   expandExpect(global);
   mappingSpy(jest, jasmine, global);
+  addJestTimer(jest, global);
+
+  jest.setTimeout = function(timeout: number) {
+    const ctx = global.Mocha.__zone_symbol__current_ctx;
+    if (ctx && typeof ctx.timeout === 'function') {
+      ctx.timeout(timeout);
+    }
+  };
 });

lib/mocha/jest-bridge/jest.ts

@@ -147,7 +147,7 @@ describe('expect', () => {
     });
 
     test('rejects to octopus', async () => {
-      await (expect(Promise.reject(new Error('octopus'))) as any).rejects.toThrow('octopus');
+      return await (expect(Promise.reject(new Error('octopus'))) as any).rejects.toThrow('octopus');
     });
   });