Testen Fehler-Fall mit observablen in Dienstleistungen

Sagen wir, ich habe eine Komponente, die abonniert, um eine service-Funktion:

export class Component {

   ...

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

Abonnieren Aufruf nimmt zwei anonyme Funktionen, die als Parameter, ich habe es geschafft, bis eine funktionierende unit-test für die Daten-Funktion, aber das Karma wird nicht akzeptieren, Abdeckung für die Fehler ein.

Habe ich versucht, die Bespitzelung der Konsole.error-Funktion, Ausgabe einer Fehlermeldung und dann zu erwarten, dass der Spion gerufen worden zu sein, aber das bedeutet nicht ganz tun es.

Mein unit-test:

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.
    }
);

Was ist die best practice für die Prüfung anonyme Funktionen wie diese? Was ist das absolute minimum zur Sicherung der Testabdeckung?

Dein test keinen Sinn macht; Sie ersetzen die callback-Sie sagen, Sie wollen zu testen. Nur Tests, die subscribe ruft seine zweite argument, wenn ein Fehler Auftritt ist nicht testen Sie Ihren code, es ist die Prüfung der Rahmenbedingungen, die ein anti-pattern. Auch Sie stellen zwei unterschiedliche Ergebnisse für Ihre mock-Aufruf in aufeinander folgenden Zeilen.
Okay, so was wäre eine gute Möglichkeit es zu testen? Auslösen eines Fehlers in einem separaten it-block?
Sie müssen aufrufen, um die tatsächliche Umsetzung, aber Sie haben nicht gezeigt, reicht ein Minimale, Vollständige und Überprüfbare Beispiel, zu erraten, wie das erreicht werden könnte.
ein update für diese Frage?

InformationsquelleAutor user3656550 | 2016-10-10

Können Sie einfach mock Beobachtbare Fehler schmeißen Objekt wie Observable.throw({status: 404}) - und test-Fehler-block zu beobachten.

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

InformationsquelleAutor Aniruddha Das

Nicht sicher genau den Zweck, den code, die Sie zeigen, die versuchen zu testen, ein mock service. Die Abdeckung problem mit der Komponente und die Fehler-callback nicht aufgerufen wurden (die wird nur aufgerufen, wenn ein Fehler aufgetreten ist).

Was ich in der Regel nicht für die meisten meiner beobachtbare Leistungen, erstellen Sie ein mock, deren Methoden sich nur die Renditen selbst. Die mock-service hat eine subscribe Methode akzeptiert next, error, und complete Rückrufe. Die Benutzer des mock bekommt es zu konfigurieren, fügen Sie einen Fehler, so das error Funktion aufgerufen wird, oder Daten hinzufügen, so dass die next - Methode aufgerufen wird. Die Sache ich mag am meisten über diese ist, dass es alle synchron.

Unten ist so etwas wie das, was ich normalerweise verwenden. Es ist nur eine abstrakte Klasse für die anderen verspottet zu verlängern. Es bietet die grundlegenden Funktionen, die eine beobachtbare bietet. Die Ausweitung der mock-service sollte nur hinzufügen, dass die Methoden, die es braucht, kehren selbst in der Methode.

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;
  }
}

Nun in Ihren tests tun Sie nur so etwas wie

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();
})

InformationsquelleAutor Paul Samsotha

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.