Wie kann ich testen, ob ein Wert in Jasmine größer oder gleich ist?

Ich möchte bestätigen, dass ein Wert eine Dezimalzahl (oder 0) ist, daher sollte die Zahl größer oder gleich Null und kleiner als 1 sein.

describe('percent',function(){  

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

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

  });

});

Wie ahme ich "> = 0" nach?

Ich dachte, ich sollte dies aktualisieren, da sich die API in neueren Versionen von Jasmine geändert hat. Die Jasmine-API verfügt jetzt über integrierte Funktionen für:

• toBeGreaterThanOrEqual
• toBeLessThanOrEqual

Sie sollten diese Funktionen den folgenden Hinweisen vorziehen.

Klicken Sie hier, um weitere Informationen zur Jasmine Matchers API zu erhalten

Ich weiß, dass dies eine alte und gelöste Frage ist, aber ich habe festgestellt, dass eine ziemlich ordentliche Lösung übersehen wurde. Da größer oder gleich ist die Umkehrung der Funktion kleiner als, versuchen Sie:

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

Bei diesem Ansatz kann der Prozentwert von einer asynchronen Funktion zurückgegeben und als Teil des Kontrollflusses verarbeitet werden.

Sie müssen nur zuerst die Vergleichsoperation ausführen und dann überprüfen, ob sie wahr ist.

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

    var percent = insights.percent;

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

  });   
});

Die aktuelle Version von Jasmine unterstützt toBeGreaterThan und toBeLessThan.

expect(myVariable).toBeGreaterThan(0);

Etwas seltsam ist dies keine grundlegende Funktionalität

Sie können einen benutzerdefinierten Matcher wie folgt hinzufügen:

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

Tatsächlich definieren Sie einen Konstruktor für Ihren Matcher - eine Funktion, die ein Matcher-Objekt zurückgibt.

Fügen Sie dies hinzu, bevor Sie "booten". Die grundlegenden Matcher werden beim Booten geladen.

Ihre HTML-Datei sollte folgendermaßen aussehen:

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

Fügen Sie dann in Ihrer boot.js den Aufruf hinzu, um die Matcher hinzuzufügen, nachdem Jasmin definiert wurde, aber vor jasmine.getEnv (). Get env ist eigentlich ein (leicht irreführend benannter) Setup-Aufruf.

Die Matcher werden beim Aufruf von setupCoreMatchers im Env-Konstruktor eingerichtet.

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

Sie zeigen eine andere Möglichkeit, benutzerdefinierte Matcher in den Beispieltests hinzuzufügen. Die Funktionsweise besteht jedoch darin, die Matcher vor jedem einzelnen Test mit a neu zu erstellen beforeEach. Das scheint ziemlich schrecklich zu sein, also dachte ich, ich würde stattdessen diesen Ansatz wählen.

Ich bin spät dran, aber wenn ich es noch poste, falls jemand diese Frage noch besucht, um nach Antworten zu suchen, verwende ich Jasmine Version 3.0 und wie von @Patrizio Rullo erwähnt, können Sie toBeGreaterThanOrEqual / toBeLessThanOrEqual verwenden .

Es wurde in Version 2.5 gemäß den Versionshinweisen hinzugefügt - https://github.com/jasmine/jasmine/blob/master/release_notes/2.5.0.md

Zum Beispiel

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

oder

expect(percent).toBeGreaterThanOrEqual(1);

Ich bin heute auf dasselbe Problem gestoßen, und wie sich herausstellt, ist es nicht so schwierig, einen benutzerdefinierten Matcher dafür hinzuzufügen. Der Hauptvorteil eines benutzerdefinierten Matchers besteht darin, dass er aussagekräftige Nachrichten zurückgeben kann, wenn ein Test fehlschlägt.

Hier ist also der Code für zwei Matcher, .toBeAtLeast()und .toBeAtMost()falls er jemandem hilft.

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

  } );

} );

Es wurde gerade im Jasmine GitHub-Hauptzweig mein Patch zusammengeführt, um die benötigten Matcher hinzuzufügen:

Fügen Sie zu BeGreatThanOrEqual und zu BeLessThanOrEqual Matchern hinzu

Aber ich habe keine Ahnung, in welcher Veröffentlichung es sein wird. In der Zwischenzeit können Sie versuchen, den Code meines Commits in Ihrer lokalen Jasmine-Kopie zu verwenden.

Ich empfehle die Verwendung dieses Jasmine-Steckers: https://github.com/JamieMason/Jasmine-Matchers

Mit der Funktion können Sie leastüberprüfen, ob ein Wert größer oder gleich einem anderen Wert ist.

Ein Alias ​​von leastis gte(groß oder gleich). Umgekehrt können Sie ltedas Gegenteil überprüfen (kleiner oder gleich).

Um die Frage zu beantworten, können Sie Folgendes tun:

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