在Angular测试中使用spy的教程详解_AngularJs

简介

jasmine spy 用于跟踪或存根函数或方法。spy 是一种检查函数是否被调用或提供自定义返回值的方法。我们可以使用spy 来测试依赖于服务的组件，并避免实际调用服务的方法来获取值。这有助于保持我们的单元测试专注于测试组件本身的内部而不是其依赖关系。

在本文中，您将学习如何在 angular 项目中使用 jasmine spy。

先决条件

要完成本教程，您需要：

在本地安装 node.js
一些关于设置 angular 项目的基础知识。

本教程已使用 node v16.2.0、npm v7.15.1 和 @angular/core v12.0.4 进行验证。

步骤 1 — 设置项目

让我们使用一个与我们在 angular 单元测试介绍中使用的示例非常相似的示例。

首先，使用 @angular/cli 创建一个新项目：

ng new angular-test-spies-example

然后，切换到新创建的项目目录：

cd angular-test-spies-example

以前，该应用程序使用两个按钮在 0 到 15 之间增加和减少值。

对于本教程，逻辑将被移动到一个服务中。这将允许多个组件访问相同的中央值。

ng generate service increment-decrement

然后，打开您的代码编辑器中的 increment-decrement.service.ts 并用以下代码替换内容：

import { injectable } from '@angular/core';

@injectable({
  providedin: 'root'
})
export class incrementdecrementservice {
  value = 0;
  message!: string;

  increment() {
    if (this.value < 15) {
      this.value += 1;
      this.message = '';
    } else {
      this.message = 'maximum reached!';
    }
  }

  decrement() {
    if (this.value > 0) {
      this.value -= 1;
      this.message = '';
    } else {
      this.message = 'minimum reached!';
    }
  }
}

打开您的代码编辑器中的 app.component.ts 并用以下代码替换内容：

import { component } from '@angular/core';
import { incrementdecrementservice } from './increment-decrement.service';

@component({
  selector: 'app-root',
  templateurl: './app.component.html',
  styleurls: ['./app.component.css']
})
export class appcomponent {
  constructor(public incrementdecrement: incrementdecrementservice) { }

  increment() {
    this.incrementdecrement.increment();
  }

  decrement() {
    this.incrementdecrement.decrement();
  }
}

打开您的代码编辑器中的 app.component.html 并用以下代码替换内容：

<h1>{{ incrementdecrement.value }}</h1>

<hr>

<button (click)="increment()" class="increment">increment</button>

<button (click)="decrement()" class="decrement">decrement</button>

<p class="message">
  {{ incrementdecrement.message }}
</p>

接下来，打开您的代码编辑器中的 app.component.spec.ts 并修改以下代码行：

import { testbed, waitforasync, componentfixture } from '@angular/core/testing';
import { by } from '@angular/platform-browser';
import { debugelement } from '@angular/core';

import { appcomponent } from './app.component';
import { incrementdecrementservice } from './increment-decrement.service';

describe('appcomponent', () => {
  let fixture: componentfixture<appcomponent>;
  let debugelement: debugelement;
  let incrementdecrementservice: incrementdecrementservice;

  beforeeach(waitforasync(() => {
    testbed.configuretestingmodule({
      declarations: [
        appcomponent
      ],
      providers: [ incrementdecrementservice ]
    }).compilecomponents();

    fixture = testbed.createcomponent(appcomponent);
    debugelement = fixture.debugelement;

    incrementdecrementservice = debugelement.injector.get(incrementdecrementservice);
  }));

  it('should increment in template', () => {
    debugelement
      .query(by.css('button.increment'))
      .triggereventhandler('click', null);

    fixture.detectchanges();

    const value = debugelement.query(by.css('h1')).nativeelement.innertext;

    expect(value).toequal('1');
  });

  it('should stop at 15 and show maximum message', () => {
    incrementdecrementservice.value = 15;
    debugelement
      .query(by.css('button.increment'))
      .triggereventhandler('click', null);

    fixture.detectchanges();

    const value = debugelement.query(by.css('h1')).nativeelement.innertext;
    const message = debugelement.query(by.css('p.message')).nativeelement.innertext;

    expect(value).toequal('15');
    expect(message).tocontain('maximum');
  });
});

