perf(component): reset state / trigger CD only if necessary (#3328)

modules/component/spec/core/potential-observable.spec.ts

@@ -0,0 +1,55 @@
+import { of } from 'rxjs';
+import { TestScheduler } from 'rxjs/testing';
+import { fromPotentialObservable } from '../../src/core/potential-observable';
+
+describe('fromPotentialObservable', () => {
+  function setup() {
+    return {
+      testScheduler: new TestScheduler((actual, expected) =>
+        expect(actual).toEqual(expected)
+      ),
+    };
+  }
+
+  function testNullishInput(input: null | undefined): void {
+    it(`should create observable from ${input}`, () => {
+      const { testScheduler } = setup();
+
+      testScheduler.run(({ expectObservable }) => {
+        const obs$ = fromPotentialObservable(input);
+        expectObservable(obs$).toBe('(x|)', { x: input });
+      });
+    });
+  }
+
+  testNullishInput(null);
+
+  testNullishInput(undefined);
+
+  it('should create observable from array', () => {
+    const { testScheduler } = setup();
+    const array = [1, 2, 3];
+
+    testScheduler.run(({ expectObservable }) => {
+      const obs$ = fromPotentialObservable(array);
+      expectObservable(obs$).toBe('(xyz|)', { x: 1, y: 2, z: 3 });
+    });
+  });
+
+  it('should create observable from promise', (done) => {
+    const promise = Promise.resolve(100);
+    const obs$ = fromPotentialObservable(promise);
+
+    // promises cannot be tested with test scheduler
+    obs$.subscribe((value) => {
+      expect(value).toBe(100);
+      done();
+    });
+  });
+
+  it('should return passed observable', () => {
+    const obs1$ = of('ngrx');
+    const obs2$ = fromPotentialObservable(obs1$);
+    expect(obs1$).toBe(obs2$);
+  });
+});

modules/component/spec/core/render-event/handlers.spec.ts

@@ -0,0 +1,55 @@
+import { combineRenderEventHandlers } from '../../../src/core/render-event/handlers';
+import {
+  CompleteRenderEvent,
+  ErrorRenderEvent,
+  NextRenderEvent,
+  RenderEvent,
+  ResetRenderEvent,
+} from '../../../src/core/render-event/models';
+
+describe('combineRenderEventHandlers', () => {
+  function testRenderEvent<T>(event: RenderEvent<T>): void {
+    describe(`when ${event.type} is emitted`, () => {
+      it(`should call ${event.type} handler`, () => {
+        const mockHandler = jest.fn();
+        const handleRenderEvent = combineRenderEventHandlers({
+          [event.type]: mockHandler,
+        });
+
+        handleRenderEvent(event);
+        expect(mockHandler).toHaveBeenCalledWith(event);
+      });
+
+      it(`should not throw error if ${event.type} handler is not defined`, () => {
+        const handleRenderEvent = combineRenderEventHandlers({});
+        expect(() => handleRenderEvent(event)).not.toThrowError();
+      });
+    });
+  }
+
+  const resetEvent: ResetRenderEvent = {
+    type: 'reset',
+    reset: true,
+  };
+  testRenderEvent(resetEvent);
+
+  const nextEvent: NextRenderEvent<number> = {
+    type: 'next',
+    value: 1,
+    reset: true,
+  };
+  testRenderEvent(nextEvent);
+
+  const errorEvent: ErrorRenderEvent = {
+    type: 'error',
+    error: 'ERROR!',
+    reset: false,
+  };
+  testRenderEvent(errorEvent);
+
+  const completeEvent: CompleteRenderEvent = {
+    type: 'complete',
+    reset: false,
+  };
+  testRenderEvent(completeEvent);
+});