Wann RSpec let () verwenden?

Ich neige dazu, vor Blöcken zu verwenden, um Instanzvariablen zu setzen. Ich verwende diese Variablen dann in meinen Beispielen. Ich bin kürzlich darauf gestoßen let(). Laut RSpec-Dokumenten ist es gewohnt

... um eine gespeicherte Hilfsmethode zu definieren. Der Wert wird über mehrere Aufrufe im selben Beispiel zwischengespeichert, jedoch nicht über Beispiele hinweg.

Wie unterscheidet sich dies von der Verwendung von Instanzvariablen in Vorblöcken? Und wann sollten Sie let()vs verwenden before()?

Ich bevorzuge letaus mehreren Gründen immer eine Instanzvariable:

• Instanzvariablen entstehen, wenn sie referenziert werden. Dies bedeutet, dass, wenn Sie die Schreibweise der Instanzvariablen fetten, eine neue erstellt und initialisiert wird nil, was zu subtilen Fehlern und Fehlalarmen führen kann. Da leteine Methode erstellt wird, erhalten Sie eine, NameErrorwenn Sie sie falsch schreiben, was ich vorzuziehen finde. Dies erleichtert auch die Überarbeitung von Spezifikationen.
• before(:each)Vor jedem Beispiel wird ein Hook ausgeführt, auch wenn das Beispiel keine der im Hook definierten Instanzvariablen verwendet. Dies ist normalerweise keine große Sache, aber wenn das Einrichten der Instanzvariablen lange dauert, verschwenden Sie Zyklen. Für die durch definierte Methode wird letder Initialisierungscode nur ausgeführt, wenn das Beispiel ihn aufruft.
• Sie können eine lokale Variable in einem Beispiel direkt in eine let umgestalten, ohne die Referenzierungssyntax im Beispiel zu ändern. Wenn Sie eine Instanzvariable umgestalten, müssen Sie ändern, wie Sie auf das Objekt im Beispiel verweisen (z @. B. ein hinzufügen ).
• Das ist ein bisschen subjektiv, aber wie Mike Lewis betonte, macht es die Spezifikation meiner Meinung nach leichter lesbar. Ich mag die Organisation, alle meine abhängigen Objekte mit zu definieren letund meinen itBlock schön kurz zu halten.

Einen verwandten Link finden Sie hier: http://www.betterspecs.org/#let

Der Unterschied zwischen den Instanzen Variablen und let()ist , dass let()ist faul ausgewertet . Dies bedeutet, dass dies let()erst ausgewertet wird, wenn die von ihm definierte Methode zum ersten Mal ausgeführt wird.

Der Unterschied zwischen beforeund letbesteht darin, dass let()Sie eine Gruppe von Variablen in einem kaskadierenden Stil definieren können. Auf diese Weise sieht die Spezifikation durch Vereinfachung des Codes etwas besser aus.

Ich habe alle Verwendungen von Instanzvariablen in meinen rspec-Tests vollständig ersetzt, um let () zu verwenden. Ich habe ein Quickie-Beispiel für einen Freund geschrieben, der damit eine kleine Rspec-Klasse unterrichtete: http://ruby-lambda.blogspot.com/2011/02/agile-rspec-with-let.html

Wie einige der anderen Antworten hier sagen, wird let () faul ausgewertet, sodass nur diejenigen geladen werden, die geladen werden müssen. Es trocknet die Spezifikation aus und macht sie lesbarer. Tatsächlich habe ich den Rspec let () -Code für die Verwendung in meinen Controllern im Stil von inherited_resource gem portiert. http://ruby-lambda.blogspot.com/2010/06/stealing-let-from-rspec.html

Neben der verzögerten Auswertung besteht der andere Vorteil darin, dass Sie in Kombination mit ActiveSupport :: Concern und der Load-Everything-In-Spezifikation / Unterstützung / Verhalten Ihre eigene Spezifikation für Ihre Anwendung erstellen können. Ich habe solche zum Testen gegen Rack- und RESTful-Ressourcen geschrieben.

Die Strategie, die ich benutze, ist Factory-Everything (über Maschinist + Fälschung / Fälscher). Es ist jedoch möglich, es in Kombination mit vor (: jedem) Blöcken zu verwenden, um Fabriken für eine ganze Reihe von Beispielgruppen vorzuladen, sodass die Spezifikationen schneller ausgeführt werden können: http://makandra.com/notes/770-taking-advantage -of-rspec-s-eingelassen-vor-Blöcken