请注意，我们可以使用 debugelement.injector.get 获取对注入服务的引用。

以这种方式测试我们的组件是有效的，但实际调用也将被传递到服务，并且我们的组件没有被孤立测试。接下来，我们将探讨如何使用 spy 来检查方法是否已被调用或提供存根返回值。

步骤 2 —— 监视服务的方法

以下是如何使用 jasmine 的 spyon 函数调用一个服务方法并测试它是否被调用：

import { testbed, waitforasync, componentfixture } from '@angular/core/testing';
import { by } from '@angular/platform-browser';
import { debugelement } from '@angular/core';

import { appcomponent } from './app.component';
import { incrementdecrementservice } from './increment-decrement.service';

describe('appcomponent', () => {
  let fixture: componentfixture<appcomponent>;
  let debugelement: debugelement;
  let incrementdecrementservice: incrementdecrementservice;
  let incrementspy: any;

  beforeeach(waitforasync(() => {
    testbed.configuretestingmodule({
      declarations: [
        appcomponent
      ],
      providers: [ incrementdecrementservice ]
    }).compilecomponents();

    fixture = testbed.createcomponent(appcomponent);
    debugelement = fixture.debugelement;

    incrementdecrementservice = debugelement.injector.get(incrementdecrementservice);
    incrementspy = spyon(incrementdecrementservice, 'increment').and.callthrough();
  }));

  it('should call increment on the service', () => {
    debugelement
      .query(by.css('button.increment'))
      .triggereventhandler('click', null);

    expect(incrementdecrementservice.value).tobe(1);
    expect(incrementspy).tohavebeencalled();
  });
});

spyon 接受两个参数：类实例（在本例中是我们的服务实例）和一个字符串值，表示要监视的方法或函数的名称。

在这里，我们还在 spy 上链接了 .and.callthrough()，这样实际方法仍然会被调用。在这种情况下，我们的 spy 只用于判断方法是否被调用以及监视参数。

以下是断言方法被调用两次的示例：

expect(incrementspy).tohavebeencalledtimes(2);

以下是断言方法未被使用 'error' 参数调用的示例：

expect(incrementspy).not.tohavebeencalledwith('error');

如果我们想避免实际调用服务上的方法，可以在 spy 上使用 .and.returnvalue。

我们的示例方法不适合这样做，因为它们不返回任何内容，而是改变内部属性。

让我们向服务添加一个实际返回值的新方法：

minimumormaximumreached() {
  return !!(this.message && this.message.length);
}

我们还向组件添加一个新方法，模板将使用它来获取值：

limitreached() {
  return this.incrementdecrement.minimumormaximumreached();
}

然后，我们可以测试当达到限制时，我们的模板消息是否会显示，而无需实际调用服务上的方法：

import { testbed, waitforasync, componentfixture } from '@angular/core/testing';
import { by } from '@angular/platform-browser';
import { debugelement } from '@angular/core';

import { appcomponent } from './app.component';
import { incrementdecrementservice } from './increment-decrement.service';

describe('appcomponent', () => {
  let fixture: componentfixture<appcomponent>;
  let debugelement: debugelement;
  let incrementdecrementservice: incrementdecrementservice;
  let minimumormaximumspy: any;

  beforeeach(waitforasync(() => {
    testbed.configuretestingmodule({
      declarations: [
        appcomponent
      ],
      providers: [ incrementdecrementservice ]
    }).compilecomponents();

    fixture = testbed.createcomponent(appcomponent);
    debugelement = fixture.debugelement;

    incrementdecrementservice = debugelement.injector.get(incrementdecrementservice);
    minimumormaximumspy = spyon(incrementdecrementservice, 'minimumormaximumreached').and.returnvalue(true);
  }));

  it(`should show 'limit reached' message`, () => {
    fixture.detectchanges();

    const message = debugelement.query(by.css('p.message')).nativeelement.innertext;

    expect(message).toequal('limit reached!');
  });
});