Sinon Tutorial: JavaScript -Tests mit Mocks, Spione & Stubs

Dieser Artikel wurde von Mark Brown und Marc Towler überprüft. Vielen Dank an alle SitePoint -Peer -Rezensenten, die SidePoint -Inhalte für die Besten erhalten haben!

Eines der größten Hindernisse beim Schreiben von Unit-Tests ist, wie man mit nicht trivialem Code umgeht.

In den tatsächlichen Projekten führt der Code häufig verschiedene Vorgänge aus, die Tests erschweren. AJAX -Anfragen, Timer, Daten, Zugriff auf andere Browserfunktionen… oder Datenbanken machen immer Spaß, wenn Sie node.js verwenden.

all dies ist schwer zu testen, da Sie sie nicht in Ihrem Code steuern können. Wenn Sie AJAX verwenden, benötigen Sie einen Server, um auf die Anfrage zu antworten, damit Ihre Tests bestehen können. Wenn Sie SetTimeout verwenden, muss Ihr Test warten. Gleiches gilt für eine Datenbank oder ein Netzwerk - Sie benötigen eine Datenbank mit den richtigen Daten oder einem Netzwerkserver.

Das wirkliche Leben ist nicht so einfach, wie viele Test -Tutorials scheinen. Aber wissen Sie, dass es eine Lösung gibt?

Mit Sinon können wir das Testen nicht trivialer Code trivial machen!

Mal sehen, wie es funktioniert.

Schlüsselpunkte

• Sinon vereinfachte Tests: Sinon.js ist entscheidend für die Vereinfachung der Tests von JavaScript -Code, das komplexe Vorgänge wie AJAX -Anrufe, Timer und Datenbankinteraktionen umfasst, da diese Teile durch Mocks, Spies und Stubs ersetzt werden können.
• Drei Arten von Tests: Sinon klassifiziert Tests als Spione (Sammeln von Informationen über Funktionsaufrufe); ganze Objekte).
• Praktische Fälle: Sinon ist besonders nützlich in Szenarien für Unit-Tests, in denen externe Abhängigkeiten die Tests komplizieren oder verlangsamen können, z. B. externe API-Aufrufe oder zeitbasierte Funktionen.
• Integration und Setup: Sinon kann leicht in node.js- und browserbasierte Testumgebungen integriert werden, wodurch die Vielseitigkeit und Benutzerfreundlichkeit in einer Vielzahl von JavaScript-Anwendungen verbessert werden.
• Verbesserte Behauptungen: Sinon bietet verbesserte Assertionsmethoden, die klarere Fehlermeldungen generieren und den Debugging -Prozess während der Testfehler verbessern.
• Best Practice: Verwenden Sie sinon.test() Verpackungstestfälle stellt sicher, dass der Test-Stand-In ordnungsgemäß gereinigt wird, die Nebenwirkungen in anderen Tests verhindert und potenzielle Fehler in der Testsuite verringert.

Was macht Sinon so wichtig und nützlich?

Wie machen Sie das, wenn Sie den Code testen möchten, der Ajax -Anrufe tätigt? Sie müssen einen Server ausführen und sicherstellen, dass er die genaue Antwort bietet, die Sie für Ihre Tests benötigen. Das Einrichten ist kompliziert und es schwierig, das Schreiben und Ausführen von Unit -Tests schwierig zu machen.

Was ist, wenn Ihr Code von der Zeit abhängt? Angenommen, es wartet auf eine Sekunde, bevor sie eine Aktion ausführen. Was tun jetzt? Sie können SetTimeout in Ihrem Test verwenden, um auf eine Sekunde zu warten, aber dies verlangsamt den Test. Stellen Sie sich vor, das Intervall ist beispielsweise fünf Minuten lang. Ich denke, Sie möchten wahrscheinlich nicht jedes Mal, wenn Sie Ihre Tests durchführen, fünf Minuten warten.

Durch die Verwendung von Sinon können wir beide Probleme (und viele andere) lösen und die Komplexität beseitigen.

Wie funktioniert Sinon?

Sinon hilft, Komplexität beim Testen zu beseitigen, indem Sie leicht sogenannte Test-Stand-in erstellen können.

Wie der Name schon sagt, ist der Test-Stand-In ein Ersatz für die im Test verwendeten Codeausschnitte. Wenn wir auf das AJAX-Beispiel zurückblicken, werden wir den Server nicht einrichten, sondern den AJAX-Aufruf durch den Test-Stand-in ersetzen. Für das zeitliche Beispiel werden wir einen Test-Stand-in verwenden, damit wir "Zeit nach vorne bewegen".

Das mag ein wenig seltsam klingen, aber das Grundkonzept ist einfach. Da JavaScript sehr dynamisch ist, können wir jede Funktion übernehmen und sie durch etwas anderes ersetzen. Das Testen eines Stellvertreters geht diese Idee nur noch einen Schritt weiter. Mit Sinon können wir jede JavaScript-Funktion durch einen Test-Stand-in ersetzen, und dann können wir sie so konfigurieren, dass sie verschiedene Operationen ausführen, um die Testkomplexe einfach zu machen.

Sinon unterteilt Test-Stand-Ins in drei Typen:

• Spion, die Informationen über Funktionsaufrufe bereitstellen, ohne ihr Verhalten zu beeinflussen
• Stub, wie ein Spion, ersetzt aber die Funktion vollständig. Dies ermöglicht es, die Stub -Funktion zu ermöglichen, was Ihnen gefällt - Ausnahmen werfen, bestimmte Werte zurückgeben usw.
• Simulation durch Kombination von Spione und Stubs erleichtert es, das gesamte Objekt zu ersetzen

Darüber hinaus bietet Sinon einige andere Hilfsprogramme, obwohl diese Hilfsprogramme außerhalb des Rahmens dieses Artikels liegen:

• gefälschter Timer kann verwendet werden, um die Zeit nach vorne zu verschieben, z. B. das Auslösen von SetTimeout
• gefälschte XMLHTTPREQUEST und Server, mit der AJAX -Anforderungen und Antworten
gestaltet werden können.

Verwenden Sie NPM, um Sinon zu installieren, um Sinon über NPM
2. zu installieren
In Ihren Tests in Ihren Tests mit var sinon = required ('Sinon') einführen;

für browserbasierte Tests:

1. Sie können NPM verwenden, um Sinon über NPM zu installieren, eine CDN zu verwenden oder von Sinons Website
herunterzuladen
2. Einbeziehen Sinon.js in Ihre Test -Läufer -Seite.

Anfänger

Sinon hat viele Merkmale, aber viele von ihnen sind auf sich selbst aufgebaut. Sie kennen einen Teil davon und wissen bereits den nächsten Teil. Sobald Sie die Grundlagen verstanden und verstehen, was jedes unterschiedliche Teil tut, macht Sinon einfach zu bedienen.

Wir brauchen normalerweise Sinon, wenn unser Code eine Funktion aufruft, die uns Ärger verursacht.

Für Ajax kann es $ .get oder xmlhttprequest sein. Für die Zeit kann die Funktion SetTimeout sein. Für Datenbanken könnte es mongoDB.Findone sein.

Um es einfacher zu machen, diese Funktion zu besprechen, nenne ich sie die Abhängigkeit . Die Funktion, die wir testen, hängt vom Ergebnis einer anderen Funktion ab. Wir können sagen, dass Sinons grundlegendes Verwendungsmuster darin besteht, problematische Abhängigkeiten durch Test-Stand-Ins zu ersetzen.

simuliert
• Wenn wir die Zeit testen, ersetzen wir SetTimeout durch einen gefälschten Timer
• Beim Testen des Datenbankzugriffs können wir MongoDB.Findone durch einen Test-Stand-in ersetzen, der einige gefälschte Daten sofort zurückgibt
Mal sehen, wie es in der Praxis funktioniert.

