Ecrire des tests unitaires en TypeScript (par l'exemple des chats)

Comment écrire des tests unitaires dans un projet TypeScript? Dans cet article, je vais essayer de répondre à cette question et vous montrer également comment créer un environnement de test unitaire pour les projets utilisant TypeScript.

Que sont les tests unitaires?

Tests unitaires - Tests appliqués sur différentes couches d'une application qui testent la plus petite logique divisible d'une application: par exemple, un module, une classe ou une méthode.

L'essence des tests unitaires est de les écrire dans chaque nouvelle classe ou méthode, en vérifiant si la prochaine modification du code a conduit à l'apparition d'erreurs (bogues) dans les parties déjà testées du programme.

. , . . , , . .

. :

project
| node_modules
| src
| package.json
| tsconfig.json
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

./src



cat.module.ts



Cat.

export class Cat {
  public name: string;
  public color: string;

  constructor(name: string, color: string) {
    this.name = name;
    this.color = color;
  }

  public move(distanceMeter: number) : string {
    return `${this.name} moved ${distanceMeter}m.`;
  }

  public say() : string {
    return `Cat ${this.name} says meow`;
  }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, . (SUT - system under test).

, test, .

npm :

npm install --save-dev ts-node mocha @testdeck/mocha nyc chai @types/chai

:

ts-node



- TypeScript REPL node.js.

mocha



- , , . . @testdeck/mocha



- testdeck , .

nyc



- CLI Istanbul, .

chai



- (assertions), . . @types/chai



typescript'

, test



, tsconfig.json



, TS .

{
  "extends": "../tsconfig.json",
  "compilerOptions": {
    "baseUrl": "./",
    "module": "commonjs",
    "experimentalDecorators": true,
    "strictPropertyInitialization": false,
    "isolatedModules": false,
    "strict": false,
    "noImplicitAny": false,
    "typeRoots" : [
      "../node_modules/@types"
    ]
  },
  "exclude": [
    "../node_modules"
  ],
  "include": [
    "./**/*.ts"
  ]
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

include test .ts

, register.js



ts-node, .

const tsNode = require('ts-node');
const testTSConfig = require('./test/tsconfig.json');

tsNode.register({
  files: true,
  transpileOnly: true,
  project: './test/tsconfig.json'
});
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, .mocharc.json



, :

{
  "require": "./register.js",
  "reporter": "list"
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

.nyrc.json



.

{
  "extends": "@istanbuljs/nyc-config-typescript",
  "include": [
    "src/**/*.ts"
  ],
  "exclude": [
    "node_modules/"
  ],
  "extension": [
    ".ts"
  ],
  "reporter": [
    "text-summary",
    "html"
  ],
  "report-dir": "./coverage"
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, :

project
| node_modules
| src
| test
| --- tsconfig.json
| .mocharc.json
| .nyrc.json
| package.json
| register.js
| tsconfig.json
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

package.json

"test": "nyc ./node_modules/.bin/_mocha 'test/**/*.test.ts'"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

,

./test



cat.unit.test.ts



:

import { Cat } from '../src/cat.module';
import { suite, test } from '@testdeck/mocha';
import * as _chai from 'chai';
import { expect } from 'chai';

_chai.should();
_chai.expect;

@suite class CatModuleTest {
  private SUT: Cat;
  private name: string;
  private color: string;

  before() {
    this.name = 'Tom';
    this.color = 'black';
    this.SUT = new Cat(this.name, this.color);
  }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Cat cat.module.ts



, , .

before Cat, .

, .

import { Cat } from '../src/cat.module';
import { suite, test } from '@testdeck/mocha';
import * as _chai from 'chai';
import { expect } from 'chai';

_chai.should();
_chai.expect;

@suite class CatModuleTest {
  private SUT: Cat;
  private name: string;
  private color: string;

  before() {
    this.name = 'Tom';
    this.color = 'black';
    this.SUT = new Cat(this.name, this.color);
  }

  @test 'Cat is created' () {
    this.SUT.name.should.to.not.be.undefined.and.have.property('name').equal('Tom');
  }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

npm test :

, 11-15. Cat move



say.

:

import { Cat } from '../src/cat.module';
import { suite, test } from '@testdeck/mocha';
import * as _chai from 'chai';
import { expect } from 'chai';

_chai.should();
_chai.expect;

@suite class CatModuleTest {
  private SUT: Cat;
  private name: string;
  private color: string;

  before() {
    this.name = 'Tom';
    this.color = 'black';
    this.SUT = new Cat(this.name, this.color);
  }

  @test 'Cat is created' () {
    this.SUT.name.should.to.not.be.undefined.and.have.property('name').equal('Tom');
  }

  @test 'Cat move 10m' () {
    let catMove = this.SUT.move(10);
    expect(catMove).to.be.equal('Tom moved 10m.');
  }

  @test 'Cat say meow' () {
    expect(this.SUT.say()).to.be.equal('Cat Tom says meow');
  }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Exécutez à nouveau nos tests et voyez que la classe Cat a maintenant une couverture de test complète.

Résultat

En conséquence, nous avons créé une infrastructure de test pour notre application et maintenant nous pouvons couvrir n'importe quel nouveau module ou classe avec des tests, en vérifiant que le code existant n'est pas cassé.

PS: Basé sur l'article Comment configurer le test unitaire avec TypeScript .