Question

我有一个效果，每次它收到一个以上“一种”动作时都会被调用

myEffect.effect.ts

  someEffect$ = createEffect(() =>
    this.actions$.pipe(
      ofType(fromActions.actionOne, fromActions.actionTwo),
      exhaustMap(() => {
        return this.myService.getSomeDataViaHTTP().pipe(
          map((data) =>
            fromActions.successAction({ payload: data})
          ),
          catchError((err) =>
            ObservableOf(fromActions.failAction({ payload: err }))
          )
        );
      })
    )
  );

在测试中，我试图“模拟两个不同的动作，但是我总是会遇到一个错误，而如果我尝试一个动作，它就可以很好地工作

每个部分之前

describe('MyEffect', () => {
  let actions$: Observable<Action>;
  let effects: MyEffect;
  let userServiceSpy: jasmine.SpyObj<MyService>;
  const data = {
  // Some data structure
  };
  beforeEach(() => {
    const spy = jasmine.createSpyObj('MyService', [
      'getSomeDataViaHTTP',
    ]);
    TestBed.configureTestingModule({
      providers: [
        MyEffect,
        provideMockActions(() => actions$),
        {
          provide: MyService,
          useValue: spy,
        },
      ],
    });

    effects = TestBed.get(MyEffect);
    userServiceSpy = TestBed.get(MyService);
  });

这很好用

    it('should return successActionsuccessAction', () => {
    const action = actionOne();
    const outcome = successAction({ payload: data });

    actions$ = hot('-a', { a: action });
    const response = cold('-a|', { a: data });
    userServiceSpy.getSomeDataViaHTTP.and.returnValue(response);

    const expected = cold('--b', { b: outcome });
    expect(effects.someEffect$).toBeObservable(expected);
  });

这不起作用

it('should return successAction', () => {
const actions = [actionOne(), actionTwo()];
const outcome = successAction({ payload: data });
actions$ = hot('-a-b', { a: actions[0], b: actions[1] });
const response = cold('-a-a', { a: data });
userServiceSpy.getSomeDataViaHTTP.and.returnValue(response);
const expected = cold('--b--b', { b: outcome });
expect(effects.someEffect$).toBeObservable(expected);
});

Answer 1

此代码中有两个问题。

这表明getSomeDataViaHTTP返回两个值。这是错误的，响应与您的第一个示例没什么不同：'-a |'
它希望第二个successAction将在40毫秒后出现（--b--b，计算破折号）。这是不正确的，因为actionTwo在20 ms（-a-a）之后发生，响应又需要10 ms（-a）。因此，第一个成功动作在20ms（10 + 10）之后，第二个在30ms（20 + 10）之后。大理石是：“-b-b”。

Input actions     : -a -a
1st http response :  -a
2nd http response :     -a
Output actions    : --b -b

工作代码：

it('should return successAction', () => {
  const actions = [actionOne(), actionTwo()];
  actions$ = hot('-a-b', { a: actions[0], b: actions[1] });

  const response = cold('-a|', { a: data });
  userServiceSpy.getSomeDataViaHTTP.and.returnValue(response);

  const outcome = successAction({ payload: data });
  const expected = cold('--b-b', { b: outcome });
  expect(effects.someEffect$).toBeObservable(expected);
});

大理石测试很酷，但是它涉及您应该准备的一些黑魔法。我非常建议您仔细阅读this excellent article，以更深入地了解该主题。

如何正确使用茉莉花大理石来测试ofType中的多个动作

1 个答案: