Como posso testar se um valor é “maior ou igual a” no Jasmine?

Quero confirmar que um valor é decimal (ou 0), então o número deve ser maior ou igual a zero e menor que 1.

describe('percent',function(){  

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

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

  });

});

Como imito "> = 0"?

Achei que deveria atualizar isso, já que a API mudou nas versões mais recentes do Jasmine. A API Jasmine agora tem funções integradas para:

• toBeGreaterThanOrEqual
• toBeLessThanOrEqual

Você deve usar essas funções em preferência ao conselho abaixo.

Clique aqui para obter mais informações sobre a API de matchers Jasmine

Eu sei que essa é uma questão antiga e resolvida, mas percebi que uma solução bastante simples foi perdida. Como maior ou igual a é o inverso da função menor que, tente:

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

Nessa abordagem, o valor da porcentagem pode ser retornado por uma função assíncrona e processado como parte do fluxo de controle.

Você só precisa executar a operação de comparação primeiro e, em seguida, verificar se ela é verdadeira.

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

    var percent = insights.percent;

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

  });   
});

A versão atual do Jasmine oferece suporte a toBeGreaterThan e toBeLessThan.

expect(myVariable).toBeGreaterThan(0);

Um tanto estranho, esta não é uma funcionalidade básica

Você pode adicionar um matcher 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
                           };
                       }
                   };
               }
    );
};

Na verdade, você está definindo um construtor para seu matcher - é uma função que retorna um objeto matcher.

Inclua isso antes de 'inicializar'. Os matchers básicos são carregados no momento da inicialização.

Seu arquivo html deve ter a seguinte aparência:

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

Em seguida, em seu boot.js, adicione a chamada para adicionar os matchers após jasmine ter sido definido, mas antes de jasmine.getEnv (). Get env é, na verdade, uma chamada de configuração (com um nome um tanto enganador).

Os matchers são configurados na chamada para setupCoreMatchers no construtor 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();

Eles mostram outra maneira de adicionar correspondências customizadas nos testes de amostra; no entanto, a maneira como funciona é recriar os correspondências antes de cada teste usando um beforeEach. Isso parece horrível, então pensei em usar essa abordagem.

Estou atrasado para isso, mas postando apenas no caso de alguém ainda visitar esta questão em busca de respostas, estou usando Jasmine versão 3.0 e como mencionado por @Patrizio Rullo você pode usar toBeGreaterThanOrEqual / toBeLessThanOrEqual .

Ele foi adicionado na versão 2.5 de acordo com as notas de lançamento - https://github.com/jasmine/jasmine/blob/master/release_notes/2.5.0.md

Por exemplo

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

ou

expect(percent).toBeGreaterThanOrEqual(1);

Encontrei o mesmo problema hoje e, ao que parece, não é tão difícil adicionar um matcher personalizado para ele. A principal vantagem de um matcher customizado é que ele pode retornar mensagens significativas quando um teste falha.

Então aqui está o código para dois matchers .toBeAtLeast()e .toBeAtMost(), caso ajude alguém.

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

  } );

} );

Foi apenas mesclado no branch master Jasmine GitHub meu patch para adicionar os matchers de que você precisa:

Adicionar correspondências toBeGreatThanOrEqual e toBeLessThanOrEqual

Mas não tenho ideia de qual lançamento será. Enquanto isso, você pode tentar usar o código do meu commit em sua cópia local do Jasmine.

Recomendo usar este plug-in Jasmine: https://github.com/JamieMason/Jasmine-Matchers

Você pode usar a função leastpara verificar se um valor é maior ou igual a algum outro valor.

Um alias de leasté gte(maior ou igual a). Vice-versa, você pode usar lte(menor ou igual a) para verificar o oposto.

Então, para responder à pergunta, você pode fazer:

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