Spion

Spion ist der einfachste Teil von Sinon, und andere Merkmale sind darauf aufgebaut.

Der Hauptzweck von Spione besteht darin, Informationen über Funktionsaufrufe zu sammeln. Sie können sie auch verwenden, um bestimmte Dinge zu überprüfen, z. B. ob eine Funktion aufgerufen wird.

var spy = sinon.spy();

//我们可以像函数一样调用间谍
spy('Hello', 'World');

//现在我们可以获取有关调用的信息
console.log(spy.firstCall.args); //输出：['Hello', 'World']

Obwohl Sie anonyme Spione erstellen können, indem Sie Sinon.spy ohne Parameter aufrufen, ist das häufigere Muster, eine andere Funktion durch einen Spion zu ersetzen.

var user = {
  ...
  setName: function(name){
    this.name = name;
  }
}

//为 setName 函数创建一个间谍
var setNameSpy = sinon.spy(user, 'setName');

//现在，每当我们调用该函数时，间谍都会记录有关它的信息
user.setName('Darth Vader');

//我们可以通过查看间谍对象来查看
console.log(setNameSpy.callCount); //输出：1

//重要最后一步 - 删除间谍
setNameSpy.restore();

spy verfügt über viele verschiedene Eigenschaften, die unterschiedliche Informationen darüber liefern, wie sie verwendet werden. Die Spionagedokumentation von Sinon enthält eine vollständige Liste aller verfügbaren Optionen.

In der Praxis verwenden Sie möglicherweise nicht oft Spione. Es ist wahrscheinlicher, dass Sie einen Stub benötigen, aber Spione können bequem sein, z. B. zu überprüfen, ob ein Rückruf genannt wird:

function myFunction(condition, callback){
  if(condition){
    callback();
  }
}

describe('myFunction', function() {
  it('should call the callback function', function() {
    var callback = sinon.spy();

    myFunction(true, callback);

    assert(callback.calledOnce);
  });
});

Sinons Behauptung

Bevor wir zum Stub fahren, lass uns einen kurzen Umweg machen und einen Blick auf die Behauptung von Sinon werfen.

In den meisten Testfällen, in denen Sie Spy (und Stubs) verwenden, müssen Sie die Ergebnisse des Tests überprüfen.

Wir können jede Art von Behauptung verwenden, um das Ergebnis zu überprüfen. Im vorherigen Beispiel über Rückrufe haben wir die Assert -Funktion von Chai verwendet, die sicherstellt, dass der Wert der wahre Wert ist.

var spy = sinon.spy();

//我们可以像函数一样调用间谍
spy('Hello', 'World');

//现在我们可以获取有关调用的信息
console.log(spy.firstCall.args); //输出：['Hello', 'World']

Der Nachteil davon ist, dass die Fehlermeldung zum Fehler unklar ist. Sie erhalten nur eine Eingabeaufforderung wie "Falsch ist nicht wahr" oder ähnlich. Wie Sie sich vorstellen können, ist dies nicht sehr hilfreich, um herauszufinden, wo das Problem liegt, und Sie müssen sich den Quellcode des Tests ansehen, um es herauszufinden. Kein Spaß.

Um dieses Problem zu lösen, können wir benutzerdefinierte Fehlermeldungen in die Behauptung einbeziehen.

var user = {
  ...
  setName: function(name){
    this.name = name;
  }
}

//为 setName 函数创建一个间谍
var setNameSpy = sinon.spy(user, 'setName');

//现在，每当我们调用该函数时，间谍都会记录有关它的信息
user.setName('Darth Vader');

//我们可以通过查看间谍对象来查看
console.log(setNameSpy.callCount); //输出：1

//重要最后一步 - 删除间谍
setNameSpy.restore();

Aber warum sich die Mühe machen, wenn wir Sinons eigene Behauptung verwenden können?

function myFunction(condition, callback){
  if(condition){
    callback();
  }
}

