How can I test that a value is "greater than or equal to" in Jasmine?

I want to confirm that a value is a decimal (or 0), so the number should be greater than or equal to zero and less than 1.

describe('percent',function(){	

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

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

});

How do I mimic " >= 0 "?

I figured I should update this since the API has changed in newer versions of Jasmine. The Jasmine API now has built in functions for:

• toBeGreaterThanOrEqual
• toBeLessThanOrEqual

You should use these functions in preference to the advice below.

Click here for more information on the Jasmine matchers API

I know that this is an old and solved question, but I noticed that a fairly neat solution was missed. Since greater than or equal to is the inverse of the less than function, Try:

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

In this approach, the value of percent can be returned by an async function and processed as a part of the control flow.

You just need to run the comparison operation first, and then check if it's truthy.

describe('percent',function(){
  it('should be a decimal',function(){
			
    var percent = insights.percent;

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

  });	
});

The current version of Jasmine supports toBeGreaterThan and toBeLessThan.

expect(myVariable).toBeGreaterThan(0);

I'm late to this but posting it just in case some one still visits this question looking for answers, I'm using Jasmine version 3.0 and as mentioned by @Patrizio Rullo you can use toBeGreaterThanOrEqual/toBeLessThanOrEqual.

It was added in version 2.5 as per release notes - https://github.com/jasmine/jasmine/blob/master/release_notes/2.5.0.md

For e.g.

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

or

expect(percent).toBeGreaterThanOrEqual(1);

Somewhat strangley this isn't basic functionality

You can add a custom matcher like this:

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 effect you're defining a constructor for your matcher - it's a function that returns a matcher object.

Include that before you 'boot'. The basic matchers are loaded at boot time.

Your html file should look like this:

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

Then in your boot.js add the call to add the matchers after jasmine has been defined but before jasmine.getEnv(). Get env is actually a (slightly misleadingly named) setup call.

The matchers get setup in the call to setupCoreMatchers in the Env constructor.

/**
 * ## 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();

They show another way of adding custom matchers in the sample tests, however the way it works is to recreate the matcher(s) before every single test using a beforeEach. That seems pretty horrible so I thought I'd go with this approach instead.

I have run into the same issue today, and as it turns out, it is not that difficult to add a custom matcher for it. The main advantage of a custom matcher is that it can return meaningful messages when a test fails.

So here is the code for two matchers, .toBeAtLeast() and .toBeAtMost(), in case it helps someone.

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

  } );

} );

It was just merged in the Jasmine GitHub master branch my patch to add the matchers you need:

Add toBeGreatThanOrEqual and toBeLessThanOrEqual matchers

But I have no idea in which release it will be. In the while, you can try to use the code of my commit in your local Jasmine copy.

Using This Updated Formula:

toBeGreaterThanOrEqual toBeLessThanOrEqual

Should Work!

I recommend use this Jasmine pluging: https://github.com/JamieMason/Jasmine-Matchers

You can use the function least to check if a value is greater than or equal to some other value.

An alias of least is gte (great than or equal to). Vice versa, you can use lte (less than or equal to) to check the opposite.

So, to answer the question, you can do:

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