..even better RSpec example

# RSpec
describe User, "a new record when login is set to 'anakin'" do
  let(:login) { 'anakin' }

  subject { Factory.build(:user, :login => login) }

  it { should be_valid } # subject.valid?
  it { should_not be_persisted } # subject.persisted?
  its(:login) { should == 'anakin' }

  context "when login is set to 'vader'" do
    let(:login) { 'vader' }
    its(:login) { should == 'vader' }
  end

  # ... an so on
end

Next: tests output

Imagine how many lines of code you will have to write in bare TestUnit...

Then establish the #context...

class SessionsController < ApplicationController

  def create
    user = User.authenticate(params)

    if user.present?
      # do something
    else
      # do something different
    end
  end

end

describe SessionsController do
  describe '#create' do
    context 'on success'
    context 'on failure'
  end
end

Next: spec for model

Spec for the model, basic structure

describe User do
  subject { Factory(:user) }

  describe "database table" do
    it { should have_db_column('email') }
  end

  describe "associations" do
    it { should have_many(:posts) }
  end

  describe "validations" do
    it { should validate_presence_of(:email) }
    it { should validate_uniqueness_of(:email) }
  end

  describe "scopes" do
    describe ".bloked"
    describe ".paginated"
  end

  describe "#full_name"
end

Next: use the right matcher

Use the right matcher

In case of failure

specify { user.valid?.should == true }

# generates the following specdoc

'User should == true' FAILED
  expected: true,
  got: false (using ==)

while

subject { user }
it { should be_valid }

# generates the following specdoc

'User should be valid' FAILED
  expected valid? to return true, got false

more in RSpec documentation

Next: should matchers

Use shoulda, example

# the model
class User < ActiveRecord::Base
  belongs_to :account
  has_many :posts

  validates_presence_of :email
  allows_values_for :email, "test@example.com"
end

# ..and the corresponding spec
describe User do
  it { should belong_to(:account) }
  it { should have_many(:posts) }

  it { should validate_presence_of(:email) }
  it { should allow_value("test@example.com").for(:email) }
end

more examples

Next: it expects one thing

:it only expects one thing

describe UsersController, '#create' do
  # setup spec...
  it 'creates a new user' do
    should assign_to(:user).with(user)
    should set_the_flash
    should respond_with(:redirect)
    should redirect_to(admin_user_path(user))
  end
end

# vs.

describe UsersController, '#create' do
  # setup spec...
  it { should assign_to(:user).with(user) }
  it { should set_the_flash }
  it { should respond_with(:redirect) }
  it { should redirect_to(admin_user_path(user)) }
end

Use shortcuts specify, it and subject

it "should be valid" do
  @user.should be_valid
end

# versus

it { @user.should be_valid }

# versus

subject { @user }
it { should be_valid }

Next: use let and let!

use let and let!

# ...let there be let!

describe BlogPost do
  let(:blog_post) do
    FactoryGirl.create(:post, :title => 'Hello')
  end

  it "does something" do
    blog_post.should ...
  end

  it "does something else" do
    blog_post.should ...
  end
end

Next: tricks with let

Tricks with let

let(:product) { mock_model(Product) }

describe "on POST to :create" do
  before do
    Product.stub(:new).and_return(product)
    product.stub(:save).and_return(success)

    post :create, :product => { 'name' => 'Test' }
  end

  context "on success" do
    let(:success) { true }

    it { should set_the_flash }
    it { should respond_with(:redirect) }
    it { should redirect_to(admin_product_path(product)) }
  end

  context "on failure" do
    let(:success) { false }

    it { should_not set_the_flash }
    it { should respond_with(:success) }
    it { should render_template(:new) }
  end
end

Next: shared context

Shared context

class Subscription < ActiveRecord::Base
  STATUS_ACTIVE = 'active'
  STATUS_CANCELLED = 'cancelled'

  def self.with_status(*statuses)
    where("status IN (?)", statuses)
  end
end

Shared context, example

describe Subscription, "#with_status" do
  let!(:active) { FactoryGirl.create(:active_subscription) }
  let!(:cancelled) { FactoryGirl.create(:cancelled_subscription) }

  # define shared context
  def self.when_status(*statuses, &ctx_block)
    ctx = context "when status is #{statuses.join('or ')}" do
      let(:result) { Subscription.with_status(*statuses) }
    end
    ctx.class_eval(&ctx_block)
  end

  when_status(Subscription::STATUS_ACTIVE) do
    specify { result.should have(1).item }
    specify { result.should include(active) }
  end

  when_status(Subscription::STATUS_ACTIVE,
      Subscription::STATUS_CANCELLED) do
    specify { result.should have(2).items }
    specify { result.should include(active) }
    specify { result.should include(cancelled) }
  end
end

Next: good practices (fast specs)

Fast controller example

let(:user) { mock_model(User) }

describe "on GET to :index" do
  before do
    User.stub(:all).and_return([])
    get :index
  end

  it { should respond_with(:success) }
  it { should_not set_the_flash }
  it { should render_template(:index) }
  it { should assign_to(:users) }
end

(and more code samples)

Next: mockmodel vs. stubmodel

Stubbing pain number #1

def index
  @followers_tweets = current_user.followers_tweets.limit(20)
  @recent_tweet = current_user.tweets.first
  @following = current_user.following.limit(5)
  @followers = current_user.followers.limit(5)
  @recent_favorite = current_user.favorite_tweets.first
  @recent_listed = current_user.recently_listed.limit(5)

  if current_user.trend_option == "worldwide"
    @trends = Trend.worldwide.by_promoted.limit(10)
  else
    @trends = Trend.filter_by(current_user.trend_option).limit(10)
  end
end

Rails Best Practices

Solution

def index
  @presenter = Tweets::IndexPresenter.new(current_user)
end

describe "on GET to :index" do
  let(:presenter) { mock('IndexPresenter') }
  before { Tweets::IndexPresenter.stubs(:new => presenter) }

  # etc.
end

Stubbing pain number #2

def show
  @user = User.find(params[:id])
  @subscriptions = @user.subscriptions_paginated(params[:page])
end

describe UsersController, "show" do
  let(:user) { mock_model(User, :subscriptions_paginated => []) }

  before do
    User.stub(:find => user)
    get :index, :id => user
  end

  # etc.
end

What will happen when I refactor User#subscriptions_paginated method?

Solution

• Always write functional tests!
• Once again: always write functional tests!
  • Cumber, request specs, steak etc.
• ...or stub methods more carefully?

Stubbing pain number #3

code samples..

a lot of code