describe('myFunction', function() {
  it('should call the callback function', function() {
    var callback = sinon.spy();

    myFunction(true, callback);

    assert(callback.calledOnce);
  });
});

Die Verwendung von Sinons Behauptungen wie diese kann sofort bessere Fehlermeldungen liefern. Dies ist nützlich, wenn Sie komplexere Bedingungen wie Parameter einer Funktion validieren müssen.

Folgendes sind einige andere nützliche Behauptungen von Sinon:

• sinon.assert.called with kann verwendet werden, um zu überprüfen, ob die Funktion mit einem bestimmten Parameter aufgerufen wurde (dies ist wahrscheinlich die, die ich am meisten verwende)
• Sinon.assert.Callorder kann überprüfen, ob die Funktion in einer bestimmten Reihenfolge aufgerufen wird

Wie Spione enthält die Behauptungsdokumentation von Sinon alle verfügbaren Optionen. Wenn Sie es vorziehen, Chai zu verwenden, gibt es auch ein Sinon-Chai-Plugin, mit dem Sie die Sinon-Behauptungen über die Erwartung von Chai verwenden können.

Stub

Stubs sind der bevorzugte Test-Stand-in, da sie flexibel und bequem sind. Sie haben alle Funktionen von Spione, sind aber mehr als nur die Rolle der Überwachungsfunktionen, und der Stub ersetzt sie vollständig. Mit anderen Worten, bei der Verwendung von Spion wird die ursprüngliche Funktion immer noch ausgeführt, aber wenn sie Stubs verwenden, wird nicht ausgeführt.

Dies macht Stubs für viele Aufgaben sehr geeignet, wie:

• Ersetzen Sie AJAX oder andere externe Anrufe, die die Tests langsam und schwer zu schreiben
machen
• verschiedene Codepfade nach Funktionsausgabe
auslösen
• Testausnahmen, z. B. was passiert, wenn eine Ausnahme ausgelöst wird?

Die Art und Weise, wie wir Stubs erstellen können, ähnelt der von Spione ...

assert(callback.calledOnce);

Wir können anonyme Stubs wie Spione erstellen, aber Stubs werden sehr nützlich, wenn Sie vorhandene Funktionen durch Stubs ersetzen.

Wenn wir beispielsweise einen Code haben, der die AJAX -Funktion von JQuery verwendet, ist es schwierig, ihn zu testen. Der Code sendet eine Anfrage an einen beliebigen Server, den wir konfigurieren, daher müssen wir ihn zur Verfügung stellen oder dem Code einen Sonderfall hinzufügen, damit er dies nicht in einer Testumgebung ausführt - das ist ein großes Tabu. Sie sollten kaum testspezifische Fälle in Ihren Code aufnehmen.

Anstatt sich schlechten Praktiken zuzuwenden, können wir Sinon verwenden und die AJAX -Funktion durch einen Stub ersetzen. Dies macht das Testen trivial.

Dies ist eine Beispielfunktion, die wir testen werden. Es nimmt das Objekt als Parameter und sendet es über AJAX an eine vordefinierte URL.

var spy = sinon.spy();

//我们可以像函数一样调用间谍
spy('Hello', 'World');

//现在我们可以获取有关调用的信息
console.log(spy.firstCall.args); //输出：['Hello', 'World']

Normalerweise wird das Testen aufgrund von AJAX -Aufrufen und vordefinierten URLs schwierig sein. Wenn wir jedoch Stubs verwenden, wird es einfach.

Angenommen, wir möchten sicherstellen, dass die an SaveUer übergebene Rückruffunktion nach Abschluss der Anfrage korrekt aufgerufen wird.

var user = {
  ...
  setName: function(name){
    this.name = name;
  }
}

//为 setName 函数创建一个间谍
var setNameSpy = sinon.spy(user, 'setName');

//现在，每当我们调用该函数时，间谍都会记录有关它的信息
user.setName('Darth Vader');

