TypeScript
Test d'unité

alsacien

Alsatian est un framework de test unitaire écrit en TypeScript. Il permet l'utilisation de cas de test et génère des balises compatibles TAP .

Pour l'utiliser, installez-le à partir de npm :

npm install alsatian --save-dev

Ensuite, configurez un fichier de test:

import { Expect, Test, TestCase } from "alsatian";
import { SomeModule } from "../src/some-module";    

export SomeModuleTests {

    @Test()
    public statusShouldBeTrueByDefault() {
        let instance = new SomeModule();
        
        Expect(instance.status).toBe(true);
    }
    
    @Test("Name should be null by default")
    public nameShouldBeNullByDefault() {
        let instance = new SomeModule();
        
        Expect(instance.name).toBe(null);
    }
    
    @TestCase("first name")
    @TestCase("apples")
    public shouldSetNameCorrectly(name: string) {
        let instance = new SomeModule();
        
        instance.setName(name);
        
        Expect(instance.name).toBe(name);
    }
    
}

Pour une documentation complète, consultez le référentiel GsHub d'alsatian .

plugin chai-immuable

1. Installer à partir de npm chai, chai-immutable et ts-node

   npm install --save-dev chai chai-immutable ts-node
   

2. Installez les types pour moka et chai

   npm install --save-dev @types/mocha @types/chai
   

3. Ecrire un fichier de test simple:

     import {List, Set} from 'immutable';
     import * as chai from 'chai';
     import * as chaiImmutable from 'chai-immutable';
   
     chai.use(chaiImmutable);
   
     describe('chai immutable example', () => {
       it('example', () => {
         expect(Set.of(1,2,3)).to.not.be.empty;
   
         expect(Set.of(1,2,3)).to.include(2);
         expect(Set.of(1,2,3)).to.include(5);
       })
     })
   

4. Exécutez-le dans la console:

   mocha --compilers ts:ts-node/register,tsx:ts-node/register 'test/**/*.spec.@(ts|tsx)'
   

ruban

La bande est un framework de test JavaScript minimaliste, elle produit un balisage compatible TAP .

Pour installer une tape aide de la commande npm run

npm install --save-dev tape @types/tape

Pour utiliser une tape avec Typescript, vous devez installer ts-node tant que package global, pour exécuter cette commande d'exécution

npm install -g ts-node

Maintenant, vous êtes prêt à écrire votre premier test

//math.test.ts
import * as test from "tape";

test("Math test", (t) => {
    t.equal(4, 2 + 2);
    t.true(5 > 2 + 2);

    t.end();
});

Pour exécuter la commande de test

ts-node node_modules/tape/bin/tape math.test.ts

En sortie, vous devriez voir

TAP version 13
# Math test
ok 1 should be equal
ok 2 should be truthy

1..2
# tests 2
# pass  2

# ok

Bon travail, vous venez de lancer votre test TypeScript.

Exécuter plusieurs fichiers de test

Vous pouvez exécuter plusieurs fichiers de test à la fois en utilisant des caractères génériques de chemin. Pour exécuter tous les tests Typescript dans la commande run du répertoire tests

ts-node node_modules/tape/bin/tape tests/**/*.ts

plaisanter (ts-blague)

jest est un framework de test JavaScript indolore par Facebook, avec ts-jest peut être utilisé pour tester le code TypeScript.

Pour installer jest à l'aide de la commande npm run

npm install --save-dev jest @types/jest ts-jest typescript

Pour plus de facilité, installez jest comme paquet global

npm install -g jest

Pour que jest fonctionne avec TypeScript, vous devez ajouter la configuration à package.json

//package.json
{
...
"jest": {
    "transform": {
      ".(ts|tsx)": "<rootDir>/node_modules/ts-jest/preprocessor.js"
    },
    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|tsx|js)$",
    "moduleFileExtensions": ["ts", "tsx", "js"]
  }
}

Maintenant, la jest est prête. Supposons que nous ayons un échantillon de fizz buz à tester

//fizzBuzz.ts
export function fizzBuzz(n: number): string {
    let output = "";
    for (let i = 1; i <= n; i++) {
        if (i % 5 && i % 3) {
            output += i + ' ';
        }
        if (i % 3 === 0) {
            output += 'Fizz ';
        }
        if (i % 5 === 0) {
            output += 'Buzz ';
        }
    }
    return output;
}

Exemple de test pourrait ressembler

//FizzBuzz.test.ts
/// <reference types="jest" />

import {fizzBuzz} from "./fizzBuzz";
test("FizzBuzz test", () =>{
    expect(fizzBuzz(2)).toBe("1 2 ");
    expect(fizzBuzz(3)).toBe("1 2 Fizz ");
});

Pour exécuter un test

jest

En sortie, vous devriez voir

 PASS  ./fizzBuzz.test.ts
  ✓ FizzBuzz test (3ms)

Test Suites: 1 passed, 1 total
Tests:       1 passed, 1 total
Snapshots:   0 total
Time:        1.46s, estimated 2s
Ran all test suites.

Couverture de code

jest prend en charge la génération de rapports de couverture de code.

Pour utiliser la couverture de code avec TypeScript, vous devez ajouter une autre ligne de configuration à package.json .

{
...
  "jest": {
  ...
    "testResultsProcessor": "<rootDir>/node_modules/ts-jest/coverageprocessor.js"
  }
}

Pour exécuter des tests avec la génération de rapports de couverture

jest --coverage

Si utilisé avec notre exemple de fizz buzz, vous devriez voir

 PASS  ./fizzBuzz.test.ts
  ✓ FizzBuzz test (3ms)

-------------|----------|----------|----------|----------|----------------|
File         |  % Stmts | % Branch |  % Funcs |  % Lines |Uncovered Lines |
-------------|----------|----------|----------|----------|----------------|
All files    |    92.31 |     87.5 |      100 |    91.67 |                |
 fizzBuzz.ts |    92.31 |     87.5 |      100 |    91.67 |             13 |
-------------|----------|----------|----------|----------|----------------|
Test Suites: 1 passed, 1 total
Tests:       1 passed, 1 total
Snapshots:   0 total
Time:        1.857s
Ran all test suites.

jest également créé la coverage dossier qui contient le rapport de couverture dans divers formats, y compris le rapport HTML convivial dans la coverage/lcov-report/index.html