Tester le cas d'erreur avec des observables dans les services

Disons que j'ai un composant qui s'abonne à un service de la fonction:

export class Component {

   ...

    ngOnInit() {
        this.service.doStuff().subscribe(
            (data: IData) => {
              doThings(data);
            },
            (error: Error) => console.error(error)
        );
    };
};

Le abonnez-vous appel prend deux fonctions anonymes en tant que paramètres, j'ai réussi à créer un test unitaire pour les données de la fonction mais le Karma n'accepte pas la couverture de l'erreur.

Tester le cas d'erreur avec des observables dans les services

J'ai essayé d'espionnage sur la console.la fonction d'erreur, de lancer une erreur et puis attendre de l'espion d'avoir été appelé, mais qui n'est pas tout à fait le faire.

Mon test unitaire:

spyOn(console,'error').and.callThrough();

serviceStub = {
        doStuff: jasmine.createSpy('doStuff').and.returnValue(Observable.of(data)),
    };

    serviceStub.doStuff.and.returnValue(Observable.throw(

        'error!'
    ));

serviceStub.doStuff().subscribe(

    (res) => {

        *working test, can access res*
    },
    (error) => {

      console.error(error);
      console.log(error);  //Prints 'error!' so throw works.
      expect(console.error).toHaveBeenCalledWith('error!'); //Is true but won't be accepted for coverage.
    }
);

Quelle est la meilleure pratique pour tester les fonctions anonymes comme ceux-ci? Quel est le strict minimum pour sécuriser la couverture de test?

source d'informationauteur user3656550

  1. 10

    Ne sais pas exactement le but de ce code, vous montrez, ce qui est en train de tester une maquette de service. Le problème de couverture est avec le composant et l'erreur de rappel pour ne pas avoir été appelé (ce qui n'est appelée que lorsque il y a une erreur).

    Ce que je fais habituellement pour la plupart de mes observables services, est de créer une maquette dont les méthodes ne renvoie lui-même. La maquette de service a un subscribe méthode qui accepte les nexterroret complete rappels. L'utilisateur de la simulation devient le configurer pour ajouter une erreur de sorte que le error fonction est appelée, ou ajouter des données, de sorte que le next méthode est appelée. La chose que j'aime le plus, c'est que tout est synchrone.

    Ci-dessous est quelque chose comme ce que j'utilise normalement. C'est juste une classe abstraite pour les autres se moque de pour étendre. Il offre les fonctionnalités de base que observable fournit. L'extension se moquer de service doit-il suffit d'ajouter les méthodes dont il a besoin, de retour dans la méthode.

    import { Subscription } from 'rxjs/Subscription';

export abstract class AbstractMockObservableService {
  protected _subscription: Subscription;
  protected _fakeContent: any;
  protected _fakeError: any;

  set error(err) {
    this._fakeError = err;
  }

  set content(data) {
    this._fakeContent = data;
  }

  get subscription(): Subscription {
    return this._subscription;
  }

  subscribe(next: Function, error?: Function, complete?: Function): Subscription {
    this._subscription = new Subscription();
    spyOn(this._subscription, 'unsubscribe');

    if (next && this._fakeContent && !this._fakeError) {
      next(this._fakeContent);
    }
    if (error && this._fakeError) {
      error(this._fakeError);
    }
    if (complete) {
      complete();
    }
    return this._subscription;
  }
}

    Maintenant dans vos tests vous venez de faire quelque chose comme

    class MockService extends AbstractMockObservableService {
  doStuff() {
    return this;
  }
}

let mockService;
beforeEach(() => {
  mockService = new MockService();
  TestBed.configureTestingModule({
    providers: [{provide: SomeService, useValue: mockService }],
    declarations: [ TestComponent ]
  });
});
it('should call service success', () => {
  mockService.content = 'some content';
  let fixture = TestBed.createComponent(TestComponent);
  //test component for success case
});
it('should call service error', () => {
  mockService.error = 'Some error';
  let fixture = TestBed.createComponent(TestComponent);
  //test component for error case
  //this should handle your coverage problem
});

//this assumes you have unsubscribed from the subscription in your
//component, which you should always do in the ngOnDestroy of the component
it('should unsubscribe when component destroyed', () => {
  let fixture = TestBed.createComponent(TestComponent);
  fixture.detectChanges();
  fixture.destroy();
  expect(mockService.subscription.unsubscribe).toHaveBeenCalled();
})
  2. 10

    Vous pouvez tout simplement se moquer Observables jeter objet d'erreur comme Observable.throw({status: 404})et test d'erreur de bloc de observable.

    const xService = fixture.debugElement.injector.get(SomeService);
const mockCall = spyOn(xService, 'method')
                       .and.returnValue(Observable.throw({status: 404}));