//我们可以通过查看间谍对象来查看
console.log(setNameSpy.callCount); //输出：1

//重要最后一步 - 删除间谍
setNameSpy.restore();

Hier ersetzen wir die Ajax -Funktion durch einen Stub. Dies bedeutet, dass die Anfrage nie gesendet wird, wir keinen Server oder so etwas benötigen - wir haben die vollständige Kontrolle darüber, was im Testcode vor sich geht!

Weil wir sicherstellen möchten, dass der Rückruf, den wir an SaveUser geben, aufgerufen wird, werden wir den Stub Ertrag anweisen. Dies bedeutet, dass der Stub die erste Funktion automatisch als Parameter aufruft. Dies simuliert das Verhalten von $ .post, das den Rückruf nach Abschluss der Anfrage aufruft.

Zusätzlich zum Stub haben wir in diesem Test einen Spion erstellt. Wir können normale Funktionen als Rückrufe verwenden, aber die Verwendung von Spione können die Ergebnisse des Tests mit Sinon.assert.Calledonce -Behauptung leicht überprüfen.

In den meisten Fällen können Sie, wenn Sie Stubs benötigen, dasselbe Grundmuster folgen:

• Finden Sie die fragliche Funktion, wie z. B. $ .post
• Zeigen Sie, wie es funktioniert, damit Sie es in Ihren Tests verspotten können
• Erstellen Sie einen Stub
• Stellen Sie den Stub auf, um das gewünschte Verhalten im Test
zu haben.

Eine weitere häufige Verwendung von

function myFunction(condition, callback){
  if(condition){
    callback();
  }
}

describe('myFunction', function() {
  it('should call the callback function', function() {
    var callback = sinon.spy();

    myFunction(true, callback);

    assert(callback.calledOnce);
  });
});

Wenn Sie mehrere Funktionen aus einem einzelnen Objekt stoßen müssen, sind sie hauptsächlich nützlich. Wenn Sie nur eine einzelne Funktion ersetzen müssen, ist der Stub einfacher zu bedienen.

Sie sollten vorsichtig sein, wenn Sie Simulation verwenden! Aufgrund ihrer Leistung ist es einfach, Ihre Tests zu spezifisch zu machen - zu viele und zu spezifische Dinge -, die Ihre Tests versehentlich anfällig machen können.

Im Gegensatz zu Spione und Stubs haben Simulationen integrierte Behauptungen. Sie können das erwartete Ergebnis vorlegen, indem Sie dem Scheinobjekt mitgeteilt werden, was passieren muss, und dann die Überprüfungsfunktion am Ende des Tests aufzurufen.

Angenommen, wir verwenden Store.js, um den Inhalt in LocalStorage zu speichern, und wir möchten die damit verbundenen Funktionen testen. Wir können Simulation verwenden, um dies wie folgt zu testen:

var spy = sinon.spy();

//我们可以像函数一样调用间谍
spy('Hello', 'World');

//现在我们可以获取有关调用的信息
console.log(spy.firstCall.args); //输出：['Hello', 'World']

Bei der Verwendung von Simulation verwenden wir einen reibungslosen Anrufstil, um den erwarteten Anruf und seine Ergebnisse zu definieren, wie oben gezeigt. Dies entspricht der Verwendung der Behauptung zur Validierung der Testergebnisse, mit der Ausnahme, dass wir sie vordefiniert haben, und um sie zu überprüfen, nennen wir Storemock.Verify () am Ende des Tests.

In Sinons Mock -Objektbegriff erstellt das Aufrufen von Mock.xpects ('etwas') eine erwarten . Das heißt, die Methode verspottet. Jede Erwartung unterstützt die gleichen Funktionen wie Spion und Stubs zusätzlich zur Emulation spezifischer Funktionen.

Sie können feststellen, dass die Verwendung von Stubs normalerweise einfacher ist als die Verwendung von Simulationen - es ist völlig in Ordnung. Simulation sollte mit Vorsicht verwendet werden.

