Реализовать юнит-тестирование с помощью жасмина / кармы, посмеиваясь над Http Post - Angular 5

Question

Я совершенно новичок в модульном тестировании и впервые внедряю модульное тестирование с использованием jasmine / karma.Я сталкиваюсь с несколькими проблемами в понимании того, как я должен реализовать тестирование, издеваясь над Http Post.Я прошел через несколько решений, таких как: решение1 и решение2

Но все же я столкнулся с несколькими проблемами в их понимании и также столкнулся с несколькими ошибками.

Следующим решением2 я попытался реализовать следующее:

http.service.ts

 update(id,password,url){

    let content = {
        "username": id,
        "password":password,

     }

     const httpOptions = {
      headers: new HttpHeaders({
        'Content-Type':  'application/json'
      })
    };

     return this.http.post(url,content,httpOptions).subscribe((data:any) => {

        if(data.length){
          return true;
        }
        else{
          return false;
        }
      })

http.service.spec.ts

import { TestBed, inject } from '@angular/core/testing';
import { HttpClientModule } from '@angular/common/http'; 
import { HttpService } from './http.service';
import {HttpModule, XHRBackend,Response,ResponseOptions, Connection} from 
'@angular/http';
import {  of } from 'rxjs';
import { MockBackend } from '@angular/http/testing';

 describe('HttpService', () => {
 let mockbackend, service;
 beforeEach(() => {TestBed.configureTestingModule({
 imports:[HttpClientModule, HttpModule],
 providers:[{
 provide: XHRBackend, useclass: MockBackend
 }]

 })
 });

  beforeEach(inject([ XHRBackend], (_service, 
  _mockbackend) => {
  service = _service;
  mockbackend = _mockbackend;
  }));

  it('post method is successfull',() =>{
  const status = 'success';
  const username = '5555555';
  const password = 'test';
  const currentUserExpected = JSON.stringify({status:status});
  const response = { status : status};
  const responseOptions = new ResponseOptions();
  responseOptions.body = JSON.stringify(response);
  mockbackend.connections.subscribe(connection =>{
  connection.mockRespond(new Response(responseOptions));
  });
  service.update(username,password).subscribe(respond =>{
  expect(respond).toEqual(true)
  })
   })

Я получаю следующую ошибку:

Ошибка

Невозможно прочитать соединения свойств'of undefined

Может кто-нибудь, пожалуйста, помогите мне понять, где я иду не так.

Также я хотел бы получить ссылку на любую документацию, которая может помочь мне лучше понять это.

Answer 1

Вот пример, который может помочь: employee-home.service.ts

import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';
import { Employee } from '../models/employee';
import { USER_PROFILE_API_LOCATION  } from '../../serviceConstants';


@Injectable({
  providedIn: 'root'
})
export class EmployeeHomeService {
  constructor(private http: HttpClient) {}

  retrieveEmployee(): Observable<Employee> {
    return this.http.get<Employee>(USER_PROFILE_API_LOCATION);  
  }

  updateEmployee(employee: Employee): Observable<Employee> {
    return this.http.put<Employee>(USER_PROFILE_API_LOCATION, employee); 
  }
}

, а затем: employee-home.service.spec.ts

import { asyncData, asyncError } from '@bis-angular/shared-helpers-testing';
import { EmployeeHomeService } from './employee-home.service';
import { Employee } from '../models/employee';
import { HttpErrorResponse } from '@angular/common/http';
import { EMPLOYEE } from '../../../fixtures/employee-fixture';

describe('EmployeeHomeService', () => {
  describe('retrieveEmployee function', () => {
     let httpClientSpyGet: { get: jasmine.Spy };
     let employeeHomeServiceGet: EmployeeHomeService;

    beforeEach(() => {
       httpClientSpyGet = jasmine.createSpyObj('HttpClient', ['get']);
       employeeHomeServiceGet = new 
EmployeeHomeService(<any>httpClientSpyGet);
    });

it('should return expected employee (HttpClient called once)', () => {
  const expectedEmployee: Employee = EMPLOYEE;

  httpClientSpyGet.get.and.returnValue(asyncData(expectedEmployee));

  employeeHomeServiceGet
    .retrieveEmployee()
    .subscribe(employee => expect(employee).toEqual(expectedEmployee, 'expected employee'), fail);
  expect(httpClientSpyGet.get.calls.count()).toBe(1, 'one call');
});

it('should return an error when the server returns an error', () => {
  const errorResponse = new HttpErrorResponse({
    error: 'test error',
    status: 404,
    statusText: 'Not Found'
  });

  httpClientSpyGet.get.and.returnValue(asyncError(errorResponse));

  employeeHomeServiceGet
    .retrieveEmployee()
    .subscribe(
      employee => fail('expected an error, not employee'),
      error => expect(error.error).toContain('test error')
    );
});
   });

  describe('updateEmployee function', () => {
    let httpClientSpyPut: { put: jasmine.Spy };
    let employeeHomeServicePut: EmployeeHomeService;
    const expectedEmployee: Employee = EMPLOYEE;

beforeEach(() => {
  httpClientSpyPut = jasmine.createSpyObj('HttpClient', ['put']);
  employeeHomeServicePut = new EmployeeHomeService(<any>httpClientSpyPut);
});

it('should save employee (HttpClient called once)', () => {
  httpClientSpyPut.put.and.returnValue(asyncData(expectedEmployee));

  employeeHomeServicePut
    .updateEmployee(expectedEmployee)
    .subscribe(employee => expect(employee).toEqual(expectedEmployee, 'expected employee'), fail);
  expect(httpClientSpyPut.put.calls.count()).toBe(1, 'one call');
});

it('should return an error when the server returns an error', () => {
  const errorResponse = new HttpErrorResponse({
    error: 'test error',
    status: 404,
    statusText: 'Not Found'
  });

  httpClientSpyPut.put.and.returnValue(asyncError(errorResponse));

  employeeHomeServicePut
    .updateEmployee(expectedEmployee)
    .subscribe(
      employee => fail('expected an error, not employee'),
      error => expect(error.error).toContain('test error')
    );
});
   });
 });

helpers:async-observable-helpers.ts

import { defer } from 'rxjs';


export function asyncData<T>(data: T) {
  return defer(() => Promise.resolve(data));
}


export function asyncError<T>(errorObject: any) {
  return defer(() => Promise.reject(errorObject));
}