rspec-rails 2.0.0.beta.22 → 2.6.0

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

@@ -1,20 +1,79 @@
 require "spec_helper"
-require "action_controller/test_case"
+require "active_support/test_case"
 
 describe "redirect_to" do
   include RSpec::Rails::Matchers::RedirectTo
 
+  let(:response) { ActionController::TestResponse.new }
+
   it "delegates to assert_redirected_to" do
     self.should_receive(:assert_redirected_to).with("destination")
     "response".should redirect_to("destination")
   end
 
-  it "uses failure message from assert_redirected_to" do
-    self.stub!(:assert_redirected_to).and_raise(
-      Test::Unit::AssertionFailedError.new("this message"))
-    response = ActionController::TestResponse.new
-    expect do
-      response.should redirect_to("destination")
-    end.to raise_error("this message")
+  context "with should" do
+    context "when assert_redirected_to passes" do
+      it "passes" do
+        self.stub!(:assert_redirected_to)
+        expect do
+          response.should redirect_to("destination")
+        end.to_not raise_exception
+      end
+    end
+
+    context "when assert_redirected_to fails" do
+      it "uses failure message from assert_redirected_to" do
+        self.stub!(:assert_redirected_to) do
+          raise ActiveSupport::TestCase::Assertion.new("this message")
+        end
+        expect do
+          response.should redirect_to("destination")
+        end.to raise_error("this message")
+      end
+    end
+
+    context "when fails due to some other exception" do
+      it "raises that exception" do
+        self.stub!(:assert_redirected_to) do
+          raise "oops"
+        end
+        expect do
+          response.should redirect_to("destination")
+        end.to raise_exception("oops")
+      end
+    end
+  end
+
+  context "with should_not" do
+    context "when assert_redirected_to fails" do
+      it "passes" do
+        self.stub!(:assert_redirected_to) do
+          raise ActiveSupport::TestCase::Assertion.new("this message")
+        end
+        expect do
+          response.should_not redirect_to("destination")
+        end.to_not raise_exception
+      end
+    end
+
+    context "when assert_redirected_to passes" do
+      it "fails with custom failure message" do
+        self.stub!(:assert_redirected_to)
+        expect do
+          response.should_not redirect_to("destination")
+        end.to raise_error(/expected not to redirect to \"destination\", but did/)
+      end
+    end
+
+    context "when fails due to some other exception" do
+      it "raises that exception" do
+        self.stub!(:assert_redirected_to) do
+          raise "oops"
+        end
+        expect do
+          response.should_not redirect_to("destination")
+        end.to raise_exception("oops")
+      end
+    end
   end
 end

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

@@ -2,15 +2,7 @@ require "spec_helper"
 
 describe "render_template" do
   include RSpec::Rails::Matchers::RenderTemplate
-
-  it "uses failure message from render_template" do
-    self.stub!(:assert_template).and_raise(
-      Test::Unit::AssertionFailedError.new("this message"))
-    response = ActionController::TestResponse.new
-    expect do
-      response.should render_template("destination")
-    end.to raise_error("this message")
-  end
+  let(:response) { ActionController::TestResponse.new }
 
   context "given a hash" do
     it "delegates to assert_template" do
@@ -32,5 +24,70 @@ describe "render_template" do
       "response".should render_template(:template_name, "this message")
     end
   end
-end
 
+  context "with should" do
+    context "when assert_template passes" do
+      it "passes" do
+        self.stub!(:assert_template)
+        expect do
+          response.should render_template("template_name")
+        end.to_not raise_exception
+      end
+    end
+
+    context "when assert_template fails" do
+      it "uses failure message from assert_template" do
+        self.stub!(:assert_template) do
+          raise ActiveSupport::TestCase::Assertion.new("this message")
+        end
+        expect do
+          response.should render_template("template_name")
+        end.to raise_error("this message")
+      end
+    end
+
+    context "when fails due to some other exception" do
+      it "raises that exception" do
+        self.stub!(:assert_template) do
+          raise "oops"
+        end
+        expect do
+          response.should render_template("template_name")
+        end.to raise_exception("oops")
+      end
+    end
+  end
+
+  context "with should_not" do
+    context "when assert_template fails" do
+      it "passes" do
+        self.stub!(:assert_template) do
+          raise ActiveSupport::TestCase::Assertion.new("this message")
+        end
+        expect do
+          response.should_not render_template("template_name")
+        end.to_not raise_exception
+      end
+    end
+
+    context "when assert_template passes" do
+      it "fails with custom failure message" do
+        self.stub!(:assert_template)
+        expect do
+          response.should_not render_template("template_name")
+        end.to raise_error(/expected not to render \"template_name\", but did/)
+      end
+    end
+
+    context "when fails due to some other exception" do
+      it "raises that exception" do
+        self.stub!(:assert_template) do
+          raise "oops"
+        end
+        expect do
+          response.should_not render_template("template_name")
+        end.to raise_exception("oops")
+      end
+    end
+  end
+end

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

@@ -2,52 +2,98 @@ require "spec_helper"
 
 describe "route_to" do
   include RSpec::Rails::Matchers::RoutingMatchers
+  include RSpec::Rails::Matchers::RoutingMatchers::RouteHelpers
 
-  it "uses failure message from assert_routing" do
-    self.stub!(:assert_routing).and_raise(
-      Test::Unit::AssertionFailedError.new("this message"))
-    expect do
-      {"this" => "path"}.should route_to("these" => "options")
-    end.to raise_error("this message")
+  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")
   end
-end
 
-describe "be_routable" do
-  include RSpec::Rails::Matchers::RoutingMatchers
-  attr_reader :routes
+  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")
+    end
+
+    it "routes without extra options" do
+      self.should_receive(:assert_recognizes).with({ :controller => "controller", :action => "action"}, { :method=> :get, :path=>"path" })
+      get("path").should route_to("controller#action")
+    end
 
-  before { @routes = double("routes") }
+  end
 
   context "with should" do
-    it "passes if routes recognize the path" do
-      routes.stub(:recognize_path) { {} }
-      expect do
-        {:get => "/a/path"}.should be_routable
-      end.to_not raise_error
+    context "when assert_recognizes passes" do
+      it "passes" do
+        self.stub!(:assert_recognizes)
+        expect do
+          {:get => "path"}.should route_to("these" => "options")
+        end.to_not raise_exception
+      end
+    end
+
+    context "when assert_recognizes fails" do
+      it "fails with message from assert_recognizes" do
+        self.stub!(:assert_recognizes) do
+          raise ActiveSupport::TestCase::Assertion.new("this message")
+        end
+        expect do
+          {:get => "path"}.should route_to("these" => "options")
+        end.to raise_error("this message")
+      end
     end
 
-    it "fails if routes do not recognize the path" do
-      routes.stub(:recognize_path) { raise ActionController::RoutingError.new('ignore') }
-      expect do
-        {:get => "/a/path"}.should be_routable
-      end.to raise_error(/expected \{:get=>"\/a\/path"\} to be routable/)
+    context "when an exception is raised" do
+      it "raises that exception" do
+        self.stub!(:assert_recognizes) do
+          raise "oops"
+        end
+        expect do
+          {:get => "path"}.should route_to("these" => "options")
+        end.to raise_exception("oops")
+      end
     end
   end
 
   context "with should_not" do
+    context "when assert_recognizes passes" do
+      it "fails with custom message" do
+        self.stub!(:assert_recognizes)
+        expect do
+          {:get => "path"}.should_not route_to("these" => "options")
+        end.to raise_error(/expected .* not to route to .*/)
+      end
+    end
 
-    it "passes if routes do not recognize the path" do
-      routes.stub(:recognize_path) { raise ActionController::RoutingError.new('ignore') }
-      expect do
-        {:get => "/a/path"}.should_not be_routable
-      end.to_not raise_error
+    context "when assert_recognizes fails" do
+      it "passes" do
+        self.stub!(:assert_recognizes) do
+          raise ActiveSupport::TestCase::Assertion.new("this message")
+        end
+        expect do
+          {:get => "path"}.should_not route_to("these" => "options")
+        end.to_not raise_error
+      end
     end
 
-    it "fails if routes recognize the path" do
-      routes.stub(:recognize_path) { {:controller => "foo"} }
-      expect do
-        {:get => "/a/path"}.should_not be_routable
-      end.to raise_error(/expected \{:get=>"\/a\/path"\} not to be routable, but it routes to \{:controller=>"foo"\}/)
+    context "when an exception is raised" do
+      it "raises that exception" do
+        self.stub!(:assert_recognizes) do
+          raise "oops"
+        end
+        expect do
+          {:get => "path"}.should_not route_to("these" => "options")
+        end.to raise_exception("oops")
+      end
     end
   end
+  it "uses failure message from assert_recognizes" do
+    self.stub!(:assert_recognizes).and_raise(
+      ActiveSupport::TestCase::Assertion.new("this message"))
+    expect do
+      {"this" => "path"}.should route_to("these" => "options")
+    end.to raise_error("this message")
+  end
 end
+

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

@@ -1,23 +1,26 @@
-module NoConnections
-  def self.included(mod)
-    (class << mod; self; end).class_eval do
-      def columns
-        []
-      end
-
-      def connection
-        RSpec::Mocks::Mock.new.as_null_object
-      end
-    end
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :database => ':memory:'
+)
+
+module Connections
+  def self.extended(host)
+
+    host.connection.execute <<-eosql
+      CREATE TABLE #{host.table_name} (
+        #{host.primary_key} integer PRIMARY KEY AUTOINCREMENT
+      )
+    eosql
   end
 end
 
 class NonActiveRecordModel
   extend ActiveModel::Naming
