Rails - RSpec - Difference between "let" and "let!"

Question

I have read what the RSpec manual says about the difference, but some things are still confusing. Every other source, including "The RSpec Book" only explain about "let", and "The Rails 3 Way" is just as confusing as the manual.

I understand that "let" is only evaluated when invoked, and keeps the same value within a scope. So it makes sense that in the first example in the manual the first test passes as the "let" is invoked only once, and the second test passes as it adds to the value of the first test (which was evaluated once in the first test and has the value of 1).

Following that, since "let!" evaluates when defined, and again when invoked, should the test not fail as "count.should eq(1)" should have instead be "count.should eq(2)"?

Any help would be appreciated.

Answer 1

I understood the difference between let and let! with a very simple example. Let me read the doc sentence first, then show the output hands on.

About let doc says :-

... let is lazy-evaluated: it is not evaluated until the first time the method it defines is invoked.

I understood the difference with the below example :-

$count = 0 describe "let" do   let(:count) { $count += 1 }    it "returns 1" do     expect($count).to eq(1)   end end 

Lets run it now :-

arup@linux-wzza:~/Ruby> rspec spec/test_spec.rb F  Failures:    1) let is not cached across examples      Failure/Error: expect($count).to eq(1)         expected: 1             got: 0         (compared using ==)      # ./spec/test_spec.rb:8:in `block (2 levels) in <top (required)>'  Finished in 0.00138 seconds (files took 0.13618 seconds to load) 1 example, 1 failure  Failed examples:  rspec ./spec/test_spec.rb:7 # let is not cached across examples arup@linux-wzza:~/Ruby> 

Why the ERROR ? Because, as doc said, with let, it is not evaluated until the first time the method it defines is invoked. In the example, we didn't invoke the count, thus $count is still 0, not incremented by 1.

Now coming to the part let!. The doc is saying

....You can use let! to force the method's invocation before each example. It means even if you didn't invoke the helper method inside the example, still it will be invoked before your example runs.

Lets test this also :-

Here is the modified code

$count = 0 describe "let!" do   let!(:count) { $count += 1 }    it "returns 1" do     expect($count).to eq(1)   end end 

Lets run this code :-

arup@linux-wzza:~/Ruby> rspec spec/test_spec.rb .  Finished in 0.00145 seconds (files took 0.13458 seconds to load) 1 example, 0 failures 

See, now $count returns 1, thus test got passed. It happened as I used let!, which run before the example run, although we didn't invoke count inside our example.

This is how let and let! differs from each other.

Answer 2

You can read more about this here, but basically. (:let) is lazily evaluated and will never be instantiated if you don't call it, while (:let!) is forcefully evaluated before each method call.