Eine vollständige Liste simulierter spezifischer Funktionen finden Sie in Sinons Simulationsdokumentation.

Wichtige Best Practices: Verwenden Sie Sinon.test ()

Sinon hat eine wichtige Best Practice, die bei der Verwendung von Spione, Stubs oder Simulationen berücksichtigt werden sollte.

Wenn Sie eine vorhandene Funktion durch einen Test-Stand-in ersetzen, verwenden Sie Sinon.test ().

Im vorherigen Beispiel verwenden wir Stub.Restore () oder Mock.restore (), um den Inhalt nach der Verwendung zu beseitigen. Dies ist notwendig, da der Test-Stand-In ansonsten vorhanden bleibt und andere Tests negativ beeinflussen oder zu Fehlern führen kann.

, aber es ist problematisch, die Funktion restore () direkt zu verwenden. Die getestete Funktion kann einen Fehler verursachen und die Testfunktion beenden, bevor Sie restore () aufrufen!

Wir haben zwei Möglichkeiten, dieses Problem zu lösen: Wir können den gesamten Inhalt in einem Versuchsfangblock einwickeln. Dies ermöglicht es uns, den restrow () -Anruf in den endgültigen Block zu setzen, um sicherzustellen, dass er läuft, egal was passiert.

oder, ein besserer Weg ist es, die Testfunktion mit Sinon.Test () zu wickeln

var user = {
  ...
  setName: function(name){
    this.name = name;
  }
}

//为 setName 函数创建一个间谍
var setNameSpy = sinon.spy(user, 'setName');

//现在，每当我们调用该函数时，间谍都会记录有关它的信息
user.setName('Darth Vader');

//我们可以通过查看间谍对象来查看
console.log(setNameSpy.callCount); //输出：1

//重要最后一步 - 删除间谍
setNameSpy.restore();

sandbox -Funktion zu verwenden, sodass wir Spione und Stubs durch diese.spy (), this.stub () und this.mock () erstellen können () (). und Simulation. Jedes Test-Stand-In, der mit der Sandbox erstellt wurde, wird automatisch aufgeräumt. Beachten Sie, dass unser Beispielcode oben nicht stub.restore () enthält - es ist unnötig, da der Test Sandboxen ist.

Wenn Sie Sinon.Test () verwenden, wann immer möglich, können Sie das Problem vermeiden, dass der Test aufgrund eines frühen Tests zufällig fehlschlägt, ohne dass der Test aufgrund von Fehlern eigenständig ist.

Sinon ist keine magische

Sinon führt viele Operationen aus und kann manchmal schwer zu verstehen, wie es funktioniert. Schauen wir uns einige einfache JavaScript -Beispiele an, wie Sinon funktioniert, damit wir besser verstehen können, wie es intern funktioniert. Dies hilft Ihnen dabei, es effizienter in verschiedenen Situationen zu verwenden.

Wir können auch manuell Spione, Stubs und Simulationen erstellen. Der Grund, warum wir Sinon verwenden, ist, dass es Aufgaben trivial macht - manuell zu schaffen, kann sehr komplex sein, aber lassen Sie uns sehen, wie es funktioniert, um zu verstehen, was Sinon tut.

Zunächst ist Spy im Wesentlichen ein Funktionsumschlag:

var spy = sinon.spy();

//我们可以像函数一样调用间谍
spy('Hello', 'World');

//现在我们可以获取有关调用的信息
console.log(spy.firstCall.args); //输出：['Hello', 'World']

Wir können mit benutzerdefinierten Funktionen problemlos Spionagefunktionen erhalten. Beachten Sie jedoch, dass Sinons Spione ein breiteres Angebot an Funktionen bieten - einschließlich der Unterstützung der Behauptung. Dies macht Sinon bequemer.

Was ist mit dem Stub?

Um einen sehr einfachen Stub zu erstellen, können Sie einfach eine Funktion durch eine neue Funktion ersetzen:

var user = {
  ...
  setName: function(name){
    this.name = name;
  }
}