Es ist wichtig zu beachten, dass let faul ausgewertet wird und keine Nebenwirkungsmethoden verwendet werden, da Sie sonst nicht einfach von let zu before (: each) wechseln können. Sie können let verwenden! anstatt zu lassen, damit es vor jedem Szenario ausgewertet wird.

Im Allgemeinen let()handelt es sich um eine schönere Syntax, mit der Sie @nameüberall Symbole eingeben können . Aber Vorbehalt Emptor! Ich habe festgestellt, dass es let()auch subtile Fehler (oder zumindest Kopfkratzer) gibt, da die Variable erst dann wirklich existiert, wenn Sie versuchen, sie zu verwenden ... Tell Tale-Zeichen: Wenn Sie ein putsnach dem hinzufügen, um let()zu sehen, ob die Variable korrekt ist, wird eine Spezifikation zugelassen zu bestehen, aber ohne dass die putsSpezifikation fehlschlägt - Sie haben diese Subtilität gefunden.

Ich habe auch festgestellt, dass let()das nicht unter allen Umständen zwischenzuspeichern scheint! Ich habe es in meinem Blog geschrieben: http://technicaldebt.com/?p=1242

Vielleicht bin es nur ich?

let ist funktional, da es im Wesentlichen ein Proc ist. Auch es ist zwischengespeichert.

Ein Gotcha, das ich sofort mit let gefunden habe ... In einem Spec-Block, der eine Änderung auswertet.

let(:object) {FactoryGirl.create :object}

expect {
  post :destroy, id: review.id
}.to change(Object, :count).by(-1)

Sie müssen sicher sein, dass Sie letaußerhalb Ihres Erwartungsblocks anrufen . dh Sie rufen FactoryGirl.createin Ihrem Let-Block an. Normalerweise überprüfe ich, ob das Objekt erhalten bleibt.

object.persisted?.should eq true

Andernfalls letwird beim ersten Aufruf des Blocks aufgrund der verzögerten Instanziierung tatsächlich eine Änderung in der Datenbank vorgenommen.

Aktualisieren

Einfach eine Notiz hinzufügen. Seien Sie vorsichtig beim Spielen von Code Golf oder in diesem Fall Rspec Golf mit dieser Antwort.

In diesem Fall muss ich nur eine Methode aufrufen, auf die das Objekt reagiert. Also rufe ich die _.persisted?_-Methode für das Objekt als seine Wahrheit auf. Ich versuche nur, das Objekt zu instanziieren. Sie könnten leer anrufen? oder null? zu. Es geht nicht um den Test, sondern darum, das Objekt zum Leben zu erwecken, indem man es nennt.

Sie können also nicht umgestalten

object.persisted?.should eq true

sein

object.should be_persisted 

da das Objekt nicht instanziiert wurde ... ist es faul. :) :)

Update 2

Nutzen Sie die Vermietung! Syntax für die sofortige Objekterstellung, die dieses Problem insgesamt vermeiden sollte. Beachten Sie jedoch, dass dies einen Großteil des Zwecks der Faulheit des nicht geknallten Let zunichte macht.

In einigen Fällen möchten Sie möglicherweise auch die Betreff-Syntax nutzen, anstatt sie zuzulassen, da Sie dadurch möglicherweise zusätzliche Optionen erhalten.

subject(:object) {FactoryGirl.create :object}

Hinweis für Joseph: Wenn Sie Datenbankobjekte in einer Datenbank erstellen, werden before(:all)diese nicht in einer Transaktion erfasst, und es ist viel wahrscheinlicher, dass Sie Cruft in Ihrer Testdatenbank belassen. Verwenden Sie before(:each)stattdessen.

Der andere Grund für die Verwendung von let und seiner verzögerten Auswertung besteht darin, dass Sie ein kompliziertes Objekt nehmen und einzelne Teile testen können, indem Sie let-in-Kontexte überschreiben, wie in diesem sehr konstruierten Beispiel:

context "foo" do
  let(:params) do
     { :foo => foo,  :bar => "bar" }
  end
  let(:foo) { "foo" }
  it "is set to foo" do
    params[:foo].should eq("foo")
  end
  context "when foo is bar" do
    let(:foo) { "bar" }
    # NOTE we didn't have to redefine params entirely!
    it "is set to bar" do
      params[:foo].should eq("bar")
    end
  end
end

"vor" impliziert standardmäßig before(:each). Siehe The Rspec Book, Copyright 2010, Seite 228.

before(scope = :each, options={}, &block)

Ich verwende, before(:each)um einige Daten für jede Beispielgruppe zu setzen, ohne die letMethode aufrufen zu müssen, um die Daten im "it" -Block zu erstellen. In diesem Fall weniger Code im "it" -Block.

