Come posso verificare che un valore sia "maggiore o uguale a" in Jasmine?

Voglio confermare che un valore è un decimale (o 0), quindi il numero deve essere maggiore o uguale a zero e minore di 1.

describe('percent',function(){  

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

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

  });

});

Come imito "> = 0"?

Ho pensato che avrei dovuto aggiornarlo poiché l'API è cambiata nelle versioni più recenti di Jasmine. L'API Jasmine ora ha funzioni integrate per:

• toBeG GreaterThanOrEqual
• toBeLessThanOrEqual

È necessario utilizzare queste funzioni rispetto ai consigli seguenti.

Fare clic qui per ulteriori informazioni sull'API di corrispondenza Jasmine

So che questa è una domanda vecchia e risolta, ma ho notato che mancava una soluzione abbastanza chiara. Poiché maggiore o uguale a è l'inverso della funzione minore di, prova:

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

In questo approccio, il valore della percentuale può essere restituito da una funzione asincrona ed elaborato come parte del flusso di controllo.

Devi solo eseguire prima l'operazione di confronto e quindi verificare se è veritiera.

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

    var percent = insights.percent;

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

  });   
});

La versione corrente di Jasmine supporta toBeGuesdayThan e toBeLessThan.

expect(myVariable).toBeGreaterThan(0);

Un po 'strano, questa non è una funzionalità di base

Puoi aggiungere un abbinatore personalizzato come questo:

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

In effetti stai definendo un costruttore per il tuo matcher: è una funzione che restituisce un oggetto matcher.

Includilo prima di "avviare". I matcher di base vengono caricati al momento dell'avvio.

Il tuo file html dovrebbe assomigliare a questo:

<!-- 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>

Quindi nel tuo boot.js aggiungi la chiamata per aggiungere i matcher dopo che jasmine è stato definito ma prima di jasmine.getEnv (). Get env è in realtà una chiamata di configurazione (leggermente fuorviante).

I matcher vengono impostati nella chiamata a setupCoreMatchers nel costruttore 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();

Mostrano un altro modo per aggiungere abbinamenti personalizzati nei test di esempio, tuttavia il modo in cui funziona è ricreare gli abbinamenti prima di ogni singolo test utilizzando un file beforeEach. Sembra piuttosto orribile, quindi ho pensato di seguire questo approccio.

Sono in ritardo per questo ma pubblicandolo solo nel caso qualcuno visiti ancora questa domanda in cerca di risposte, sto usando Jasmine versione 3.0 e come menzionato da @Patrizio Rullo puoi usare toBeGuesdayOrEqual / toBeLessThanOrEqual .

È stato aggiunto nella versione 2.5 come da note di rilascio: https://github.com/jasmine/jasmine/blob/master/release_notes/2.5.0.md

Per es

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

o

expect(percent).toBeGreaterThanOrEqual(1);

Oggi ho riscontrato lo stesso problema e, a quanto pare, non è così difficile aggiungere un abbinamento personalizzato per questo. Il vantaggio principale di un abbinamento personalizzato è che può restituire messaggi significativi quando un test fallisce.

Quindi ecco il codice per due abbinamenti .toBeAtLeast()e .toBeAtMost(), nel caso in cui aiuti qualcuno.

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

  } );

} );

È stato appena fuso nel ramo master di Jasmine GitHub la mia patch per aggiungere i matcher di cui hai bisogno:

Aggiungi aBeGreatThanOrEqual e toBeLessThanOrEqual

Ma non ho idea in quale versione sarà. Nel frattempo, puoi provare a utilizzare il codice del mio commit nella tua copia Jasmine locale.

Consiglio di utilizzare questo plug-in Jasmine: https://github.com/JamieMason/Jasmine-Matchers

È possibile utilizzare la funzione leastper verificare se un valore è maggiore o uguale a un altro valore.

Un alias di leastis gte(great than or equal to). Viceversa, puoi usare lte(minore o uguale a) per verificare il contrario.

Quindi, per rispondere alla domanda, puoi fare:

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