Une bonne vie commence par le test

Un programmeur qui n'écrit pas de cas de test automatiques n'est pas un bon ingénieur de test. Nous encourageons tous les projets à établir des cas de test automatisés complets dès le début. Avec le développement du projet, l'investissement initial sera récompensé des centaines de fois.

Continuons l'exemple de la section précédente et examinons comment utiliser fibjs pour écrire des cas de test.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
const http = require('http');
const path = require('path');

var hello_server = {
    '/:name(fibjs.*)': (req, name) => {
        req.response.write('hello, ' + name + '. I love you.');
    },
    '/:name': (req, name) => {
        req.response.write('hello, ' + name);
    }
};

var root_server = {
    '/hello': hello_server,
    '/bonjour': hello_server,
    '*': http.fileHandler(path.join(__dirname, 'web'))
};

var svr = new http.Server(8080, root_server);

svr.start();

Un cadre de test vide

Commençons par un framework de test de base :

1
2
3
4
5
6
7
8
9
10
var test = require('test');
test.setup();

describe('hello, test', () => {
    it('a empty test', () => {

    });
});

test.run();

Enregistrez comme test.jsplus tard, dans la ligne de commande fibjs test.js, vous voyez la sortie suivante, un cadre de test de base a été écrit.

1
2
3
4
  hello, test
    √ a empty test

  √ 1 tests completed (0ms)

Démarrer le serveur de test

Parce que nous devons tester le serveur http, nous devons d'abord démarrer le serveur. Le scénario de test enverra une requête au serveur, puis testera le résultat de la requête pour déterminer si le serveur répond aux exigences :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var test = require('test');
test.setup();

var http = require('http');

describe('hello, test', () => {
    it('hello, fibjs', () => {
        var r = http.get('http://127.0.0.1:8080/hello/fibjs');
        assert.equal(r.statusCode, 200);
        assert.equal(r.data.toString(), 'hello, fibjs. I love you.');
    });
});

test.run();

Dans ce code, nous jugeons si la logique du serveur est normale en vérifiant si le résultat de http.get est le résultat attendu. D'après cet exemple, nous pouvons effectuer rapidement un ensemble de tests, et nous avons optimisé le code en même temps :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
var test = require('test');
test.setup();

var http = require('http');

function test_get(url, rep) {
    var r = http.get('http://127.0.0.1:8080' + url);
    assert.equal(r.statusCode, 200);
    assert.equal(r.data.toString(), rep);
}

describe('hello, test', () => {
    it('hello, fibjs', () => {
        test_get('/hello/fibjs', 'hello, fibjs. I love you.');
    });

    it('hello, fibjs*', () => {
        test_get('/hello/fibjs-great', 'hello, fibjs-great. I love you.');
    });

    it('hello, JavaScript', () => {
        test_get('/hello/JavaScript', 'hello, JavaScript');
    });

    it('hello, v8', () => {
        test_get('/hello/v8', 'hello, v8');
    });
});

test.run();

Gestion groupée des cas d'utilisation

Ajoutons bonjour test. Bien que bonjour et hello soient le même ensemble de services, car le chemin a changé, nous devons également vérifier l'exactitude du service. Cette fois, afin de mieux gérer les cas d'utilisation, nous avons effectué les cas de test Regroupant, en même temps, car les contenus de test de hello et bonjour sont les mêmes, nous avons à nouveau optimisé le code et testé les deux ensembles de services avec le même ensemble de codes :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
var test = require('test');
test.setup();

var http = require('http');

function test_get(url, rep) {
    var r = http.get('http://127.0.0.1:8080' + url);
    assert.equal(r.statusCode, 200);
    assert.equal(r.data.toString(), rep);
}

