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

Je veux confirmer qu'une valeur est un décimal (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 imiter "> = 0"?

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

• toBeGreaterThanOrEqual
• toBeLessThanOrEqual

Vous devez utiliser ces fonctions de préférence aux conseils ci-dessous.

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

Je sais que c'est une question ancienne et résolue, mais j'ai remarqué qu'une solution assez soignée avait été manquée. Puisque 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.

Il vous suffit d'exécuter d'abord l'opération de comparaison, puis de vérifier si elle est véridique.

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

    var percent = insights.percent;

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

  });   
});

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

expect(myVariable).toBeGreaterThan(0);

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

Vous pouvez ajouter un matcher personnalisé comme celui-ci:

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-le avant de «démarrer». Les matchers de base sont chargés au moment du 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 boot.js, ajoutez l'appel pour ajouter les correspondants après que jasmine a été défini mais avant jasmine.getEnv (). Get env est en fait un appel de configuration (nommé légèrement).

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

/**
 * ## Require & 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 matchers personnalisés dans les exemples de tests, mais la façon dont cela fonctionne est de recréer le (s) matcher (s) avant chaque test à l'aide d'un fichier beforeEach. Cela semble assez horrible, alors j'ai pensé que j'opterais plutôt pour cette approche.

Je suis en retard mais je le poste juste au cas où quelqu'un visite encore 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

Pour par exemple

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

ou

expect(percent).toBeGreaterThanOrEqual(1);

J'ai rencontré le même problème aujourd'hui, et il s'avère qu'il n'est pas si difficile d'ajouter un matcher personnalisé pour cela. Le principal avantage d'un matcher personnalisé est qu'il peut renvoyer des messages significatifs lorsqu'un test échoue.

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;
        }
      };
    }

  } );

} );

Il a juste été fusionné dans la branche principale de Jasmine GitHub mon patch pour ajouter les correspondants dont vous avez besoin:

Ajouter les correspondances toBeGreatThanOrEqual et toBeLessThanOrEqual

Mais je n'ai aucune idée de la version dans laquelle ce sera. En attendant, vous pouvez essayer d'utiliser le code de mon commit dans votre copie locale de Jasmine.

Je recommande d'utiliser ce pluging Jasmine: https://github.com/JamieMason/Jasmine-Matchers

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

Un alias de leastis gte(supérieur ou égal à). Vice versa, 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)