Quand utiliser RSpec let ()?

J'ai tendance à utiliser des blocs avant pour définir des variables d'instance. J'utilise ensuite ces variables dans mes exemples. Je suis récemment tombé sur let(). Selon les documents RSpec, il est utilisé pour

... pour définir une méthode d'aide mémorisée. La valeur sera mise en cache sur plusieurs appels dans le même exemple, mais pas sur plusieurs exemples.

En quoi est-ce différent de l'utilisation de variables d'instance dans des blocs avant? Et aussi quand faut-il utiliser let()vs before()?

Je préfère toujours letune variable d'instance pour deux raisons:

• Les variables d'instance surgissent lorsqu'elles sont référencées. Cela signifie que si vous touchez l'orthographe de la variable d'instance, une nouvelle sera créée et initialisée nil, ce qui peut entraîner des bogues subtils et des faux positifs. Depuis letcrée une méthode, vous obtiendrez un NameErrorlorsque vous l'orthographiez mal, ce que je trouve préférable. Cela facilite également la refonte des spécifications.
• Un before(:each)hook sera exécuté avant chaque exemple, même si l'exemple n'utilise aucune des variables d'instance définies dans le hook. Ce n'est généralement pas un gros problème, mais si la configuration de la variable d'instance prend du temps, vous perdez des cycles. Pour la méthode définie par let, le code d'initialisation ne s'exécute que si l'exemple l'appelle.
• Vous pouvez refactoriser une variable locale dans un exemple directement dans un let sans changer la syntaxe de référencement dans l'exemple. Si vous refactorisez une variable d'instance, vous devez changer la façon dont vous référencez l'objet dans l'exemple (par exemple, ajoutez un @).
• C'est un peu subjectif, mais comme Mike Lewis l'a souligné, je pense que cela rend la spécification plus facile à lire. J'aime l'organisation de définir tous mes objets dépendants avec letet de garder mon itbloc agréable et court.

Un lien connexe peut être trouvé ici: http://www.betterspecs.org/#let

La différence entre l'utilisation de variables d'instance et let()celle qui let()est évaluée paresseusement . Cela signifie que let()n'est pas évalué tant que la méthode qu'il définit n'est pas exécutée pour la première fois.

La différence entre beforeet letest que cela let()vous donne une belle façon de définir un groupe de variables dans un style «en cascade». Ce faisant, la spécification est un peu meilleure en simplifiant le code.

J'ai complètement remplacé toutes les utilisations des variables d'instance dans mes tests rspec pour utiliser let (). J'ai écrit un exemple rapide pour un ami qui l'a utilisé pour enseigner une petite classe Rspec: http://ruby-lambda.blogspot.com/2011/02/agile-rspec-with-let.html

Comme le disent certaines des autres réponses ici, let () est évalué paresseux donc il ne chargera que celles qui nécessitent un chargement. Il sèche la spécification et la rend plus lisible. J'ai en fait porté le code Rspec let () à utiliser dans mes contrôleurs, dans le style de gem hérité_ressource. http://ruby-lambda.blogspot.com/2010/06/stealing-let-from-rspec.html

Avec l'évaluation paresseuse, l'autre avantage est que, combiné à ActiveSupport :: Concern, et à la spécification / support / comportement tout-en-un, vous pouvez créer votre propre mini-DSL de spécification spécifique à votre application. J'ai écrit des tests pour les ressources Rack et RESTful.

La stratégie que j'utilise est Factory-everything (via Machinist + Forgery / Faker). Cependant, il est possible de l'utiliser en combinaison avec des blocs avant (: chaque) pour précharger les usines pour un ensemble complet de groupes d'exemples, ce qui permet aux spécifications de s'exécuter plus rapidement: http://makandra.com/notes/770-taking-advantage -of-rspec-s-let-in-before-blocks

Il est important de garder à l'esprit que let est évalué paresseux et ne pas y mettre de méthodes d'effets secondaires sinon vous ne pourriez pas passer facilement de let à avant (: chaque) . Vous pouvez utiliser let! au lieu de laisser afin qu'il soit évalué avant chaque scénario.

En général, let()c'est une syntaxe plus agréable, et cela vous évite de taper des @namesymboles partout. Mais, caveat emptor! J'ai trouvé let()aussi introduit des bugs subtils (ou au moins gratter la tête) , car la variable n'existe pas vraiment jusqu'à ce que vous essayez de l' utiliser ... Dites signe de conte: si l' ajout d' un putsaprès let()pour voir que la variable est correcte permet une spécification pour passer, mais sans la putsspécification échoue - vous avez trouvé cette subtilité.

J'ai également constaté que let()cela ne semble pas en cache en toutes circonstances! Je l'ai écrit dans mon blog: http://technicaldebt.com/?p=1242

C'est peut-être juste moi?

Let est fonctionnel car c'est essentiellement un Proc. Aussi son caché.

Un problème que j'ai trouvé tout de suite avec let ... Dans un bloc Spec qui évalue un changement.

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

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

Vous devez être sûr d'appeler en letdehors de votre bloc d'attente. c'est-à-dire que vous appelez FactoryGirl.createdans votre bloc let. Je le fais généralement en vérifiant que l'objet est persistant.

object.persisted?.should eq true

Sinon, lorsque le letbloc est appelé la première fois, un changement dans la base de données se produit en raison de l'instanciation paresseuse.

Mise à jour