+  include ActiveModel::Conversion
 end
 
 class MockableModel < ActiveRecord::Base
-  include NoConnections
+  extend Connections
   has_one :associated_model
 end
 
@@ -25,23 +28,12 @@ class SubMockableModel < MockableModel
 end
 
 class AssociatedModel < ActiveRecord::Base
-  include NoConnections
+  extend Connections
   belongs_to :mockable_model
 end
 
 class AlternatePrimaryKeyModel < ActiveRecord::Base
-  include NoConnections
   self.primary_key = :my_id
+  extend Connections
   attr_accessor :my_id
 end
-
-class ConnectableModel < ActiveRecord::Base
-  establish_connection :adapter => 'sqlite3',
-                       :database => ':memory:'
-
-  connection.execute <<-eosql
-    CREATE TABLE connectable_models (
-      id integer PRIMARY KEY AUTOINCREMENT
-    )
-  eosql
-end

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

@@ -41,19 +41,17 @@ describe "mock_model(RealModel)" do
     before(:each) do
       @model = mock_model(MockableModel, :id => 1)
     end
+
     it "is named using the stubbed id value" do
       @model.instance_variable_get(:@name).should == "MockableModel_1"
     end
-    it "returns string of id value for to_param" do
-      @model.to_param.should == "1"
-    end
   end
 
   describe "destroy" do
