rspec-rails 2.99.0.beta1 → 2.99.0.beta2

data/spec/rspec/rails/matchers/be_new_record_spec.rb

@@ -7,7 +7,7 @@ describe "be_new_record" do
     let(:record) { double('record', :persisted? => false) }
 
     it "passes" do
-      record.should be_new_record
+      expect(record).to be_new_record
     end
 
     it "fails with custom failure message" do
@@ -21,7 +21,7 @@ describe "be_new_record" do
     let(:record) { double('record', :persisted? => true) }
 
     it "fails" do
-      record.should_not be_new_record
+      expect(record).not_to be_new_record
     end
 
     it "fails with custom failure message" do

data/spec/rspec/rails/matchers/be_routable_spec.rb

@@ -8,16 +8,16 @@ describe "be_routable" do
 
   context "with should" do
     it "passes if routes recognize the path" do
-      routes.stub(:recognize_path) { {} }
+      allow(routes).to receive(:recognize_path) { {} }
       expect do
-        {:get => "/a/path"}.should be_routable
+        expect({:get => "/a/path"}).to be_routable
       end.to_not raise_error
     end
 
     it "fails if routes do not recognize the path" do
-      routes.stub(:recognize_path) { raise ActionController::RoutingError.new('ignore') }
+      allow(routes).to receive(:recognize_path) { raise ActionController::RoutingError.new('ignore') }
       expect do
-        {:get => "/a/path"}.should be_routable
+        expect({:get => "/a/path"}).to be_routable
       end.to raise_error(/expected \{:get=>"\/a\/path"\} to be routable/)
     end
   end
@@ -25,16 +25,16 @@ describe "be_routable" do
   context "with should_not" do
 
     it "passes if routes do not recognize the path" do
-      routes.stub(:recognize_path) { raise ActionController::RoutingError.new('ignore') }
+      allow(routes).to receive(:recognize_path) { raise ActionController::RoutingError.new('ignore') }
       expect do
-        {:get => "/a/path"}.should_not be_routable
+        expect({:get => "/a/path"}).not_to be_routable
       end.to_not raise_error
     end
 
     it "fails if routes recognize the path" do
-      routes.stub(:recognize_path) { {:controller => "foo"} }
+      allow(routes).to receive(:recognize_path) { {:controller => "foo"} }
       expect do
-        {:get => "/a/path"}.should_not be_routable
+        expect({:get => "/a/path"}).not_to be_routable
       end.to raise_error(/expected \{:get=>"\/a\/path"\} not to be routable, but it routes to \{:controller=>"foo"\}/)
     end
   end

data/spec/rspec/rails/matchers/be_valid_spec.rb

@@ -1,5 +1,4 @@
 require "spec_helper"
-require 'active_support/all'
 require 'rspec/rails/matchers/be_valid'
 
 describe "be_valid matcher" do
@@ -20,7 +19,7 @@ describe "be_valid matcher" do
   end
 
   it "includes a failure message for the negative case" do
-    post.stub(:valid?) { true }
+    allow(post).to receive(:valid?) { true }
     expect {
       expect(post).not_to be_valid
     }.to raise_exception(/expected .* not to be valid/)
@@ -33,12 +32,12 @@ describe "be_valid matcher" do
   end
 
   it "includes the validation context if provided" do
-    post.should_receive(:valid?).with(:create) { true }
+    expect(post).to receive(:valid?).with(:create) { true }
     expect(post).to be_valid(:create)
   end
 
   it "does not include the validation context if not provided" do
-    post.should_receive(:valid?).with(no_args) { true }
+    expect(post).to receive(:valid?).with(no_args) { true }
     expect(post).to be_valid
   end
 end

data/spec/rspec/rails/matchers/errors_on_spec.rb

@@ -2,37 +2,37 @@ require "spec_helper"
 
 describe "error_on" do
   it "provides a description including the name of what the error is on" do
-    have(1).error_on(:whatever).description.should == "have 1 error on :whatever"
+    expect(have(1).error_on(:whatever).description).to eq("have 1 error on :whatever")
   end
 
   it "provides a failure message including the number actually given" do
-    lambda {
-      [].should have(1).error_on(:whatever)
-    }.should raise_error("expected 1 error on :whatever, got 0")
+    expect {
+      expect([]).to have(1).error_on(:whatever)
+    }.to raise_error("expected 1 error on :whatever, got 0")
   end
 end
 
 describe "errors_on" do
   it "provides a description including the name of what the error is on" do