Il suffit d'ajouter une note. Soyez prudent en jouant au golf à code ou dans ce cas au golf rspec avec cette réponse.

Dans ce cas, je n'ai qu'à appeler une méthode à laquelle l'objet répond. _.persisted?J'invoque donc la méthode _ sur l'objet comme étant véridique. Tout ce que j'essaie de faire, c'est d'instancier l'objet. Vous pourriez appeler vide? ou nul? aussi. Le point n'est pas le test mais donner vie à l'objet en l'appelant.

Vous ne pouvez donc pas refactoriser

object.persisted?.should eq true

être

object.should be_persisted 

comme l'objet n'a pas été instancié ... c'est paresseux. :)

Update 2

tirer parti de la laisser! syntaxe pour la création instantanée d'objets, ce qui devrait éviter complètement ce problème. Notez bien que cela ira à l'encontre de l'objectif de la paresse du let non frappé.

De plus, dans certains cas, vous souhaiterez peut-être utiliser la syntaxe du sujet au lieu de la laisser car cela peut vous donner des options supplémentaires.

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

Remarque à Joseph - si vous créez des objets de base de données dans un, before(:all)ils ne seront pas capturés dans une transaction et vous êtes beaucoup plus susceptible de laisser des fichiers dans votre base de données de test. Utilisez before(:each)plutôt.

L'autre raison d'utiliser let et son évaluation paresseuse est que vous puissiez prendre un objet compliqué et tester des pièces individuelles en remplaçant let dans des contextes, comme dans cet exemple très artificiel:

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

"avant" par défaut implique before(:each). Réf The Rspec Book, copyright 2010, page 228.

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

J'utilise before(:each)pour amorcer des données pour chaque groupe d'exemple sans avoir à appeler la letméthode pour créer les données dans le bloc "it". Moins de code dans le bloc "it" dans ce cas.

J'utilise letsi je veux des données dans certains exemples mais pas dans d'autres.

Les deux avant et laisser sont parfaits pour sécher les blocs "it".

Pour éviter toute confusion, "laisser" n'est pas la même chose que before(:all). "Let" réévalue sa méthode et sa valeur pour chaque exemple ("it"), mais met en cache la valeur sur plusieurs appels dans le même exemple. Vous pouvez en savoir plus à ce sujet ici: https://www.relishapp.com/rspec/rspec-core/v/2-6/docs/helper-methods/let-and-let

Voix dissidente ici: après 5 ans de rspec je n'aime pas lettrop.

1. L'évaluation paresseuse rend souvent la configuration du test confuse

Il devient difficile de raisonner sur la configuration lorsque certaines choses qui ont été déclarées dans la configuration n'affectent pas réellement l'état, tandis que d'autres le sont.

Finalement, de quelqu'un de frustration change juste letà let!(même chose sans évaluation paresseuse) afin d'obtenir leur travail spec. Si cela fonctionne pour eux, une nouvelle habitude est née: lorsqu'une nouvelle spécification est ajoutée à une suite plus ancienne et que cela ne fonctionne pas, la première chose que l'écrivain essaie est d'ajouter une frange aux letappels aléatoires .

Bientôt, tous les avantages de performance ont disparu.

2. La syntaxe spéciale est inhabituelle pour les utilisateurs non-rspec

Je préfère enseigner Ruby à mon équipe que les astuces de rspec. Les variables d'instance ou les appels de méthode sont utiles partout dans ce projet et dans d'autres, la letsyntaxe ne sera utile que dans rspec.

3. Les "avantages" nous permettent d'ignorer facilement les bonnes modifications de conception

let()est bon pour les dépendances coûteuses que nous ne voulons pas créer encore et encore. Il s'associe également bien avec subject, vous permettant de sécher les appels répétés aux méthodes multi-arguments

Des dépendances coûteuses répétées plusieurs fois et des méthodes avec de grandes signatures sont deux points où nous pourrions améliorer le code:

• je peux peut-être introduire une nouvelle abstraction qui isole une dépendance du reste de mon code (ce qui signifierait que moins de tests en ont besoin)
• peut-être que le code testé en fait trop
• peut-être que je dois injecter des objets plus intelligents au lieu d'une longue liste de primitives
• peut-être que j'ai une violation de ne pas demander
• peut-être que le code coûteux peut être rendu plus rapide (plus rare - méfiez-vous d'une optimisation prématurée ici)

Dans tous ces cas, je peux traiter le symptôme de tests difficiles avec un baume apaisant de magie rspec, ou je peux essayer de traiter la cause. J'ai l'impression d'avoir passé beaucoup trop de temps ces dernières années sur le premier et maintenant je veux un meilleur code.

Pour répondre à la question d'origine: je préférerais ne pas le faire, mais j'utilise toujours let. Je l' utilise principalement pour m'adapter au style du reste de l'équipe (il semble que la plupart des programmeurs Rails dans le monde soient maintenant profondément plongés dans leur magie rspec, ce qui est très souvent). Parfois, je l'utilise lorsque j'ajoute un test à un code que je n'ai pas le contrôle ou que je n'ai pas le temps de refactoriser pour une meilleure abstraction: c'est-à-dire lorsque la seule option est l'analgésique.

j'utilise let pour tester mes réponses HTTP 404 dans mes spécifications API en utilisant des contextes.

Pour créer la ressource, j'utilise let!. Mais pour stocker l'identifiant de ressource, j'utilise let. Regardez à quoi ça ressemble:

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

Cela maintient les spécifications propres et lisibles.