Ich verwende, letwenn ich einige Daten in einigen Beispielen möchte, andere jedoch nicht.

Sowohl vorher als auch lassen sind großartig, um die "es" -Blöcke aufzutrocknen.

Um Verwirrung zu vermeiden, ist "let" nicht dasselbe wie before(:all). "Let" bewertet seine Methode und seinen Wert für jedes Beispiel neu ("it"), speichert den Wert jedoch zwischen mehreren Aufrufen im selben Beispiel zwischen. Weitere Informationen finden Sie hier: https://www.relishapp.com/rspec/rspec-core/v/2-6/docs/helper-methods/let-and-let

Gegenstimme hier: Nach 5 Jahren rspec mag ich nicht letsehr.

1. Eine träge Auswertung macht den Testaufbau oft verwirrend

Es wird schwierig, über das Setup nachzudenken, wenn einige Dinge, die im Setup deklariert wurden, den Status nicht tatsächlich beeinflussen, während andere dies tun.

Irgendwann wechselt jemand aus Frustration einfach letzu let!(dasselbe ohne faule Bewertung), um seine Spezifikation zum Laufen zu bringen. Wenn dies für sich arbeitet, wird eine neue Gewohnheit geboren: wenn eine neue Spezifikation zu einer älteren Suite hinzugefügt wird und es nicht funktioniert, die erste Sache , versucht der Schriftsteller Pony zufällig hinzufügen letAnrufe.

Ziemlich bald sind alle Leistungsvorteile weg.

2. Spezielle Syntax ist für Nicht-Rspec-Benutzer ungewöhnlich

Ich würde meinem Team lieber Ruby beibringen als die Tricks von rspec. Instanzvariablen oder Methodenaufrufe sind überall in diesem und anderen Projekten letnützlich. Die Syntax ist nur in rspec nützlich.

3. Die "Vorteile" ermöglichen es uns, gute Designänderungen leicht zu ignorieren

let()ist gut für teure Abhängigkeiten, die wir nicht immer wieder erstellen möchten. Es passt auch gut zu subject, sodass Sie wiederholte Aufrufe von Methoden mit mehreren Argumenten austrocknen können

Teure Abhängigkeiten, die oft wiederholt werden, und Methoden mit großen Signaturen sind beide Punkte, an denen wir den Code verbessern könnten:

• Vielleicht kann ich eine neue Abstraktion einführen, die eine Abhängigkeit vom Rest meines Codes isoliert (was bedeuten würde, dass weniger Tests sie benötigen).
• Vielleicht macht der getestete Code zu viel
• Vielleicht muss ich intelligentere Objekte anstelle einer langen Liste von Grundelementen injizieren
• Vielleicht habe ich eine Verletzung von Tell-Don't-Ask
• Vielleicht kann der teure Code schneller gemacht werden (seltener - Vorsicht vor vorzeitiger Optimierung hier)

In all diesen Fällen kann ich das Symptom schwieriger Tests mit einem beruhigenden Balsam aus Rspec-Magie behandeln oder versuchen, die Ursache zu beheben. Ich habe das Gefühl, dass ich in den letzten Jahren viel zu viel mit dem ersteren verbracht habe und jetzt möchte ich einen besseren Code.

Um die ursprüngliche Frage zu beantworten: Ich würde es lieber nicht tun, aber ich benutze es immer noch let. Ich benutze es meistens, um mich dem Stil des restlichen Teams anzupassen (es scheint, als ob die meisten Rails-Programmierer auf der Welt jetzt tief in ihrer Rspec-Magie stecken, so dass dies sehr oft der Fall ist). Manchmal verwende ich es, wenn ich einem Code, über den ich keine Kontrolle habe, einen Test hinzufüge oder keine Zeit habe, eine bessere Abstraktion vorzunehmen: dh wenn die einzige Option das Schmerzmittel ist.

Ich letteste meine HTTP 404-Antworten in meinen API-Spezifikationen mithilfe von Kontexten.

Um die Ressource zu erstellen, verwende ich let!. Aber um die Ressourcenkennung zu speichern, verwende ich let. Schauen Sie sich an, wie es aussieht:

let!(:country)   { create(:country) }
let(:country_id) { country.id }
before           { get "api/countries/#{country_id}" }

it 'responds with HTTP 200' { should respond_with(200) }

context 'when the country does not exist' do
  let(:country_id) { -1 }
  it 'responds with HTTP 404' { should respond_with(404) }
end

Das hält die Spezifikationen sauber und lesbar.