describe('hello, test', () => {
    function test_hello(hello) {
        describe(hello + ' test', () => {
            it('fibjs', () => {
                test_get('/' + hello + '/fibjs', 'hello, fibjs. I love you.');
            });

            it('fibjs*', () => {
                test_get('/' + hello + '/fibjs-great', 'hello, fibjs-great. I love you.');
            });

            it('JavaScript', () => {
                test_get('/' + hello + '/JavaScript', 'hello, JavaScript');
            });

            it('v8', () => {
                test_get('/' + hello + '/v8', 'hello, v8');
            });
        });
    }

    test_hello('hello');
    test_hello('bonjour');
});

test.run();

Grâce au regroupement des cas d'utilisation, nous pouvons voir les résultats des tests plus clairement, et il est également facile d'ignorer et de tester un groupe de cas d'utilisation individuellement, ce qui accélère la vitesse de développement et de test. Voici les résultats de cette série de tests :

1
2
3
4
5
6
7
8
9
10
11
12
13
  hello, test
    hello test
      √ fibjs
      √ fibjs*
      √ JavaScript
      √ v8
    bonjour test
      √ fibjs
      √ fibjs*
      √ JavaScript
      √ v8

  √ 8 tests completed (3ms)

Selon la conception de notre serveur, nous avons également un ensemble de services de fichiers statiques.Selon l'exemple ci-dessus, je pense que vous pouvez rapidement rédiger cette partie des cas de test.

Testez en un clic

Après l'introduction ci-dessus, nous pouvons rapidement établir des cas de test. Mais pour utiliser ce script de test, vous devez d'abord démarrer le serveur, c'est très simple, nous voulons exécuter test.jspour terminer le test directement. Nous pouvons utiliser le code suivant pour réaliser :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
var test = require('test');
test.setup();

var http = require('http');

var coroutine = require('coroutine');
coroutine.start(() => {
    run('./main.js');
});
coroutine.sleep(100);

function test_get(url, rep) {
    var r = http.get('http://127.0.0.1:8080' + url);
    assert.equal(r.statusCode, 200);
    assert.equal(r.data.toString(), rep);
}

describe('hello, test', () => {
    function test_hello(hello) {
        describe(hello + ' test', () => {
            it('fibjs', () => {
                test_get('/' + hello + '/fibjs', 'hello, fibjs. I love you.');
            });

            it('fibjs*', () => {
                test_get('/' + hello + '/fibjs-great', 'hello, fibjs-great. I love you.');
            });

            it('JavaScript', () => {
                test_get('/' + hello + '/JavaScript', 'hello, JavaScript');
            });

            it('v8', () => {
                test_get('/' + hello + '/v8', 'hello, v8');
            });
        });
    }

    test_hello('hello');
    test_hello('bonjour');
});

process.exit(test.run());

Ligne 6 à 10 de ce code, nous avons ajouté un main.jscode de démarrage de paragraphe , et patientons un peu, puis reprenons les tests.

Vérification de la couverture du code

Les bons cas de test doivent tenir compte du fait que les cas de test doivent couvrir toutes les branches de l'entreprise pour garantir que l'entreprise est exécutée correctement. À ce stade, les vérifications de la couverture du code peuvent être utilisées pour déterminer si le test est terminé.

Ce processus est très simple, il suffit d'ajouter le paramètre --cov lors du test :

1
fibjs --cov test

Une fois le test terminé, un fichier journal de fibjs-xxxx.lcov sera généré dans le répertoire courant. A ce moment, il est nécessaire d'analyser le journal et de générer un rapport :

1
fibjs --cov-process fibjs-xxxx.lcov out

Ensuite, vous pouvez générer un ensemble de rapports d'analyse dans le répertoire out. Entrez dans le catalogue pour vérifier, vous pouvez voir la page suivante : Vous pouvez voir que main.jsla couverture du code a atteint 100 %, ce qui signifie que le test couvre complètement la logique métier. Cliquez main.jsplus loin, vous pouvez voir un rapport plus détaillé.

👉 [ Trouvez le tueur de performance ]