-    have(2).errors_on(:whatever).description.should == "have 2 errors on :whatever"
+    expect(have(2).errors_on(:whatever).description).to eq("have 2 errors on :whatever")
   end
 
   it "provides a failure message including the number actually given" do
-    lambda {
-      [1].should have(3).errors_on(:whatever)
-    }.should raise_error("expected 3 errors on :whatever, got 1")
+    expect {
+      expect([1]).to have(3).errors_on(:whatever)
+    }.to raise_error("expected 3 errors on :whatever, got 1")
   end
 end
 
 describe "have something other than error_on or errors_on" do
   it "has a standard rspec failure message" do
-    lambda {
-      [1,2,3].should have(2).elements
-    }.should raise_error("expected 2 elements, got 3")
+    expect {
+      expect([1,2,3]).to have(2).elements
+    }.to raise_error("expected 2 elements, got 3")
   end
 
   it "has a standard rspec description" do
-    have(2).elements.description.should == "have 2 elements"
+    expect(have(2).elements.description).to eq("have 2 elements")
   end
 end
 

data/spec/rspec/rails/matchers/has_spec.rb

@@ -24,6 +24,6 @@ end
 describe "should have_xxx" do
   it "works with ActiveRecord::Associations::CollectionProxy" do
     owner = CollectionOwner.new
-    owner.associated_items.should have_some_quality
+    expect(owner.associated_items).to have_some_quality
   end
 end

data/spec/rspec/rails/matchers/have_rendered_spec.rb

@@ -7,21 +7,21 @@ require "spec_helper"
 
     context "given a hash" do
       it "delegates to assert_template" do
-        self.should_receive(:assert_template).with({:this => "hash"}, "this message")
+        expect(self).to receive(:assert_template).with({:this => "hash"}, "this message")
         expect("response").to send(template_expectation, {:this => "hash"}, "this message")
       end
     end
 
     context "given a string" do
       it "delegates to assert_template" do
-        self.should_receive(:assert_template).with("this string", "this message")
+        expect(self).to receive(:assert_template).with("this string", "this message")
         expect("response").to send(template_expectation, "this string", "this message")
       end
     end
 
     context "given a symbol" do
       it "converts to_s and delegates to assert_template" do
-        self.should_receive(:assert_template).with("template_name", "this message")
+        expect(self).to receive(:assert_template).with("template_name", "this message")
         expect("response").to send(template_expectation, :template_name, "this message")
       end
     end

data/spec/rspec/rails/matchers/redirect_to_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+require "active_support"
 require "active_support/test_case"
 
 describe "redirect_to" do
@@ -12,7 +13,7 @@ describe "redirect_to" do
 
       it "passes" do
         expect do
-          response.should redirect_to("destination")
+          expect(response).to redirect_to("destination")
         end.to_not raise_exception
       end
     end
@@ -24,7 +25,7 @@ describe "redirect_to" do
 
       it "uses failure message from assert_redirected_to" do
         expect do
-          response.should redirect_to("destination")
+          expect(response).to redirect_to("destination")
         end.to raise_exception("this message")
       end
     end
@@ -36,7 +37,7 @@ describe "redirect_to" do
 
       it "raises that exception" do
         expect do
-          response.should redirect_to("destination")
+          expect(response).to redirect_to("destination")
         end.to raise_exception("oops")
       end
     end
@@ -50,7 +51,7 @@ describe "redirect_to" do
 
       it "passes" do
         expect do
-          response.should_not redirect_to("destination")
+          expect(response).not_to redirect_to("destination")
         end.to_not raise_exception
       end
     end
@@ -60,7 +61,7 @@ describe "redirect_to" do
 
       it "fails with custom failure message" do
         expect do