//为 setName 函数创建一个间谍
var setNameSpy = sinon.spy(user, 'setName');

//现在，每当我们调用该函数时，间谍都会记录有关它的信息
user.setName('Darth Vader');

//我们可以通过查看间谍对象来查看
console.log(setNameSpy.callCount); //输出：1

//重要最后一步 - 删除间谍
setNameSpy.restore();

Sinons Stubs bieten jedoch mehrere Vorteile:

• Sie enthalten volle Spionagefunktionen
• Sie können das ursprüngliche Verhalten einfach mit stub.restore ()
wiederherstellen
• Sie können gegen Sinon Stubs
behaupten

Simulationen kombinieren einfach das Verhalten von Spione und Stubs, so dass ihre Funktionalität auf unterschiedliche Weise verwendet werden kann.

Obwohl Sinon manchmal so aussieht, als ob es viel "Magie" gemacht hat, kann dies in den meisten Fällen leicht mit Ihrem eigenen Code erfolgen. Sinon ist viel bequemer zu bedienen, anstatt für diesen Zweck eine eigene Bibliothek schreiben zu müssen.

Schlussfolgerung

Testen des Reallebens erscheint manchmal zu kompliziert und kann leicht vollständig aufgeben. Aber bei Sinon wird das Testen fast jeder Code -Art zu einer Kinderspiel.

Denken Sie nur an das Hauptprinzip: Wenn die Funktion Ihren Test schwer zu schreiben macht, versuchen Sie, ihn durch einen Test-Stand-in zu ersetzen. Dieses Prinzip gilt unabhängig von der Funktion.

Möchten Sie wissen, wie Sie Sinon in Ihrem eigenen Code anwenden? Besuchen Sie meine Website und ich schicke Ihnen meinen kostenlosen Sinon -Leitfaden für reale Welt, der drei Beispiele für Sinon Best Practices und die Anwendung in verschiedenen Arten von Testsituationen enthält!

FAQs über Sinon.js Test (FAQ)

Was ist der Unterschied zwischen Mocks, Spione und Stubs in Sinon.js?

In Sinon.js haben Mocks, Spione und Stubs unterschiedliche Verwendungen. Ein Spion ist eine Funktion, die alle als Parameter, Rückgabewerte, den Wert davon aufzeichnet und die Ausnahme (falls vorhanden). Sie können verwendet werden, um Funktionsaufrufe und Antworten zu verfolgen. Der Stub ähnelt einem Spion, hat aber ein vorprogrammiertes Verhalten. Sie erfassen auch Informationen darüber, wie sie aufgerufen werden, aber im Gegensatz zu Spione können sie verwendet werden, um das Verhalten von Methoden zu kontrollieren, um Methoden zu erzwingen, um Fehler zu werfen oder bestimmte Werte zurückzugeben. Simulation ist eine falsche Methode mit vorprogrammiertem Verhalten (wie Stubs) sowie vorprogrammierten Erwartungen (wie Spion).

Wie kann man Sinon.js für Unit -Tests in JavaScript verwenden?

sinon.js ist ein leistungsstarkes Werkzeug zum Erstellen von Spione, Stubs und Mocks bei JavaScript -Tests. Um es zu verwenden, müssen Sie es zunächst in Ihr Projekt aufnehmen, indem Sie Skript -Tags in Ihrem HTML verwenden oder über NPM installieren. Sobald Sie enthalten sind, können Sie mit seiner API Spione, Stubs und Mocks erstellen und verwalten. Diese können dann verwendet werden, um den Code zu isolieren, den Sie testen, und sicherstellen, dass er wie erwartet funktioniert.

Wie kann man einen Spion in Sinon.js erstellen?

