Winkel 4 unit testing mit jasmine /karma mit http-post-Spott - wie kann man das

Ich habe einen service möchte ich unit-Tests im Winkel 4 Typoskript Jasmin.

Nun, die http ist dabei ein post , und es gibt eine Identität, aber.. es ist nicht senden, nichts.

Ich will einfach einen guten code-coverage, aber ich verstehe nicht, wie ganz abgeschlossen ist diese spöttische Aussage.

hier ist die Methode für http-post in meinem service-Datei

addSession() {
        let headers = new Headers({ 'Content-Type': 'application/json' });
        let options = new RequestOptions({ headers: headers });

        return this.http.post(this.url, JSON.stringify({}), options)
            .map((response: Response) => response.json());

}

Dann die SPEC-DATEI , die ich nicht bekommen, was Sie wirklich testen, ich nehme an, vorgetäuscht, dass ich eine Nummer bekommen vom Dienst zurück http post, die Antwort sollte etwas wie 000000014

Spec

import { TrackerFormService } from './tracker-form.service'
import { Observable } from 'rxjs/Observable'

describe('TrackerFormService', () => {

    let trackerFormService: TrackerFormService,
        mockHttp;

    beforeEach(() => {
        mockHttp = jasmine.createSpyObj('mockHttp', ['get', 'post', 'put']
        )
        trackerFormService = new TrackerFormService(mockHttp);
    });

    describe('addSession', () => {

        it('add session ', () => {
              //how to test,  what to test?    
              //response , is a number?  how to mock/fake this?

        })

    })

})

InformationsquelleAutor | 2017-09-26

Um das zu erreichen, was Sie wollen, die Modelle, die Sie brauchen, ist eine einfache Funktion, die liefert die gleichen wie die POST würde in der Regel selbst; eine andere Sache ist der test sollte nicht auf den server für real, so müssten Sie so etwas wie dieses (müssen Sie möglicherweise andere Abhängigkeiten):

import { HttpModule } from '@angular/http';
import { TrackerFormService } from './tracker-form.service'
import { Observable } from 'rxjs/Observable'

describe('TrackerFormService', () => {
//Mock the service like this and add all the functions you have in this fashion
let trackerFormService: TrackerFormService,
  mockService = {
    addSession: jasmine.createSpy('addSession').and.returnValue(Observable.of('your session object mock goes here'))
  };

  beforeEach(() => {
    TestBed.configureTestingModule({
      imports: [HttpModule],
      providers: [{
        provide: TrackerFormService,
        useValue: mockService
      }]
    });
  });

  //Do this trick to inject the service every time, and just use `service` in your tests
  beforeEach(inject([TrackerFormService], (trackerFormService) => {
    service = trackerFormService;
  }));

  describe('addSession', () => {
    it('add session ', () => {
      let fakeResponse = null;

      //Call the service function and subscribe to it to catch the fake response coming from the mock.
      service.addSession().subscribe((value) => {
        //in here value will be whatever you put as returnValue (remember to keep the observable.of())
        fakeResponse = value;
      });

      //expects as in any test.
      expect(fakeResponse).toBeDefined();
      expect(fakeResponse).toBe('your session object mock goes here');
    });
  });
});

InformationsquelleAutor Sonicd300

0

Mit Eckigen 4.3 kam die HttpClient-service, der an die Stelle von Http und bietet eine einfachere Möglichkeit zum simulieren von HTTP-Anfragen. Es ist gut dokumentiert auf der offiziellen Seite: https://angular.io/guide/http
- ich bin bereits über der anderen, und ich war zu Fragen, wie man gezielt zu verspotten, was ich habe. was Sie sagen, ist das äquivalent von 1. in .net-core-oder c# - 7 , die Sie jetzt tun können, XYZ, so viel schöner, oder 2. in ES6, jetzt ist es ja so viel besser ...
- Wenn ich das richtig Sie wollen, zu verspotten, die TrackerFormService.addSession () - Methode der test der TrackerFormService, das macht keinen Sinn, aus meiner Perspektive, weil Sie testen wollen, in der realen Implementierung nicht spotten.
- es gibt eine Zahl zurück, wie 000000015 aus der Antwort, so bin ich sicher, dass die Menschen verspottet /gefälscht den Prozess des http-post-Dienste. ich kann Beispiele finden, aber Sie sind so spezifisch, dass der Versuch, herauszufinden, wie man nur mock/fake meine spezifischen test, was ich will. Ich behaupte nicht zu wissen, wie es zu tun, so war ich mit der Frage
InformationsquelleAutor TekTimmy
0

Gut, wie Sie getan setup der test - /mock-Sie können die gefälschten die Rücksendung von der post anrufen und prüfen, dass Sie das Ergebnis Sie erwartet. Sie werden testen, dass das verspottet wird die Antwort sein, richtig umgesetzt, indem Sie Ihren map-Anweisung. Mit Ihrem Spion-Sie können auch überprüfen, wie der post-Methode aufgerufen wurde. Dieser wird überprüfen, ob die Optionen entsprechen, was Sie erwarten.

Aber meiner Meinung nach das ist eine eher komplizierte Lösung. Ich würde es vorziehen, zu vermeiden, verhöhnt und Spione durch die Spaltung der Methode, so dass jede Methode ist nur eine Sache zu tun. Weil Ihr addSession Methode ist derzeit dabei drei verschiedene (und doch logisch abhängig) Dinge:
1. erstellen Optionen für eine addSession xhr Aufruf
2. führt der Aufruf
3. konvertieren Sie die Antwort
Wenn du gegen die Methode bis in drei können Sie ganz einfach testen-Methode #1 und #3 in separaten tests und Methode #2 würde nur der Aufruf der http-Bibliothek. Dies können Sie erreichen, den gleichen test Wert wie oben, ohne den Aufruf der http-Bibliothek.

