Merge pull request #199 from ngrx/master

Convert Unsupported Operations

Author: GulajavaMinistudio

.circleci/config.yml

@@ -97,7 +97,7 @@ jobs:
       - checkout
       - restore_cache:
           key: *cache_key
-      - run: yarn run example:test --watch=false
+      - run: yarn run example:test --watch=false --runInBand
 
   example-e2e-tests:
     <<: *run_in_browser
@@ -207,9 +207,9 @@ workflows:
       - example-tests:
           requires:
             - install
-      - example-e2e-tests:
-          requires:
-            - install
+      # - example-e2e-tests:
+      #     requires:
+      #       - install
       - docs-tests:
           requires:
             - install
@@ -226,7 +226,7 @@ workflows:
           requires:
             - docs
             - example-tests
-            - example-e2e-tests
+            # - example-e2e-tests
             - docs-tests
             - test
           filters:

modules/effects/spec/actions.spec.ts

@@ -1,9 +1,10 @@
 import { Injector } from '@angular/core';
 import {
   Action,
-  StoreModule,
+  props,
   ScannedActionsSubject,
   ActionsSubject,
+  createAction,
 } from '@ngrx/store';
 import { Actions, ofType } from '../';
 import { map, toArray, switchMap } from 'rxjs/operators';
@@ -25,16 +26,12 @@ describe('Actions', function() {
     type: 'SUBTRACT';
   }
 
-  function reducer(state: number = 0, action: Action) {
-    switch (action.type) {
-      case ADD:
-        return state + 1;
-      case SUBTRACT:
-        return state - 1;
-      default:
-        return state;
-    }
-  }
+  const square = createAction('SQUARE');
+  const multiply = createAction('MULTYPLY', props<{ by: number }>());
+  const divide = createAction('DIVIDE', props<{ by: number }>());
+
+  // Class-based Action types
+  const actions = [ADD, ADD, SUBTRACT, ADD, SUBTRACT];
 
   beforeEach(function() {
     const injector = Injector.create([
@@ -69,12 +66,12 @@ describe('Actions', function() {
     });
 
     actions.forEach(action => dispatcher.next(action));
+    dispatcher.complete();
   });
 
-  const actions = [ADD, ADD, SUBTRACT, ADD, SUBTRACT];
-  const expected = actions.filter(type => type === ADD);
+  it('should filter out actions', () => {
+    const expected = actions.filter(type => type === ADD);
 
-  it('should let you filter out actions', function() {
     actions$
       .pipe(
         ofType(ADD),
@@ -83,15 +80,17 @@ describe('Actions', function() {
       )
       .subscribe({
         next(actual) {
-          expect(actual).toEqual(expected as any[]);
+          expect(actual).toEqual(expected);
         },
       });
 
     actions.forEach(action => dispatcher.next({ type: action }));
     dispatcher.complete();
   });
 
-  it('should let you filter out actions and ofType can take an explicit type argument', function() {
+  it('should filter out actions and ofType can take an explicit type argument', () => {
+    const expected = actions.filter(type => type === ADD);
+
     actions$
       .pipe(
         ofType<AddAction>(ADD),
@@ -100,11 +99,192 @@ describe('Actions', function() {
       )
       .subscribe({
         next(actual) {
-          expect(actual).toEqual(expected as any[]);
+          expect(actual).toEqual(expected);
+        },
+      });
+
+    actions.forEach(action => dispatcher.next({ type: action }));
+    dispatcher.complete();
+  });
+
+  it('should let you filter out multiple action types with explicit type argument', () => {
+    const expected = actions.filter(type => type === ADD || type === SUBTRACT);
+
+    actions$
+      .pipe(
+        ofType<AddAction | SubtractAction>(ADD, SUBTRACT),
+        map(update => update.type),
+        toArray()
+      )
+      .subscribe({
+        next(actual) {
+          expect(actual).toEqual(expected);
+        },
+      });
+
+    actions.forEach(action => dispatcher.next({ type: action }));
+    dispatcher.complete();
+  });
+
+  it('should filter out actions by action creator', () => {
+    actions$
+      .pipe(
+        ofType(square),
+        map(update => update.type),
+        toArray()
+      )
+      .subscribe({
+        next(actual) {
+          expect(actual).toEqual(['SQUARE']);
+        },
+      });
+
+    [...actions, square.type].forEach(action =>
+      dispatcher.next({ type: action })
+    );
+    dispatcher.complete();
+  });
+
+  it('should infer the type for the action when it is filter by action creator with property', () => {
+    const MULTYPLY_BY = 5;
+
+    actions$
+      .pipe(
+        ofType(multiply),
+        map(update => update.by),
+        toArray()
+      )
+      .subscribe({
+        next(actual) {
+          expect(actual).toEqual([MULTYPLY_BY]);
         },
       });
 
+    // Unrelated Actions
     actions.forEach(action => dispatcher.next({ type: action }));
+    // Action under test
+    dispatcher.next(multiply({ by: MULTYPLY_BY }));
+    dispatcher.complete();
+  });
+
+  it('should infer the type for the action when it is filter by action creator', () => {
+    // Types are not provided for generic Actions
+    const untypedActions$: Actions = actions$;
+    const MULTYPLY_BY = 5;
+
+    untypedActions$
+      .pipe(
+        ofType(multiply),
+        // Type is infered, even though untypedActions$ is Actions<Action>
+        map(update => update.by),
+        toArray()
+      )
+      .subscribe({
+        next(actual) {
+          expect(actual).toEqual([MULTYPLY_BY]);
+        },
+      });
+
+    // Unrelated Actions
+    actions.forEach(action => dispatcher.next({ type: action }));
+    // Action under test
+    dispatcher.next(multiply({ by: MULTYPLY_BY }));
+    dispatcher.complete();
+  });
+
+  it('should filter out multiple actions by action creator', () => {
+    const DIVIDE_BY = 3;
+    const MULTYPLY_BY = 5;
+    const expected = [DIVIDE_BY, MULTYPLY_BY];
+
+    actions$
+      .pipe(
+        ofType(divide, multiply),
+        // Both have 'by' property
+        map(update => update.by),
+        toArray()
+      )
+      .subscribe({
+        next(actual) {
+          expect(actual).toEqual(expected);
+        },
+      });
+
+    // Unrelated Actions
+    actions.forEach(action => dispatcher.next({ type: action }));
+    // Actions under test, in specific order
+    dispatcher.next(divide({ by: DIVIDE_BY }));
+    dispatcher.next(divide({ by: MULTYPLY_BY }));
+    dispatcher.complete();
+  });
+
+  it('should filter out actions by action creator and type string', () => {
+    const expected = [...actions.filter(type => type === ADD), square.type];
+
+    actions$
+      .pipe(
+        ofType(ADD, square),
+        map(update => update.type),
+        toArray()
+      )
+      .subscribe({
+        next(actual) {
+          expect(actual).toEqual(expected);
+        },
+      });
+
+    [...actions, square.type].forEach(action =>
+      dispatcher.next({ type: action })
+    );
+
+    dispatcher.complete();
+  });
+
+  it('should filter out actions by action creator and type string, with explicit type argument', () => {
+    const expected = [...actions.filter(type => type === ADD), square.type];
+
+    actions$
+      .pipe(
+        // Provided type overrides any inference from arguments
+        ofType<AddAction | ReturnType<typeof square>>(ADD, square),
+        map(update => update.type),
+        toArray()
+      )
+      .subscribe({
+        next(actual) {
+          expect(actual).toEqual(expected);
+        },
+      });
+
+    [...actions, square.type].forEach(action =>
+      dispatcher.next({ type: action })
+    );
+
+    dispatcher.complete();
+  });
+
+  it('should filter out up to 5 actions with type inference', () => {
+    // Mixing all of them, up to 5
+    const expected = [divide.type, ADD, square.type, SUBTRACT, multiply.type];
+
+    actions$
+      .pipe(
+        ofType(divide, ADD, square, SUBTRACT, multiply),
+        map(update => update.type),
+        toArray()
+      )
+      .subscribe({
+        next(actual) {
+          expect(actual).toEqual(expected);
+        },
+      });
+
+    // Actions under test, in specific order
+    dispatcher.next(divide({ by: 1 }));
+    dispatcher.next({ type: ADD });
+    dispatcher.next(square());
+    dispatcher.next({ type: SUBTRACT });
+    dispatcher.next(multiply({ by: 2 }));
     dispatcher.complete();
   });
 });

modules/effects/spec/create_effect.spec.ts

@@ -0,0 +1,61 @@
+import { of } from 'rxjs';
+import { createEffect, getCreateEffectMetadata } from '../src/effect_creator';
+
+describe('createEffect()', () => {
+  it('should flag the variable with a meta tag', () => {
+    const effect = createEffect(() => of({ type: 'a' }));
+
+    expect(effect.hasOwnProperty('__@ngrx/effects_create__')).toBe(true);
+  });
+
+  it('should dispatch by default', () => {
+    const effect: any = createEffect(() => of({ type: 'a' }));
+
+    expect(effect['__@ngrx/effects_create__']).toEqual({ dispatch: true });
+  });
+
+  it('should be possible to explicitly create a dispatching effect', () => {
+    const effect: any = createEffect(() => of({ type: 'a' }), {
+      dispatch: true,
+    });
+
+    expect(effect['__@ngrx/effects_create__']).toEqual({ dispatch: true });
+  });
+
+  it('should be possible to create a non-dispatching effect', () => {
+    const effect: any = createEffect(() => of({ type: 'a' }), {
+      dispatch: false,
+    });
+
+    expect(effect['__@ngrx/effects_create__']).toEqual({ dispatch: false });
+  });
+
+  describe('getCreateEffectMetadata', () => {
+    it('should get the effects metadata for a class instance', () => {
+      class Fixture {
+        a = createEffect(() => of({ type: 'a' }));
+        b = createEffect(() => of({ type: 'b' }), { dispatch: true });
+        c = createEffect(() => of({ type: 'c' }), { dispatch: false });
+      }
+
+      const mock = new Fixture();
+
+      expect(getCreateEffectMetadata(mock)).toEqual([
+        { propertyName: 'a', dispatch: true },
+        { propertyName: 'b', dispatch: true },
+        { propertyName: 'c', dispatch: false },
+      ]);
+    });
+
+    it('should return an empty array if the effect has not been created with createEffect()', () => {
+      const fakeCreateEffect: any = () => {};
+      class Fixture {
+        a = fakeCreateEffect(() => of({ type: 'A' }));
+      }
+
+      const mock = new Fixture();
+
+      expect(getCreateEffectMetadata(mock)).toEqual([]);
+    });
+  });
+});

modules/effects/spec/effect_decorator.spec.ts

@@ -0,0 +1,32 @@
+import { Effect, getEffectDecoratorMetadata } from '../src/effect_decorator';
+
+describe('@Effect()', () => {
+  describe('getEffectDecoratorMetadata', () => {
+    it('should get the effects metadata for a class instance', () => {
+      class Fixture {
+        @Effect() a: any;
+        @Effect() b: any;
+        @Effect({ dispatch: false })
+        c: any;
+      }
+
+      const mock = new Fixture();
+
+      expect(getEffectDecoratorMetadata(mock)).toEqual([
+        { propertyName: 'a', dispatch: true },
+        { propertyName: 'b', dispatch: true },
+        { propertyName: 'c', dispatch: false },
+      ]);
+    });
+
+    it('should return an empty array if the class has not been decorated', () => {
+      class Fixture {
+        a: any;
+      }
+
+      const mock = new Fixture();
+
+      expect(getEffectDecoratorMetadata(mock)).toEqual([]);
+    });
+  });
+});