title: RSpec
----

### Invoking tests

    rake -T spec      # List spec tasks

    rake spec         # Run all

    rake spec/models/mymodel_spec.rb
    rake spec/models/mymodel_spec.rb:27

### Other spec tasks

    rake spec:controllers
    rake spec:helpers
    rake spec:lib
    rake spec:mailers
    rake spec:models
    rake spec:requests
    rake spec:routing
    rake spec:views


### Spec helpers

    module UserSpecHelper
      def valid_user_attributes
        { :email => "joe@bloggs.com",
          :username => "joebloggs",
          :password => "abcdefg"}
      end
    end

### A test

    describe "A User (in general)" do
      include UserSpecHelper

      before(:each) do
        @user = User.new
      end

      subject {
        Person.new
      }

      context "setter methods" do
        it "should do this" do
          pending "some other thing"

          subject.name = 'x'
          subject.name.should == 'x'
        end
      end
    end

### Expectations

    target.should be < 6
    target.should == 5
    target.should be_between(1, 10)
    target.should_not == 'Samantha'

    target.should be <value>
    target.should_not be <value>

    target.should satisfy {|arg| ...}
    target.should_not satisfy {|arg| ...}

    target.should equal <value>
    target.should not_equal <value>

    target.should be_close <value>, <tolerance>
    target.should_not be_close <value>, <tolerance>

    target.should predicate [optional args]
    target.should be_predicate [optional args]
    target.should_not predicate [optional args]
    target.should_not be_predicate [optional args]

    target.should match <regex>
    target.should_not match <regex>

    target.should be_an_instance_of <class>
    target.should_not be_an_instance_of <class>

    target.should be_a_kind_of <class>
    target.should_not be_a_kind_of <class>

    target.should respond_to <symbol>
    target.should_not respond_to <symbol>

    lambda {a_call}.should raise_error
    lambda {a_call}.should raise_error(<exception> [, message])
    lambda {a_call}.should_not raise_error
    lambda {a_call}.should_not raise_error(<exception> [, message])
    lambda {a_call}.should change(instance, method).from(number).to(number)

    proc.should throw <symbol>
    proc.should_not throw <symbol>

    target.should include <object>
    target.should_not include <object>

    target.should have(<number>).things
    target.should have_at_least(<number>).things
    target.should have_at_most(<number>).things

    target.should have(<number>).errors_on(:field)

    expect { thing.approve! }.to change(thing, :status).
        from(Status::AWAITING_APPROVAL).
        to(Status::APPROVED)

    expect { thing.destroy }.to change(Thing, :count).by(-1)

### Mocking a class

    user_mock = mock "User"
    user_mock.should_receive(:authenticate).with("password").and_return(true)
    user_mock.should_receive(:coffee).exactly(3).times.and_return(:americano)
    user_mock.should_receive(:coffee).exactly(5).times.and_raise(NotEnoughCoffeeExcep
    ion)

    people_stub = mock "people"
    people_stub.stub!(:each).and_yield(mock_user)
    people_stub.stub!(:bad_method).and_raise(RuntimeError)

    user_stub = mock_model("User", :id => 23, :username => "pat", :email =>
    "pat@example.com")

    my_instance.stub!(:msg).and_return(value)
    MyClass.stub!(:msg).and_return(value)