Es ist einfach, einen Spion in Sinon.js zu erstellen. Sie müssen nur die Funktion Sinon.spy () aufrufen. Dies gibt eine Spionagefunktion zurück, die Sie in Ihren Tests verwenden können. Der Spion wird Informationen darüber aufgezeichnet, wie Sie es aufrufen können, die Sie dann in Ihren Tests einchecken können. Sie können beispielsweise überprüfen, wie oft ein Spion aufgerufen wird, welche Parameter es verwendet, um ihn zu nennen und wie er zurückgibt.

Wie erstellt man Stubs in Sinon.js?

Um einen Stub in Sinon.js zu erstellen, müssen Sie die Funktion Sinon.Stub () aufrufen. Dies gibt eine Stubfunktion zurück, die Sie in Ihren Tests verwenden können. Der Stub verhält sich wie ein Spion und erfasst Informationen darüber, wie Sie es aufrufen können, ermöglicht es Ihnen jedoch auch, sein Verhalten zu steuern. Zum Beispiel können Sie den Stub einen Fehler werfen oder einen bestimmten Wert zurückgeben.

Wie kann man in Sinon.js ein Mock erstellen?

Einen Schein in Sinon.js beinhaltet, die Funktion Sinon.mock () zu rufen. Dadurch wird ein Scheinobjekt zurückgegeben, das Sie in Ihren Tests verwenden können. Das Scheinobjekt verhält sich wie ein Spion, protokolliert Informationen darüber, wie man es nennt, und ähnelt einem Stub, sodass Sie sein Verhalten steuern können. Aber es ermöglicht Ihnen auch, Erwartungen darüber festzulegen, wie Sie es nennen können.

Wie kann man Sinon.js mit anderen Testframeworks verwenden?

sinon.js ist so konzipiert, dass sie mit jedem JavaScript -Test -Framework verwendet werden soll. Es bietet einen eigenständigen Test -Framework, kann aber auch in andere beliebte Test -Frameworks wie Mokka, Jasmin und Qunit integriert werden. Die Dokumentation von Sinon.js enthält Beispiele für die Integration in diese und andere Testframeworks.

Wie kann man einen Stub oder Spion zu seiner ursprünglichen Funktion wiederherstellen?

Wenn Sie die Funktion durch Stub oder Spion ersetzt haben, können Sie die ursprüngliche Funktion wiederherstellen, indem Sie die Methode .restore () auf dem Stub oder Spion aufrufen. Dies ist nützlich, wenn Sie nach dem Testen aufräumen möchten, um sicherzustellen, dass der Stub oder der Spion andere Tests nicht beeinflusst.

Wie kann man überprüfen, ob Spy mit spezifischen Parametern aufgerufen wurde?

sinon.js bietet verschiedene Möglichkeiten, um zu überprüfen, wie man einen Spion nennt. Sie können beispielsweise die Methode. CalledWith () verwenden, um zu überprüfen, ob ein Spion mit einem bestimmten Parameter aufgerufen wurde. Sie können auch die Methode .CaledonceWith () verwenden, um zu überprüfen, ob der Spion nur einmal mit einem bestimmten Parameter aufgerufen wurde.

Wie kann ich einen Stub zu einem bestimmten Wert machen?

Sie können die Methode von .returns () verwenden, um den Stub zu einem bestimmten Wert zurückzuführen. Wenn Sie beispielsweise einen Stub namens Mystub haben, können Sie den Wert 'Foo' zurückgeben, indem Sie Mystub.Returns ('foo') anrufen.

Wie kann man einen Stub machen, einen Fehler zu werfen?

Sie können mit der Methode .Thows () verwenden, um den Stub zu einem Fehler zu werfen. Wenn Sie beispielsweise einen Stub namens Mystub haben, können Sie einen Fehler machen, indem Sie Mystub.Throws () aufrufen. Standardmäßig wirft dies ein Fehlerobjekt aus, aber Sie können den Fehler auch einen bestimmten Fehlertyp auswirken, indem Sie den Namen des Fehlers als Parameter übergeben.

Das obige ist der detaillierte Inhalt vonSinon Tutorial: JavaScript -Tests mit Mocks, Spione & Stubs. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!