¿Cómo puedo probar que un valor es "mayor o igual que" en Jasmine?

Quiero confirmar que un valor es un decimal (o 0), por lo que el número debe ser mayor o igual que cero y menor que 1.

describe('percent',function(){  

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

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

  });

});

¿Cómo imito "> = 0"?

Pensé que debería actualizar esto ya que la API ha cambiado en las versiones más recientes de Jasmine. La API de Jasmine ahora tiene funciones integradas para:

• toBeGreaterThanOrEqual
• toBeLessThanOrEqual

Debe utilizar estas funciones en lugar de los consejos siguientes.

Haga clic aquí para obtener más información sobre la API de Jasmine Matchers

Sé que esta es una pregunta antigua y resuelta, pero noté que se perdió una solución bastante ordenada. Dado que mayor o igual que es la inversa de la función menor que, intente:

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

En este enfoque, el valor del porcentaje puede ser devuelto por una función asíncrona y procesado como parte del flujo de control.

Solo necesita ejecutar la operación de comparación primero y luego verificar si es veraz.

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

    var percent = insights.percent;

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

  });   
});

La versión actual de Jasmine admite toBeGreaterThan y toBeLessThan.

expect(myVariable).toBeGreaterThan(0);

Algo estrangulado, esta no es una funcionalidad básica

Puede agregar un comparador personalizado como este:

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 efecto, está definiendo un constructor para su matcher: es una función que devuelve un objeto matcher.

Incluya eso antes de 'arrancar'. Los comparadores básicos se cargan en el momento del arranque.

Su archivo html debería verse así:

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

Luego, en su boot.js, agregue la llamada para agregar los emparejadores después de que se haya definido jasmine pero antes de jasmine.getEnv (). Get env es en realidad una llamada de configuración (con un nombre un poco engañoso).

Los emparejadores se configuran en la llamada a setupCoreMatchers en el constructor 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();

Muestran otra forma de agregar comparadores personalizados en las pruebas de muestra, sin embargo, la forma en que funciona es recrear los comparadores antes de cada prueba usando un archivo beforeEach. Eso parece bastante horrible, así que pensé en este enfoque.

Llego tarde a esto, pero lo publico en caso de que alguien todavía visite esta pregunta en busca de respuestas, estoy usando Jasmine versión 3.0 y, como lo menciona @Patrizio Rullo, puede usar toBeGreaterThanOrEqual / toBeLessThanOrEqual .

Se agregó en la versión 2.5 según las notas de la versión: https://github.com/jasmine/jasmine/blob/master/release_notes/2.5.0.md

Por ejemplo

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

o

expect(percent).toBeGreaterThanOrEqual(1);

Hoy me he encontrado con el mismo problema, y ​​resulta que no es tan difícil agregarle un comparador personalizado. La principal ventaja de un comparador personalizado es que puede devolver mensajes significativos cuando falla una prueba.

Así que aquí está el código para dos comparadores .toBeAtLeast()y .toBeAtMost(), en caso de que ayude a alguien.

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

  } );

} );

Se acaba de fusionar en la rama maestra de Jasmine GitHub mi parche para agregar los emparejadores que necesita:

Agregar a los emparejadoresBeGreatThanOrEqual y toBeLessThanOrEqual

Pero no tengo idea de en qué versión será. Mientras tanto, puedes intentar usar el código de mi confirmación en tu copia local de Jasmine.

Recomiendo usar este pluging Jasmine: https://github.com/JamieMason/Jasmine-Matchers

Puede utilizar la función leastpara comprobar si un valor es mayor o igual que algún otro valor.

Un alias de leastes gte(mayor o igual que). Viceversa, puede usar lte(menor o igual a) para verificar lo contrario.

Entonces, para responder a la pregunta, puede hacer:

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