web-dev-qa-db-fra.com

Comment puis-je tester qu'une valeur est "supérieure ou égale à" dans Jasmine?

Je veux confirmer qu'une valeur est une décimale (ou 0), donc le nombre doit être supérieur ou égal à zéro et inférieur à 1.

describe('percent',function(){  

  it('should be a decimal', function() {

    var percent = insights.percent; 
    expect(percent).toBeGreaterThan(0);
    expect(percent).toBeLessThan(1);

  });

});

Comment puis-je imiter "> = 0"?

javascripttddjasmine
82
Bryce Johnson

Vous devez d'abord exécuter l'opération de comparaison, puis vérifier si c'est vrai.

describe('percent',function(){
  it('should be a decimal',function(){

    var percent = insights.percent;

    expect(percent >= 0).toBeTruthy();
    expect(percent).toBeLessThan(1);

  });   
});
66
Bryce Johnson

J'ai pensé que je devrais mettre à jour ceci car l'API a changé dans les versions plus récentes de Jasmine. L'API Jasmine a maintenant des fonctions intégrées pour:

  • toBeGreaterThanOrEqual
  • toBeLessThanOrEqual

Vous devriez utiliser ces fonctions plutôt que les conseils ci-dessous.

Cliquez ici pour plus d'informations sur l'API Jasmine Matchers

Je sais qu’il s’agit d’une question ancienne et résolue, mais j’ai remarqué qu’une solution plutôt intéressante avait été manquée. Étant donné que supérieur ou égal à est l'inverse de la fonction inférieure à, essayez:

expect(percent).not.toBeLessThan(0);

Dans cette approche, la valeur de pourcentage peut être renvoyée par une fonction asynchrone et traitée dans le cadre du flux de contrôle.

97
Andrew

La version actuelle de Jasmine prend en charge toBeGreaterThan et toBeLessThan.

expect(myVariable).toBeGreaterThan(0);
11
DrMcCleod

Un peu étrange ce n'est pas une fonctionnalité de base

Vous pouvez ajouter un matcher personnalisé comme ceci:

JasmineExtensions.js

yourGlobal.addExtraMatchers = function () {
    var addMatcher = function (name, func) {
        func.name = name;
        jasmine.matchers[name] = func;
    };

    addMatcher("toBeGreaterThanOrEqualTo", function () {
                   return {
                       compare: function (actual, expected) {
                           return {
                               pass: actual >= expected
                           };
                       }
                   };
               }
    );
};

En fait, vous définissez un constructeur pour votre matcher - c'est une fonction qui renvoie un objet matcher.

Incluez cela avant de "démarrer". Les matchers de base sont chargés au démarrage.

Votre fichier HTML devrait ressembler à ceci:

<!-- jasmine test framework-->
<script type="text/javascript" src="lib/jasmine-2.0.0/jasmine.js"></script>
<script type="text/javascript" src="lib/jasmine-2.0.0/jasmine-html.js"></script>

<!-- custom matchers -->
<script type="text/javascript" src="Tests/JasmineExtensions.js"></script>
<!-- initialisation-->
<script type="text/javascript" src="lib/jasmine-2.0.0/boot.js"></script>

Ensuite, dans votre fichier boot.js, ajoutez l’appel pour ajouter les correspondants après que le jasmin ait été défini, mais avant jasmine.getEnv (). Get env est en réalité un appel de configuration (nommé légèrement de façon trompeuse).

Les correspondants sont configurés lors de l’appel de setupCoreMatchers dans le constructeur Env.

/**
 * ## Require &amp; Instantiate
 *
 * Require Jasmine's core files. Specifically, this requires and attaches all of Jasmine's code to the `jasmine` reference.
 */
window.jasmine = jasmineRequire.core(jasmineRequire);
yourGlobal.addExtraMatchers();

/**
 * Since this is being run in a browser and the results should populate to an HTML page, require the HTML-specific Jasmine code, injecting the same reference.
 */
jasmineRequire.html(jasmine);

/**
 * Create the Jasmine environment. This is used to run all specs in a project.
 */
var env = jasmine.getEnv();

Ils montrent une autre façon d’ajouter des correspondants personnalisés dans les exemples de tests. Toutefois, la méthode utilisée consiste à recréer le ou les correcteurs avant chaque test à l’aide de beforeEach. Cela semble assez horrible alors j'ai pensé que j'adopterais plutôt cette approche.

5
JonnyRaa

Je suis en retard mais je l’affiche juste au cas où quelqu'un reviendrait encore sur cette question à la recherche de réponses. J'utilise Jasmine version 3.0 et, comme mentionné par @Patrizio Rullo, vous pouvez utiliser toBeGreaterThanOrEqual/toBeLessThanOrEqual .

Il a été ajouté dans la version 2.5 selon les notes de publication - https://github.com/jasmine/jasmine/blob/master/release_notes/2.5.0.md

Par exemple.

expect(percent).toBeGreaterThanOrEqual(1,"This is optional expect failure message");

ou

expect(percent).toBeGreaterThanOrEqual(1);
5
Rohit

Il vient d'être fusionné dans la branche principale de Jasmine GitHub avec mon correctif pour ajouter les correspondants dont vous avez besoin:

Ajouter aux correspondants de BeGreatThanOrEqual et toBeLessThanOrEqual

Mais je ne sais pas dans quelle version ce sera. Pendant ce temps, vous pouvez essayer d’utiliser le code de mon commit dans votre copie Jasmine locale.

4
Patrizio Rullo

J'ai rencontré le même problème aujourd'hui, et il s'avère que ce n'est pas si difficile d'ajouter un accessoire personnalisé pour celui-ci. L'avantage principal d'un matcher personnalisé est qu'il peut renvoyer des messages significatifs en cas d'échec d'un test.

Voici donc le code pour deux correspondants, .toBeAtLeast() et .toBeAtMost(), au cas où cela aiderait quelqu'un.

beforeEach( function () {

  // When beforeEach is called outside of a `describe` scope, the matchers are
  // available globally. See http://stackoverflow.com/a/11942151/508355

  jasmine.addMatchers( {

    toBeAtLeast: function () {
      return {
        compare: function ( actual, expected ) {
          var result = {};
          result.pass = actual >= expected;
          if ( result.pass ) {
            result.message = "Expected " + actual + " to be less than " + expected;
          } else {
            result.message = "Expected " + actual + " to be at least " + expected;
          }
          return result;
        }
      };
    },

    toBeAtMost: function () {
      return {
        compare: function ( actual, expected ) {
          var result = {};
          result.pass = actual <= expected;
          if ( result.pass ) {
            result.message = "Expected " + actual + " to be greater than " + expected;
          } else {
            result.message = "Expected " + actual + " to be at most " + expected;
          }
          return result;
        }
      };
    }

  } );

} );
4
hashchange

Je recommande d'utiliser cette connexion Jasmine: https://github.com/JamieMason/Jasmine-Matchers

1
Broda Noel

Vous pouvez utiliser la fonction least pour vérifier si une valeur est supérieure ou égale à une autre valeur.

Un alias de least est gte (supérieur ou égal à). Inversement, vous pouvez utiliser lte (inférieur ou égal à) pour vérifier le contraire.

Donc, pour répondre à la question, vous pouvez faire:

expect(percent).to.be.gte(0)

1
Robinson Collado