javascript - tutorial - karma js

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

Question

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"?

Answer 1

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

expect(myVariable).toBeGreaterThan(0);

Answer 2

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

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

Por ej.

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

o

expect(percent).toBeGreaterThanOrEqual(1);

Answer 3

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

Así que aquí está el código para dos emparejamientos, .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://.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;
        }
      };
    }

  } );

} );

Answer 4

Puede usar la función least para verificar si un valor es mayor o igual a algún otro valor.

Un alias de least es gte (igual o mayor que). Viceversa, puede usar lte (menor o igual que) para verificar lo opuesto.

Entonces, para responder la pregunta, puedes hacer:

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

Answer 5

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

Answer 6

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

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.

Answer 7

Simplemente se fusionó en la rama maestra de Jasmine GitHub mi parche para agregar los adaptadores que necesita:

Agregue a los emparejamientos de BebeGreatThanOrEqual y toBeLessThanOrEqual

Pero no tengo idea de cuál será el lanzamiento. Por el momento, puedes intentar usar el código de mi confirmación en tu copia local de Jasmine.

Answer 8

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

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

    var percent = insights.percent;

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

  });   
});

Answer 9

Un poco estrangulado, esto no es una funcionalidad básica

Puede agregar un marcador 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 de coincidencia.

Incluya eso antes de ''iniciar''. Los compensadores 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 emparejamientos después de que se haya definido jazmín pero antes de jasmin.getEnv (). Get env es en realidad una llamada de configuración (un poco engañosamente llamada).

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 coincidencias personalizadas en las pruebas de muestra, sin embargo, la forma en que funciona es recrear las (s) competencia (s) antes de cada prueba usando un beforeEach . Eso parece bastante horrible, así que pensé que iría con este enfoque en su lugar.