如何測試角度 - catchError 運算符“rxjs”

Question

你能幫我測試一下代碼嗎？ 我無法測試可觀察間隔 (1000) 管道內的 catchError 運算符...

我不知道在 angular 中對間隔 (1000) 的可觀察量進行多少單元測試。 我需要模擬一個間隔的執行，並模擬錯誤。 我沒有做代碼，代碼已經完成，我是新員工，我被分配了做單元測試的任務。 不知道有沒有必要在一個時間間隔上catchError。

我的文件 ts 是：

import { Injectable, EventEmitter } from '@angular/core';
import {Subscription, Observable, interval, BehaviorSubject, throwError} from 'rxjs';
import {take, map, catchError, finalize} from 'rxjs/operators';
import { environment } from 'environments/environment';

/**
 * @Class CounterSessionProvider
 * @description This class is a provider for control session time
 * @author Andres Giraldo Londoño, Pragma S.A.
 */
@Injectable({
  providedIn: 'root',
})
export class CounterSessionProvider {
  // 4 minutes
  public inactivityTime = 20; // environment.inactivityTime; // environment.inactivityTime -> 20 seconds
  counterStateEmitter = new EventEmitter();
  currentSubscription: Subscription;
  public substracCounter$: BehaviorSubject<boolean>;

  constructor() {
    this.substracCounter$ = new BehaviorSubject(false);
  }

  public start() {
    this.currentSubscription = this.initInterval().subscribe();
  }

  public initInterval(): Observable<number> {
    return interval(1000).pipe(
      take(this.inactivityTime),
      map((index: number) => this.inactivityTime - (index + 1)),
      catchError(err => {
        this.counterStateEmitter.error(err);
        return throwError(err);
      })
    );
  }

  public restarCounterTime(): void {
    this.substracCounter$.next(true);
  }

  public stop() {
    if (this.currentSubscription) {
      this.currentSubscription.unsubscribe();
    }
    this.counterStateEmitter.emit('ABORTED');
  }
}

我的文件 spec.ts 是：

import {fakeAsync, TestBed, tick} from '@angular/core/testing';
import { CounterSessionProvider } from './counter-session.provider';
import {interval, Observable, Subscription, throwError} from 'rxjs';
import {catchError, take} from 'rxjs/operators';
import { TestScheduler } from 'rxjs/testing';

describe('CounterSessionProvider', () => {
  let counterSessionProvider: CounterSessionProvider;
  let scheduler: TestScheduler;

  beforeEach(() => {
    counterSessionProvider = new CounterSessionProvider();
  });

  /*beforeEach(() => {
    scheduler = new TestScheduler((actual, expected) => {
      expect(actual).toEqual(expected);
    });
  });*/

  /*it('should throw error when initInterval interval', fakeAsync(() => {
    scheduler.run(helpers => {
      spyOn(counterSessionProvider, 'initInterval').and.returnValue(throwError('ERROR'));
      const actions$ = helpers.hot('--a', { a: 1000 });
      const completion$ = helpers.cold('--c', { c: 1000 });
      expect(counterSessionProvider.initInterval).toBe(completion$);
    });
  }));*/

  it('should initialize currentSubscription from interval', fakeAsync(() => {
    let currentVal = null;
    const numberObservable = counterSessionProvider.initInterval();
    counterSessionProvider.currentSubscription = numberObservable.subscribe((value: number) => {
      currentVal = value;
    });
    tick(1000);
    expect(currentVal).toEqual(19);
    counterSessionProvider.currentSubscription.unsubscribe();
  }));

  it('should emit a String COMPLETE when start() is called', () => {
    spyOn(counterSessionProvider, 'start');
    counterSessionProvider.start();
    counterSessionProvider.counterStateEmitter.subscribe(value => {
      expect(value).toEqual('COMPLETE');
    });
    expect(counterSessionProvider.start).toHaveBeenCalled();
  });

  it('should call stop()', () => {
    spyOn(counterSessionProvider, 'stop');
    counterSessionProvider.currentSubscription = new Subscription();
    counterSessionProvider.stop();
    counterSessionProvider.counterStateEmitter.subscribe((value: string) => {
      expect(value).toEqual('ABORTED');
    });
    expect(counterSessionProvider.stop).toHaveBeenCalled();
  });

  it('should call method start and initilize currentSubscription', fakeAsync(() => {
    counterSessionProvider.start();
    tick(1000);
    counterSessionProvider.currentSubscription.unsubscribe();
    expect(counterSessionProvider.currentSubscription).not.toBeNull();
  }));

  it('should call restarCounterTime() and emit a TRUE', () => {
    counterSessionProvider.restarCounterTime();
    counterSessionProvider.substracCounter$.subscribe(value => expect(value).toBeTruthy());
  });

  it('should call method stop and emit ABORTED', fakeAsync(() => {
    counterSessionProvider.start();
    tick(1000);
    counterSessionProvider.stop();
  }));

  /*beforeEach(() => {
    counterSessionProvider = TestBed.get(CounterSessionProvider);
  });

  it('should be created', () => {
    expect(counterSessionProvider).toBeTruthy();
  });

  it('should return ABORTED when stop function is called', () => {
    counterSessionProvider.start();
    counterSessionProvider.counterState.subscribe((msg: string) => {
      expect(msg).toEqual('ABORTED');
    });
    counterSessionProvider.stop();
  });*/
});

但是我需要覆蓋你覆蓋的所有代碼。 在下圖中，我展示了我需要的覆蓋范圍。

嘗試應用 Shashank Vivek 給我的建議，它給出了以下結果：

Answer 1

這就是我的建議，為catchError throw一些東西，像這個演示一樣，否則不會調用catchError 。 我不確定是否應該刪除catchError ，您應該與團隊驗證它（因為它里面似乎有一些代碼）

組件.ts

  public initInterval(): Observable<number> {
    return interval(1000).pipe(
      take(this.inactivityTime),
      map((index: number) => {
        // write some condition to "throw" otherwise "catchError" is of now use
        if (this.inactivityTime > 30) {
          throw new Error('inactivityTime greater than 30');
        }
        return this.inactivityTime - (index + 1);
      }),
      catchError((err) => {
        this.counterStateEmitter.error(err);
        return throwError(err);
      }),
      finalize(() => {
        this.currentSubscription.unsubscribe();
        this.counterStateEmitter.emit('COMPLETE');
      })
    );
  }

然后spec.ts你設置條件拋出錯誤：

  it('should handle error in initInterval', fakeAsync(() => {
    let currentVal;
    let someError;
    spyOn(
      counterSessionProvider.counterStateEmitter,
      'error'
    ).and.callThrough();
    counterSessionProvider.inactivityTime = 35; // just to simulate the error event as per the code I have added
    const numberObservable = counterSessionProvider.initInterval();
    counterSessionProvider.currentSubscription = numberObservable.subscribe(
      (value: number) => {
        currentVal = value;
      },
      (err) => {
        someError = err;
      }
    );
    tick(1000);
    expect(currentVal).toBeUndefined();
    expect(someError).toBeDefined(); // you can also use .toBe('inactivityTime greater than 30')
    expect(counterSessionProvider.counterStateEmitter.error).toHaveBeenCalled();
    counterSessionProvider.currentSubscription.unsubscribe();
  }));

試一試，讓我知道這是否有效。

覆蓋截圖：