-    it "sets id to nil" do
+    it "sets persisted to false" do
       model = mock_model(MockableModel)
       model.destroy
-      model.id.should be_nil
+      model.should_not be_persisted
     end
   end
 
@@ -146,11 +144,34 @@ describe "mock_model(RealModel)" do
         MockableModel.stub(:column_names).and_return(["column_a", "column_b"])
         @model = mock_model(MockableModel)
       end
-      it "says it will respond_to?(key) if RealModel has the attribute 'key'" do
-        @model.respond_to?("column_a").should be(true)
+
+      it "accepts two arguments" do
+        expect do
+          @model.respond_to?("title_before_type_cast", false)
+        end.to_not raise_exception
+      end
+
+      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)
+        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)
+        end
+        it "says it will not respond_to?(xxx_before_type_cast)" do
+          @model.respond_to?("title_before_type_cast").should be(false)
+        end
       end
-      it "does not say it will respond_to?(key) if RealModel does not have the attribute 'key'" do
-        @model.respond_to?("column_c").should be(false)
+      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)
+        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)
+        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)
+        end
       end
     end
 
@@ -159,6 +180,12 @@ describe "mock_model(RealModel)" do
         model = NonActiveRecordModel.new
         model.should 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)
+        end
+      end
     end
   end
 
@@ -181,26 +208,25 @@ describe "mock_model(RealModel)" do
   end
 
   describe "#persisted?" do
-    context "with default id" do
+    context "with default identifier" do
       it "returns true" do
         mock_model(MockableModel).should be_persisted
       end
     end
 
-    context "with explicit id" do
+    context "with explicit identifier via :id" do
       it "returns true" do
         mock_model(MockableModel, :id => 37).should be_persisted
       end
     end
 
-    context "with id nil" do
+    context "with id => nil" do
       it "returns false" do
         mock_model(MockableModel, :id => nil).should_not be_persisted
       end
     end
   end
 
-
   describe "#valid?" do
     context "default" do
       it "returns true" do
@@ -220,6 +246,11 @@ describe "mock_model(RealModel)" do
       m.as_new_record.should be_new_record
     end
 
+    it "says it is not persisted" do
+      m = mock_model(MockableModel)
+      m.as_new_record.should_not be_persisted
+    end
+
     it "has a nil id" do
       mock_model(MockableModel).as_new_record.id.should be(nil)
     end
@@ -229,6 +260,12 @@ describe "mock_model(RealModel)" do
     end
   end
 
+  describe "#blank?" do
+    it "is false" do
+      mock_model(MockableModel).should_not be_blank
+    end
+  end
+
   describe "ActiveModel Lint tests" do
     require 'test/unit/assertions'
     require 'active_model/lint'