-          response.should_not redirect_to("destination")
+          expect(response).not_to redirect_to("destination")
         end.to raise_exception(/expected not to redirect to \"destination\", but did/)
       end
     end
@@ -72,7 +73,7 @@ describe "redirect_to" do
 
       it "raises that exception" do
         expect do
-          response.should_not redirect_to("destination")
+          expect(response).not_to redirect_to("destination")
         end.to raise_exception("oops")
       end
     end

data/spec/rspec/rails/matchers/relation_match_array_spec.rb

@@ -7,25 +7,25 @@ describe "ActiveSupport::Relation =~ matcher" do
 
   if ::Rails::VERSION::STRING >= '4'
     it "verifies that the scope returns the records on the right hand side, regardless of order" do
-      MockableModel.all.should =~ models.reverse
+      expect(MockableModel.all).to match_array(models.reverse)
     end
 
     it "fails if the scope encompasses more records than on the right hand side" do
       MockableModel.create
-      MockableModel.all.should_not =~ models.reverse
+      expect(MockableModel.all).not_to match_array(models.reverse)
     end
   else
     it "verifies that the scope returns the records on the right hand side, regardless of order" do
-      MockableModel.scoped.should =~ models.reverse
+      expect(MockableModel.scoped).to match_array(models.reverse)
     end
 
     it "fails if the scope encompasses more records than on the right hand side" do
       MockableModel.create
-      MockableModel.scoped.should_not =~ models.reverse
+      expect(MockableModel.scoped).not_to match_array(models.reverse)
     end
   end
 
   it "fails if the scope encompasses fewer records than on the right hand side" do
-    MockableModel.limit(models.length - 1).should_not =~ models.reverse
+    expect(MockableModel.limit(models.length - 1)).not_to match_array(models.reverse)
   end
 end

data/spec/rspec/rails/matchers/route_to_spec.rb

@@ -11,45 +11,45 @@ describe "route_to" do
   it "provides a description" do
     matcher = route_to("these" => "options")
     matcher.matches?(:get => "path")
-    matcher.description.should == "route {:get=>\"path\"} to {\"these\"=>\"options\"}"
+    expect(matcher.description).to eq("route {:get=>\"path\"} to {\"these\"=>\"options\"}")
   end
 
   it "delegates to assert_recognizes" do
-    self.should_receive(:assert_recognizes).with({ "these" => "options" }, { :method=> :get, :path=>"path" }, {})
-    {:get => "path"}.should route_to("these" => "options")
+    expect(self).to receive(:assert_recognizes).with({ "these" => "options" }, { :method=> :get, :path=>"path" }, {})
+    expect({:get => "path"}).to route_to("these" => "options")
   end
 
   context "with shortcut syntax" do
     it "routes with extra options" do
-      self.should_receive(:assert_recognizes).with({ :controller => "controller", :action => "action", :extra => "options"}, { :method=> :get, :path=>"path" }, {})
-      get("path").should route_to("controller#action", :extra => "options")
+      expect(self).to receive(:assert_recognizes).with({ :controller => "controller", :action => "action", :extra => "options"}, { :method=> :get, :path=>"path" }, {})
+      expect(get("path")).to route_to("controller#action", :extra => "options")
     end
 
     it "routes without extra options" do
-      self.should_receive(:assert_recognizes).with(
+      expect(self).to receive(:assert_recognizes).with(
         {:controller => "controller", :action => "action"}, 
         {:method=> :get, :path=>"path" },
         {}
       )
-      get("path").should route_to("controller#action")
+      expect(get("path")).to route_to("controller#action")
     end
 
     it "routes with one query parameter" do
-      self.should_receive(:assert_recognizes).with(
+      expect(self).to receive(:assert_recognizes).with(
         {:controller => "controller", :action => "action", :queryitem => "queryvalue"},
         {:method=> :get, :path=>"path" },
         {'queryitem' => 'queryvalue' }
       )
-      get("path?queryitem=queryvalue").should route_to("controller#action", :queryitem => 'queryvalue')
+      expect(get("path?queryitem=queryvalue")).to route_to("controller#action", :queryitem => 'queryvalue')
     end
 
     it "routes with multiple query parameters" do
-      self.should_receive(:assert_recognizes).with(
+      expect(self).to receive(:assert_recognizes).with(
         {:controller => "controller", :action => "action", :queryitem => "queryvalue", :qi2 => 'qv2'},
         {:method=> :get, :path=>"path"},
         {'queryitem' => 'queryvalue', 'qi2' => 'qv2'}
       )
-      get("path?queryitem=queryvalue&qi2=qv2").should route_to("controller#action", :queryitem => 'queryvalue', :qi2 => 'qv2')
+      expect(get("path?queryitem=queryvalue&qi2=qv2")).to route_to("controller#action", :queryitem => 'queryvalue', :qi2 => 'qv2')
     end
 
   end
@@ -58,7 +58,7 @@ describe "route_to" do
     context "when assert_recognizes passes" do
       it "passes" do
         expect do
-          {:get => "path"}.should route_to("these" => "options")
+          expect({:get => "path"}).to route_to("these" => "options")
         end.to_not raise_exception
       end
     end
@@ -69,7 +69,7 @@ describe "route_to" do
           raise ActiveSupport::TestCase::Assertion.new("this message")
         end
         expect do
-          {:get => "path"}.should route_to("these" => "options")
+          expect({:get => "path"}).to route_to("these" => "options")
         end.to raise_error(RSpec::Expectations::ExpectationNotMetError, "this message")
       end
     end
@@ -80,7 +80,7 @@ describe "route_to" do
           raise ActionController::RoutingError.new("this message")
         end
         expect do
-          {:get => "path"}.should route_to("these" => "options")
+          expect({:get => "path"}).to route_to("these" => "options")
         end.to raise_error(RSpec::Expectations::ExpectationNotMetError, "this message")
       end
     end
@@ -91,7 +91,7 @@ describe "route_to" do
           raise "oops"
         end
         expect do
-          {:get => "path"}.should route_to("these" => "options")
+          expect({:get => "path"}).to route_to("these" => "options")
         end.to raise_exception("oops")
       end
     end
@@ -101,8 +101,8 @@ describe "route_to" do
     context "when assert_recognizes passes" do
       it "fails with custom message" do
         expect do
-          {:get => "path"}.should_not route_to("these" => "options")
-        end.to raise_error(/expected .* not to route to .*/)
+          expect({:get => "path"}).not_to route_to("these" => "options")
+        end.to raise_error(/expected {:get=>"path"} not to route to {"these"=>"options"}/)
       end
     end
 
@@ -112,7 +112,7 @@ describe "route_to" do
           raise ActiveSupport::TestCase::Assertion.new("this message")
         end
         expect do
-          {:get => "path"}.should_not route_to("these" => "options")
+          expect({:get => "path"}).not_to route_to("these" => "options")
         end.to_not raise_error
       end
     end
@@ -123,7 +123,7 @@ describe "route_to" do
           raise ActionController::RoutingError.new("this message")
         end
         expect do
-          {:get => "path"}.should_not route_to("these" => "options")
+          expect({:get => "path"}).not_to route_to("these" => "options")
         end.to_not raise_error
       end
     end
@@ -134,7 +134,7 @@ describe "route_to" do
           raise "oops"
         end
         expect do
-          {:get => "path"}.should_not route_to("these" => "options")
+          expect({:get => "path"}).not_to route_to("these" => "options")
         end.to raise_exception("oops")
       end
     end
@@ -145,7 +145,7 @@ describe "route_to" do
       raise ActiveSupport::TestCase::Assertion, "this message"
     end
     expect do
-      {"this" => "path"}.should route_to("these" => "options")
+      expect({"this" => "path"}).to route_to("these" => "options")
     end.to raise_error("this message")
   end
 end

data/spec/rspec/rails/minitest_lifecycle_adapter_spec.rb

@@ -19,4 +19,13 @@ describe RSpec::Rails::MinitestLifecycleAdapter do
       :before_setup, :after_setup, :example, :before_teardown, :after_teardown
     ])
   end
+
+  it "allows let variables named 'send'" do
+    run_result = ::RSpec::Core::ExampleGroup.describe do
+      let(:send) { "WHAT" }
+      specify { expect(send).to eq "WHAT" }
+    end.run NullObject.new
+
+    expect(run_result).to be true
+  end
 end

data/spec/rspec/rails/mocks/mock_model_spec.rb

@@ -6,7 +6,7 @@ describe "mock_model(RealModel)" do
     context "that does not represent an existing constant" do
       it "class says it's name" do
         model = mock_model("Foo")
-        model.class.name.should eq("Foo")
+        expect(model.class.name).to eq("Foo")
       end
     end
 
@@ -14,7 +14,7 @@ describe "mock_model(RealModel)" do
       context "that extends ActiveModel::Naming" do
         it "treats the constant as the class" do
           model = mock_model("MockableModel")
-          model.class.name.should eq("MockableModel")
+          expect(model.class.name).to eq("MockableModel")
         end
       end
 
@@ -42,7 +42,7 @@ describe "mock_model(RealModel)" do
     end
 
     it "is named using the stubbed id value" do
-      @model.instance_variable_get(:@name).should == "MockableModel_1"
+      expect(@model.instance_variable_get(:@name)).to eq("MockableModel_1")
     end
   end
 
@@ -50,7 +50,30 @@ describe "mock_model(RealModel)" do
     it "sets persisted to false" do
       model = mock_model(MockableModel)
       model.destroy
-      model.should_not be_persisted
+      expect(model).not_to be_persisted
+    end
+  end
+
+  describe "association" do
+    it "constructs a mock association object" do
+      model = mock_model(MockableModel)
+      expect(model.association(:association_name)).to be
+    end
+
+    it "returns a different association object for each association name" do
+      model = mock_model(MockableModel)
+      posts = model.association(:posts)
+      authors = model.association(:authors)
+
+      expect(posts).not_to equal(authors)
+    end
+
+    it "returns the same association model each time for the same association name" do
+      model = mock_model(MockableModel)
+      posts1 = model.association(:posts)
+      posts2 = model.association(:posts)
+
+      expect(posts1).to equal(posts2)
     end
   end
 
@@ -58,21 +81,21 @@ describe "mock_model(RealModel)" do
     context "default" do
       it "is empty" do
         model = mock_model(MockableModel)
-        model.errors.should be_empty
+        expect(model.errors).to be_empty
       end
     end
 
     context "with :save => false" do
       it "is not empty" do
         model = mock_model(MockableModel, :save => false)
-        model.errors.should_not be_empty
+        expect(model.errors).not_to be_empty
       end
     end
 
     context "with :update_attributes => false" do
       it "is not empty" do
         model = mock_model(MockableModel, :save => false)
-        model.errors.should_not be_empty
+        expect(model.errors).not_to be_empty
       end
     end
   end
@@ -81,7 +104,7 @@ describe "mock_model(RealModel)" do
     it "does not mutate its parameters" do
       params = {:a => 'b'}
       mock_model(MockableModel, params)
-      params.should == {:a => 'b'}
+      expect(params).to eq({:a => 'b'})
     end
   end
 
@@ -93,11 +116,11 @@ describe "mock_model(RealModel)" do
     end
 
     it "passes: associated_model == mock" do
-      @mock_model.should == @real.mockable_model
+      expect(@mock_model).to eq(@real.mockable_model)
     end
 
     it "passes: mock == associated_model" do
-      @real.mockable_model.should == @mock_model
+      expect(@real.mockable_model).to eq(@mock_model)
     end
   end
 
@@ -109,11 +132,11 @@ describe "mock_model(RealModel)" do
     end
 
     it "passes: associated_model == mock" do
-      @mock_model.should == @real.nonexistent_model
+      expect(@mock_model).to eq(@real.nonexistent_model)
     end
 
     it "passes: mock == associated_model" do
-      @real.nonexistent_model.should == @mock_model
+      expect(@real.nonexistent_model).to eq(@mock_model)
     end
   end
 
@@ -123,15 +146,15 @@ describe "mock_model(RealModel)" do
     end
     
     it "says it is_a?(RealModel)" do
-      @model.is_a?(SubMockableModel).should be(true)
+      expect(@model.is_a?(SubMockableModel)).to be(true)
     end
     
     it "says it is_a?(OtherModel) if RealModel is an ancestors" do
-      @model.is_a?(MockableModel).should be(true)
+      expect(@model.is_a?(MockableModel)).to be(true)
     end
     
     it "can be stubbed" do
-      mock_model(MockableModel, :is_a? => true).is_a?(:Foo).should be_truthy
+      expect(mock_model(MockableModel, :is_a? => true).is_a?(:Foo)).to be_truthy
     end
   end
 
@@ -141,15 +164,15 @@ describe "mock_model(RealModel)" do
     end
     
     it "says it is kind_of? if RealModel is" do
-      @model.kind_of?(SubMockableModel).should be(true)
+      expect(@model.kind_of?(SubMockableModel)).to be(true)
     end
     
     it "says it is kind_of? if RealModel's ancestor is" do
-      @model.kind_of?(MockableModel).should be(true)
+      expect(@model.kind_of?(MockableModel)).to be(true)
     end
     
     it "can be stubbed" do
-      mock_model(MockableModel, :kind_of? => true).kind_of?(:Foo).should be_truthy
+      expect(mock_model(MockableModel, :kind_of? => true).kind_of?(:Foo)).to be_truthy
     end
   end
 
@@ -159,22 +182,22 @@ describe "mock_model(RealModel)" do
     end
     
     it "says it is instance_of? if RealModel is" do
-      @model.instance_of?(SubMockableModel).should be(true)
+      expect(@model.instance_of?(SubMockableModel)).to be(true)
     end
     
     it "does not say it instance_of? if RealModel isn't, even if it's ancestor is" do
-      @model.instance_of?(MockableModel).should be(false)
+      expect(@model.instance_of?(MockableModel)).to be(false)
     end
     
     it "can be stubbed" do
-      mock_model(MockableModel, :instance_of? => true).instance_of?(:Foo).should be_truthy
+      expect(mock_model(MockableModel, :instance_of? => true).instance_of?(:Foo)).to be_truthy
     end
   end
 
   describe "#respond_to?" do
     context "with an ActiveRecord model" do
       before(:each) do
-        MockableModel.stub(:column_names).and_return(["column_a", "column_b"])
+        allow(MockableModel).to receive(:column_names).and_return(["column_a", "column_b"])
         @model = mock_model(MockableModel)
       end
 
@@ -186,57 +209,57 @@ describe "mock_model(RealModel)" do
 
       context "without as_null_object" do
         it "says it will respond_to?(key) if RealModel has the attribute 'key'" do
-          @model.respond_to?("column_a").should be(true)
+          expect(@model.respond_to?("column_a")).to be(true)
         end
         it "stubs column accessor (with string)" do
           @model.respond_to?("column_a")
-          @model.column_a.should be_nil
+          expect(@model.column_a).to be_nil
         end
         it "stubs column accessor (with symbol)" do
           @model.respond_to?(:column_a)
-          @model.column_a.should be_nil
+          expect(@model.column_a).to be_nil
         end
         it "does not stub column accessor if already stubbed in declaration (with string)" do
           model = mock_model(MockableModel, "column_a" => "a")
           model.respond_to?("column_a")
-          model.column_a.should eq("a")
+          expect(model.column_a).to eq("a")
         end
         it "does not stub column accessor if already stubbed in declaration (with symbol)" do
           model = mock_model(MockableModel, :column_a => "a")
           model.respond_to?("column_a")
-          model.column_a.should eq("a")
+          expect(model.column_a).to eq("a")
         end
         it "does not stub column accessor if already stubbed after declaration (with string)" do
-          @model.stub("column_a" => "a")
+          allow(@model).to receive(:column_a).and_return("a")
           @model.respond_to?("column_a")
-          @model.column_a.should eq("a")
+          expect(@model.column_a).to eq("a")
         end
         it "does not stub column accessor if already stubbed after declaration (with symbol)" do
-          @model.stub(:column_a => "a")
+          allow(@model).to receive(:column_a).and_return("a")
           @model.respond_to?("column_a")
-          @model.column_a.should eq("a")
+          expect(@model.column_a).to eq("a")
         end
         it "says it will not respond_to?(key) if RealModel does not have the attribute 'key'" do
-          @model.respond_to?("column_c").should be(false)
+          expect(@model.respond_to?("column_c")).to be(false)
         end
         it "says it will not respond_to?(xxx_before_type_cast)" do
-          @model.respond_to?("title_before_type_cast").should be(false)
+          expect(@model.respond_to?("title_before_type_cast")).to be(false)
         end
       end
-      
+
       context "with as_null_object" do
         it "says it will respond_to?(key) if RealModel has the attribute 'key'" do
-          @model.as_null_object.respond_to?("column_a").should be(true)
+          expect(@model.as_null_object.respond_to?("column_a")).to be(true)
         end
         it "says it will respond_to?(key) even if RealModel does not have the attribute 'key'" do
-          @model.as_null_object.respond_to?("column_c").should be(true)
+          expect(@model.as_null_object.respond_to?("column_c")).to be(true)
         end
         it "says it will not respond_to?(xxx_before_type_cast)" do
-          @model.as_null_object.respond_to?("title_before_type_cast").should be(false)
+          expect(@model.as_null_object.respond_to?("title_before_type_cast")).to be(false)
         end
         it "returns self for any unprepared message" do
           @model.as_null_object.tap do |x|
-            x.non_existant_message.should be(@model)
+            expect(x.non_existant_message).to be(@model)
           end
         end
       end
@@ -245,39 +268,39 @@ describe "mock_model(RealModel)" do
     context "with a non-ActiveRecord model" do
       it "responds as normal" do
         model = NonActiveRecordModel.new
-        model.should respond_to(:to_param)
+        expect(model).to respond_to(:to_param)
       end
       
       context "with as_null_object" do
         it "says it will not respond_to?(xxx_before_type_cast)" do
           model = NonActiveRecordModel.new.as_null_object
-          model.respond_to?("title_before_type_cast").should be(false)
+          expect(model.respond_to?("title_before_type_cast")).to be(false)
         end
       end
     end
     
     it "can be stubbed" do
-      mock_model(MockableModel, :respond_to? => true).respond_to?(:foo).should be_truthy
+      expect(mock_model(MockableModel, :respond_to? => true).respond_to?(:foo)).to be_truthy
     end
   end
   
   describe "#class" do
     it "returns the mocked model" do
-      mock_model(MockableModel).class.should eq(MockableModel)
+      expect(mock_model(MockableModel).class).to eq(MockableModel)
     end
     
     it "can be stubbed" do
-      mock_model(MockableModel, :class => String).class.should be(String)
+      expect(mock_model(MockableModel, :class => String).class).to be(String)
     end
   end
 
   describe "#to_s" do
     it "returns (model.name)_(model#to_param)" do
-      mock_model(MockableModel).to_s.should == "MockableModel_#{to_param}"
+      expect(mock_model(MockableModel).to_s).to eq("MockableModel_#{to_param}")
     end
     
     it "can be stubbed" do
-      mock_model(MockableModel, :to_s => "this string").to_s.should == "this string"
+      expect(mock_model(MockableModel, :to_s => "this string").to_s).to eq("this string")
     end
   end
 
@@ -285,7 +308,7 @@ describe "mock_model(RealModel)" do
     context "default" do
       it "returns false" do
         @model = mock_model(SubMockableModel)
-        @model.destroyed?.should be(false)
+        expect(@model.destroyed?).to be(false)
       end
     end
   end
@@ -294,7 +317,7 @@ describe "mock_model(RealModel)" do
     context "default" do
       it "returns false" do
         @model = mock_model(SubMockableModel)
-        @model.marked_for_destruction?.should be(false)
+        expect(@model.marked_for_destruction?).to be(false)
       end
     end
   end
@@ -302,19 +325,19 @@ describe "mock_model(RealModel)" do
   describe "#persisted?" do
     context "with default identifier" do
       it "returns true" do
-        mock_model(MockableModel).should be_persisted
+        expect(mock_model(MockableModel)).to be_persisted
       end
     end
 
     context "with explicit identifier via :id" do
       it "returns true" do
-        mock_model(MockableModel, :id => 37).should be_persisted
+        expect(mock_model(MockableModel, :id => 37)).to be_persisted
       end
     end
 
     context "with id => nil" do
       it "returns false" do
-        mock_model(MockableModel, :id => nil).should_not be_persisted
+        expect(mock_model(MockableModel, :id => nil)).not_to be_persisted
       end
     end
   end
@@ -322,13 +345,13 @@ describe "mock_model(RealModel)" do
   describe "#valid?" do
     context "default" do
       it "returns true" do
-        mock_model(MockableModel).should be_valid
+        expect(mock_model(MockableModel)).to be_valid
       end
     end
     
     context "stubbed with false" do
       it "returns false" do
-        mock_model(MockableModel, :valid? => false).should_not be_valid
+        expect(mock_model(MockableModel, :valid? => false)).not_to be_valid
       end
     end
   end
@@ -336,26 +359,26 @@ describe "mock_model(RealModel)" do
   describe "#as_new_record" do
     it "says it is a new record" do
       m = mock_model(MockableModel)
-      m.as_new_record.should be_new_record
+      expect(m.as_new_record).to be_new_record
     end
 
     it "says it is not persisted" do
       m = mock_model(MockableModel)
-      m.as_new_record.should_not be_persisted
+      expect(m.as_new_record).not_to be_persisted
     end
 
     it "has a nil id" do
-      mock_model(MockableModel).as_new_record.id.should be(nil)
+      expect(mock_model(MockableModel).as_new_record.id).to be(nil)
     end
 
     it "returns nil for #to_param" do
-      mock_model(MockableModel).as_new_record.to_param.should be(nil)
+      expect(mock_model(MockableModel).as_new_record.to_param).to be(nil)
     end
   end
 
   describe "#blank?" do
     it "is false" do
-      mock_model(MockableModel).should_not be_blank
+      expect(mock_model(MockableModel)).not_to be_blank
     end
   end