Test AngularJS: blocs de bootstrap, itinéraires, événements et animations

Points clés

• Les tests unitaires sont essentiels pour le développement de logiciels, en particulier pour les applications qui contiennent des centaines de milliers de lignes de code JavaScript. AngularJS prend en charge des fonctionnalités telles que l'injection de dépendance (DI) pour faciliter les tests de code.
• Les blocs de configuration et d'exécution sont exécutés au début du cycle de vie du module et contiennent une logique importante. Ils ne peuvent pas être appelés directement comme d'autres composants, ce qui rend les tests délicats, mais en raison de leur rôle critique, ils ne peuvent pas être ignorés.
• AngularJS fournit une agrégation d'événements via l'événement $scope sur $emit/$broadcast, permettant aux objets d'interagir les uns avec les autres même s'ils ne se connaissent pas. Les tests unitaires sont écrits isolément, donc la spécification de test doit simuler une extrémité pour tester la fonctionnalité.
• Le routage définit la façon dont les utilisateurs naviguent dans l'application, et toutes les modifications peuvent entraîner une mauvaise expérience utilisateur. Par conséquent, le routage doit également être testé. Les deux routeurs les plus couramment utilisés dans les applications AngularJS sont NgOUTE et UI-Router.
• Les animations de test dans AngularJS sont plus simples que les instructions de test, et la bibliothèque angular-mocks contient des modules ngAnimateMock pour simplifier ce processus. AngularJS empêche l'animation de fonctionner jusqu'à la fin de la première boucle de digest pour accélérer la liaison initiale.

En train de créer et de fournir des logiciels entièrement fonctionnels, nous appliquons une variété de technologies pour vérifier l'exactitude et la qualité du logiciel. Les tests unitaires sont l'une des techniques. De nombreuses organisations mettent l'accent sur les tests unitaires car il réduit le coût de la recherche et de la résolution des problèmes potentiels de l'application. Lorsque nous avons commencé à développer des applications contenant des centaines de milliers de lignes de code JavaScript, nous n'avons pas pu éviter de tester le code. Certains développeurs JavaScript disent que le test de JavaScript est plus important car le comportement de la langue est inconnu avant l'exécution. Heureusement, AngularJS facilite le code de test écrit en utilisant ce cadre plus facile en prenant en charge les fonctionnalités telles que l'injection de dépendance (DI). Dans mes articles précédents, j'ai discuté de quelques conseils sur la simulation, comment tester les contrôleurs, les services et les fournisseurs, et comment tester les instructions. Cet article introduira des tests pour les blocs de démarrage (y compris les blocs de configuration, les blocs d'exécution et les blocs de résolution de routage), les événements portée et les animations pour les applications AngularJS. Vous pouvez télécharger le code utilisé dans cet article à partir de notre référentiel GitHub, où vous pouvez également trouver des instructions pour exécuter les tests.

Test Configuration et exécutez le bloc

Les blocs de configuration et d'exécution sont exécutés au début du cycle de vie du module. Ils contiennent une logique importante pour contrôler le fonctionnement des modules, des widgets ou des applications. Les tester est un peu délicat car ils ne peuvent pas être appelés directement comme les autres composants. En même temps, ils ne peuvent pas être ignorés car leur rôle est crucial. Considérez la configuration suivante et les blocs d'exécution:

angular.module('configAndRunBlocks', ['ngRoute'])
    .config(function ($routeProvider) {
    $routeProvider.when('/home', {
        templateUrl: 'home.html',
        controller: 'HomeController',
        resolve: {
            bootstrap: ['$q', function ($q) {
                return $q.when({
                    prop: 'value'
                });
            }]
        }
    })
        .when('/details/:id', {
        templateUrl: 'details.html',
        controller: 'DetailsController'
    })
        .otherwise({
        redirectTo: '/home'
    });
})
    .run(function ($rootScope, messenger) {

    messenger.send('Bootstrapping application');
    $rootScope.$on('$locationChangeStart', function (event, next, current) {
        messenger.send('Changing route to ' + next + ' from ' + current);
    });
});

Similaire au cas avec le fournisseur de test, nous devons nous assurer que le module est chargé avant de tester la configuration et d'exécuter la fonctionnalité dans le bloc. Par conséquent, nous utiliserons un bloc d'injection vide pour charger le module. L'extrait de code suivant simule les dépendances utilisées dans le bloc ci-dessus et charge le module:

describe('config and run blocks', function () {
    var routeProvider, messenger;

    beforeEach(function () {
        module('ngRoute');

        module(function ($provide, $routeProvider) {
            routeProvider = $routeProvider;
            spyOn(routeProvider, 'when').andCallThrough();
            spyOn(routeProvider, 'otherwise').andCallThrough();

            messenger = {
                send: jasmine.createSpy('send')
            };
            $provide.value('messenger', messenger);
        });

        module('configAndRunBlocks');
    });

    beforeEach(inject());
});

Je n'ai pas délibérément simulé l'objet $routeProvider car nous testerons les itinéraires enregistrés dans cet article plus tard. Le module est maintenant chargé, les blocs de configuration et d'exécution sont exécutés. Nous pouvons donc commencer à tester leur comportement. Étant donné que le bloc de configuration enregistre l'itinéraire, nous pouvons vérifier s'il enregistre l'itinéraire correct. Nous testerons si le nombre attendu d'itinéraires est enregistré. Les tests suivants vérifient la fonctionnalité du bloc de configuration:

describe('config block tests', function () {
    it('should have called registered 2 routes', function () {
        //Otherwise internally calls when. So, call count of when has to be 3
        expect(routeProvider.when.callCount).toBe(3);
    });

    it('should have registered a default route', function () {
        expect(routeProvider.otherwise).toHaveBeenCalled();
    });
});

Le bloc d'exécution dans l'exemple de code appelle un service et enregistre un événement. Nous testerons cet événement plus tard dans cet article. Actuellement, testons l'appel vers la méthode de service:

describe('run block tests', function () {
    var rootScope;
    beforeEach(inject(function ($rootScope) {
        rootScope = $rootScope;
    }));
    it('should send application bootstrap message', function () {
        expect(messenger.send).toHaveBeenCalled();
        expect(messenger.send).toHaveBeenCalledWith("Bootstrapping application");
    });
});

(La description ultérieure des événements de portée de test, du routage, des blocs d'analyse et des animations est omis ici en raison des limitations de l'espace. Pour les exemples complets de code de test, veuillez vous référer au référentiel GitHub d'origine)

Conclusion

Grâce à cet article, je présente la plupart des techniques de test que j'ai apprises pour tester le code AngularJS au cours des deux dernières années. Ce n'est pas la fin, et vous en apprendrez plus lorsque vous rédigerez des tests pour un scénario commercial de votre véritable application. J'espère que vous avez maintenant suffisamment de connaissances sur le test du code angularjs. Pourquoi attendre? Écrivez des tests pour chaque ligne de code que j'ai écrite jusqu'à présent!

(La partie FAQ dans le texte d'origine est également omise en raison des limitations de l'espace)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!