fix(cdk-render-strategies): don't send complete event to strategy-behavior (#954)

hoebbelsB · web-flow · commit 8df99ea948f0 · 2021-09-23T17:23:45.000+02:00
diff --git a/libs/cdk/spec/render-strategies/onStrategy.spec.ts b/libs/cdk/spec/render-strategies/onStrategy.spec.ts
@@ -0,0 +1,94 @@
+import { ɵglobal } from '@angular/core';
+import { TestScheduler } from 'rxjs/testing';
+import * as rxjs from 'rxjs';
+// tslint:disable-next-line:nx-enforce-module-boundaries
+import { jestMatcher } from '@test-helpers';
+// tslint:disable-next-line:nx-enforce-module-boundaries
+import { onStrategy, RX_NATIVE_STRATEGIES } from '@rx-angular/cdk';
+import { animationFrameScheduler, observeOn, of } from 'rxjs';
+
+// tslint:disable: no-duplicate-string
+describe('onStrategy', () => {
+
+  let testScheduler: TestScheduler;
+  let handles = [];
+  let animationRuns = 0;
+  function _animate() {
+    handles.forEach(handle => handle());
+  }
+  let _animationFrameRestore;
+  let _cancelAnimationFrameRestore;
+  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}) => {
+      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)
+    });
+  });
+
+  it('should throw error', () => {
+    testScheduler.run(({expectObservable}) => {
+      const error = new Error('error');
+      const work = () => {
+        throw error;
+      }
+      const value = 42;
+      const errorValues = [error, value];
+      const expected = '#';
+      const stream$ = onStrategy(value, RX_NATIVE_STRATEGIES.native, work);
+      expectObservable(stream$).toBe(expected, null, errorValues);
+    });
+  });
+
+  it('should run on animationFrame', () => {
+    testScheduler.run(({ expectObservable, animate }) => {
+      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);
+      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();
+    expect(work).toHaveBeenCalledTimes(1);
+  });
+
+  it('it should call work', () => {
+    const work = jest.fn();
+    onStrategy(42, RX_NATIVE_STRATEGIES.native, work).subscribe();
+    expect(work).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/libs/cdk/src/lib/utils/onStrategy.ts b/libs/cdk/src/lib/utils/onStrategy.ts
@@ -1,41 +1,14 @@
 import { RxCoalescingOptions } from '@rx-angular/cdk/coalescing';
-import { switchMap } from 'rxjs/operators';
+import { switchMap, take } from 'rxjs/operators';
 import {
   RxRenderWork,
   RxStrategyCredentials,
 } from '../model';
-import { Observable, Observer, of, throwError } from 'rxjs';
+import { Observable, of, throwError } from 'rxjs';
 import {
-  RxRenderError,
   RxRenderErrorFactory,
 } from '../template-management/render-error';
 
-/**
- * @internal
- *
- * @param value
- * @param strategy
- * @param workFactory
- * @param options
- */
-/*export function onStrategy<T>(
-  value: T,
-  strategy: RxStrategyCredentials,
-  workFactory: (
-    value: T,
-    work: RxRenderWork,
-    options: RxCoalescingOptions
-  ) => void,
-  options: RxCoalescingOptions = {}
-): Observable<T> {
-  return of(value).pipe(
-    strategy.behavior(
-      () => workFactory(value, strategy.work, options),
-      options.scope || {}
-    )
-  );
-}*/
-
 /**
  * @internal
  *
@@ -57,7 +30,9 @@ export function onStrategy<T>(
   errorFactory: RxRenderErrorFactory<T, any> = (e, v) => [e, v]
 ): Observable<T> {
   let error: Error;
-  return of(value).pipe(
+  return new Observable<T>(subscriber => {
+    subscriber.next(value);
+  }).pipe(
     strategy.behavior(() => {
       try {
         workFactory(value, strategy.work, options);
@@ -67,6 +42,7 @@ export function onStrategy<T>(
     }, options.scope || {}),
     switchMap(() =>
       error ? throwError(errorFactory(error, value)) : of(value)
-    )
+    ),
+    take(1)
   );
 }
