test(cdk): fix broken tests

hoebbelsB · edbzn · commit 033153825e6e · 2023-02-07T22:34:37.000+01:00
diff --git a/libs/cdk/render-strategies/spec/onStrategy.spec.ts b/libs/cdk/render-strategies/spec/onStrategy.spec.ts
@@ -1,57 +1,45 @@
-import { ɵglobal } from '@angular/core';
 import { TestScheduler } from 'rxjs/testing';
 import { jestMatcher } from '@test-helpers';
-import { onStrategy, RX_NATIVE_STRATEGIES } from '@rx-angular/cdk/render-strategies';
-import { animationFrameScheduler, observeOn, of } from 'rxjs';
+import {
+  onStrategy,
+  RX_NATIVE_STRATEGIES,
+  RxStrategyCredentials,
+} from '@rx-angular/cdk/render-strategies';
+import { animationFrameScheduler, observeOn, tap } from 'rxjs';
 
 describe('onStrategy', () => {
-
   let testScheduler: TestScheduler;
-  let handles = [];
-  let animationRuns = 0;
-  function _animate() {
-    handles.forEach(handle => handle());
-  }
-  let _animationFrameRestore;
-  let _cancelAnimationFrameRestore;
+  const animationFrameStrategy: RxStrategyCredentials = {
+    name: 'animationFrame',
+    work: (cdRef) => cdRef.detectChanges(),
+    behavior: ({ work }) => {
+      return (o$) =>
+        o$.pipe(
+          observeOn(animationFrameScheduler),
+          tap(() => work())
+        );
+    },
+  };
   beforeEach(() => {
     testScheduler = new TestScheduler(jestMatcher);
-    _animationFrameRestore = ɵglobal.requestAnimationFrame;
-    _cancelAnimationFrameRestore = ɵglobal.cancelAnimationFrame;
-    ɵglobal.requestAnimationFrame = (cb?) => {
-      handles[animationRuns] = cb;
-      animationRuns++;
-      return animationRuns;
-    }
-    ɵglobal.cancelAnimationFrame = (id: number) => {
-      handles = handles.splice(id, 1);
-    }
-  });
-
-
-  afterEach(() => {
-    ɵglobal.requestAnimationFrame = _animationFrameRestore;
-    ɵglobal.cancelAnimationFrame = _cancelAnimationFrameRestore;
-    animationRuns = 0;
-    handles = [];
   });
 
   it('should emit 42', () => {
-    testScheduler.run(({expectObservable}) => {
+    testScheduler.run(({ expectObservable }) => {
       const work = jest.fn();
       const values = { x: 42 };
       const stream$ = onStrategy(values.x, RX_NATIVE_STRATEGIES.native, work);
       const expected = '(x|)';
-      expectObservable(stream$).toBe(expected, values)
+      expectObservable(stream$).toBe(expected, values);
     });
   });
 
   it('should throw error', () => {
-    testScheduler.run(({expectObservable}) => {
+    testScheduler.run(({ expectObservable }) => {
       const error = new Error('error');
       const work = () => {
         throw error;
-      }
+      };
       const value = 42;
       const errorValues = [error, value];
       const expected = '#';
@@ -65,20 +53,22 @@ describe('onStrategy', () => {
       const work = jest.fn();
       animate('         --------x');
       const expected = '--------(x|)';
-      of(null).pipe(observeOn(animationFrameScheduler)).subscribe(() => {
-        _animate();
-      });
       const values = { x: 42 };
-      const stream$ = onStrategy(values.x, RX_NATIVE_STRATEGIES.local, work);
+      const stream$ = onStrategy(values.x, animationFrameStrategy, work);
       expectObservable(stream$).toBe(expected, values);
     });
   });
 
   it('it should call work once when async', () => {
     const work = jest.fn();
-    onStrategy(42, RX_NATIVE_STRATEGIES.local, work).subscribe();
-    expect(work).not.toHaveBeenCalled();
-    _animate();
+    testScheduler.run(({ expectObservable, animate }) => {
+      animate('         --------x');
+      const expected = '--------(x|)';
+      const values = { x: 42 };
+      const stream$ = onStrategy(values.x, animationFrameStrategy, work);
+      expect(work).not.toHaveBeenCalled();
+      expectObservable(stream$).toBe(expected, values);
+    });
     expect(work).toHaveBeenCalledTimes(1);
   });
 
diff --git a/libs/cdk/zone-less/rxjs/spec/scheduler/asapScheduler.spec.ts b/libs/cdk/zone-less/rxjs/spec/scheduler/asapScheduler.spec.ts
@@ -4,23 +4,28 @@ import { RxTestScheduler } from '../../src/testing/test-scheduler';
 import { jestMatcher } from '@test-helpers';
 import { Subscription, SchedulerAction, merge } from 'rxjs';
 import { delay } from 'rxjs/operators';
-import { AsapAction } from '../../src/scheduler/asap/AsapAction';
 import { AsapScheduler } from '../../src/scheduler/asap/AsapScheduler';
+import { asapScheduler } from '../../src/scheduler/asap/asap';
 
-let asap: AsapScheduler;
+const asap: AsapScheduler = asapScheduler;
 
 /** @test {Scheduler} */
 describe('Scheduler.asap', () => {
   let testScheduler: RxTestScheduler;
+  const proxyZone = window['Zone']['ProxyZoneSpec'];
 
   beforeEach(() => {
     testScheduler = new RxTestScheduler(jestMatcher);
-    asap = new AsapScheduler(AsapAction);
+    window['Zone']['ProxyZoneSpec'] = undefined;
     jest.clearAllTimers();
     jest.useRealTimers();
     jest.clearAllMocks();
   });
 
+  afterEach(() => {
+    window['Zone']['ProxyZoneSpec'] = proxyZone;
+  });
+
   it('should exist', () => {
     expect(asap).toBeDefined();
   });
@@ -66,6 +71,10 @@ describe('Scheduler.asap', () => {
     jest.useFakeTimers();
     // callThrough is missing from the declarations installed by the typings tool in stable
     const intervalSpy = jest.spyOn(intervalProvider, 'setInterval');
+    intervalProvider.delegate = {
+      setInterval: setInterval,
+      clearInterval: clearInterval,
+    };
     const period = 50;
     const state = { index: 0, period };
     type State = typeof state;
@@ -80,17 +89,22 @@ describe('Scheduler.asap', () => {
     expect(state).toHaveProperty('index', 0);
     expect(intervalSpy).toHaveBeenCalledTimes(1);
     jest.advanceTimersByTime(period);
-    // expect(state).toHaveProperty('index', 1);
+    expect(state).toHaveProperty('index', 1);
     expect(intervalSpy).toHaveBeenCalledTimes(2);
     jest.advanceTimersByTime(period);
     expect(state).toHaveProperty('index', 2);
     expect(intervalSpy).toHaveBeenCalledTimes(3);
+    intervalProvider.delegate = undefined;
   });
 
   it('should reuse the interval for recursively scheduled actions with the same delay', () => {
     jest.useFakeTimers();
     // callThrough is missing from the declarations installed by the typings tool in stable
     const intervalSpy = jest.spyOn(intervalProvider, 'setInterval');
+    intervalProvider.delegate = {
+      setInterval: setInterval,
+      clearInterval: clearInterval,
+    };
     const period = 50;
     const state = { index: 0, period };
     type State = typeof state;
@@ -103,12 +117,13 @@ describe('Scheduler.asap', () => {
     asap.schedule(dispatch as any, period, state);
     expect(state).toHaveProperty('index', 0);
     expect(intervalSpy).toHaveBeenCalledTimes(1);
-    jest.advanceTimersByTime(period + 1);
+    jest.advanceTimersByTime(period);
     expect(state).toHaveProperty('index', 1);
     expect(intervalSpy).toHaveBeenCalledTimes(1);
     jest.advanceTimersByTime(period);
     expect(state).toHaveProperty('index', 2);
     expect(intervalSpy).toHaveBeenCalledTimes(1);
+    intervalProvider.delegate = undefined;
   });
 
   it('should schedule an action to happen later', (done) => {