Nun, was zu Methode #2... es ist noch ungetestet und meiner Meinung nach gibt es keinen Grund, es zu testen an alle. Da Sie nicht schreiben, dass code. Auch wenn Sie mit angulars http-Modul ich bin sicher, Sie haben solide unit tests selbst.

Die Antwort von Ihrem service sollte schon abgedeckt werden, die durch eine zusätzliche integration, test, führen Sie weniger Häufig mit der Prüfung des service-api wird noch zurück, was Sie erwarten.

Wenn Sie wirklich wollen, dass eine Zeile grün in Ihrem code-coverage -, dann könnten Sie Optional verwenden Sie eine Bibliothek mit dem Namen nock. Nock fängt alle xhr-Verkehr mit Ihrer app zu verursachen. In der test-Datei können Sie anzeigen xhr-Anfragen zu spotten Antworten mit den nock-Objekt.

JS:
```
var scope = nock('http://myapp.iriscouch.com')
                .post('/users', {
                  username: 'pgte',
                  email: '[email protected]'
                })
                .reply(201, {
                  ok: true,
                  id: '123ABC',
                  rev: '946B7D1C'
                });
```
kopiert von: https://www.npmjs.com/package/nock

Für Bezug und weitere Informationen über das testen im Allgemeinen, und wie viel zu testen, empfehle ich gerade
"Budgetierung Wirklichkeit" von Justin Searls

InformationsquelleAutor Tabueeee

-2

Beispiel-Testfall für die http-service-Anfragen

HTML:

describe('Forgot Password Controller', function () {
    var $controller,
        $httpBackend,
        $q,
        $rootScope,
        $state,
        controller,
        scope,
        accountProvider;

    beforeEach(module('app'));
    beforeEach(inject(function (_$injector_, _$controller_, _$rootScope_) {

        $controller = _$controller_;
        $rootScope = _$rootScope_;
        $httpBackend = _$injector_.get('$httpBackend');
        $state = _$injector_.get('$state');
        $q = _$injector_.get('$q');
        accountProvider = _$injector_.get('accountProvider');
        scope = _$rootScope_.$new();

        controller = $controller(app.controllers.forgotPassword, {
            $state: $state,
            accountProvider: accountProvider
        });
    }));

    afterEach(function () {
        $httpBackend.verifyNoOutstandingRequest();
        $httpBackend.verifyNoOutstandingExpectation();
    });

    describe('forgot password submission', function () {

        it('Can submit a forgot password request successfully', function () {
            $httpBackend.expectPOST("URL DOMAIN" + '/events/requestPasswordReset').respond(200);
            spyOn($state, 'go');
            controller.form = { emailAddress: '[email protected]' };

            controller.submit();

            expect(controller.submitting).toBe(true);

            $httpBackend.flush();

            expect(controller.submitting).toBe(false);
            expect($state.go).toHaveBeenCalledWith('login', { successMessage: 'An email sent to ' + controller.form.emailAddress + ' contains instructions for resetting your password.' });
        });

        it('Can handle when a user is not found when submitting a forgot password request', function () {
            $httpBackend.expectPOST(app.env.EDGE_SERVICE_PATH + '/events/requestPasswordReset').respond(404);
            spyOn($state, 'go');
            controller.form = { emailAddress: '[email protected]' };

            controller.submit();

            expect(controller.submitting).toBe(true);
            $httpBackend.flush();

            //We intentionally want to make it appear to the user that the password reset email was sent even when a user
            //does not exist, to help hide info about which users exist in the system
            expect(controller.submitting).toBe(false);
            expect($state.go).toHaveBeenCalledWith('login', { successMessage: 'An email sent to ' + controller.form.emailAddress + ' contains instructions for resetting your password.' });

        });

        it('Can handle unexpected errors from submitting a forgot password request', function () {
            $httpBackend.expectPOST("URL DOMAIN"  + '/events/requestPasswordReset').respond(500);

            controller.submit();
            $httpBackend.flush();

            expect(controller.errors.unexpectedError).toBe(true);
        });

        it('Can handle 422 validation errors from submitting a forgot password request', function () {
            var responseData = {
                fieldErrors: {
                    username: [{code: 'error'}, {code: 'required', message: 'This is required.'}]
                }
            };
            $httpBackend.expectPOST("URL DOMAIN" + '/events/requestPasswordReset').respond(422, responseData);

            controller.submit();
            $httpBackend.flush();

            expect(controller.errors.validationErrors).toBe(true);
            expect(controller.errors.fieldErrors).toEqual(responseData.fieldErrors);
        });

        it('Can handle 503 service unavailable from submitting a forgot password request', function () {
            $httpBackend.expectPOST("URL DOMAIN" + '/events/requestPasswordReset').respond(503);

            controller.submit();
            $httpBackend.flush();

            expect(controller.errors.serviceUnavailable).toBe(true);
        });

    });

});

Dies ist nicht eine eckige 4-Lösung.
ja , hier gebe ich Vorstellung darüber, wie das schreiben von Testfällen für die rest-apis.
Wie dies hilft, um ein mock-service in ng??

InformationsquelleAutor AnilKumar

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.