rspec-rails 1.1.12 → 1.2.0

data/spec/spec/rails/example/configuration_spec.rb

@@ -9,41 +9,33 @@ module Spec
       end
 
       describe "#use_transactional_fixtures" do
-        it "should return #{Spec::Runner::Configuration::TEST_CASE}.use_transactional_fixtures" do
-          config.use_transactional_fixtures.should == Spec::Runner::Configuration::TEST_CASE.use_transactional_fixtures
+        it "should return ActiveSupport::TestCase.use_transactional_fixtures" do
+          config.use_transactional_fixtures.should == ActiveSupport::TestCase.use_transactional_fixtures
         end
 
-        it "should set #{Spec::Runner::Configuration::TEST_CASE}.use_transactional_fixtures to false" do
-          Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
-            example_group.should_receive(:use_transactional_fixtures=).with(false)
-          end
+        it "should set ActiveSupport::TestCase.use_transactional_fixtures to false" do
+          ActiveSupport::TestCase.should_receive(:use_transactional_fixtures=).with(false)
           config.use_transactional_fixtures = false
         end
 
-        it "should set #{Spec::Runner::Configuration::TEST_CASE}.use_transactional_fixtures to true" do
-          Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
-            example_group.should_receive(:use_transactional_fixtures=).with(true)
-          end
+        it "should set ActiveSupport::TestCase.use_transactional_fixtures to true" do
+          ActiveSupport::TestCase.should_receive(:use_transactional_fixtures=).with(true)
           config.use_transactional_fixtures = true
         end
       end
 
       describe "#use_instantiated_fixtures" do
-        it "should return #{Spec::Runner::Configuration::TEST_CASE}.use_transactional_fixtures" do
-          config.use_instantiated_fixtures.should == Spec::Runner::Configuration::TEST_CASE.use_instantiated_fixtures
+        it "should return ActiveSupport::TestCase.use_transactional_fixtures" do
+          config.use_instantiated_fixtures.should == ActiveSupport::TestCase.use_instantiated_fixtures
         end
 
-        it "should set #{Spec::Runner::Configuration::TEST_CASE}.use_instantiated_fixtures to false" do
-          Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
-            example_group.should_receive(:use_instantiated_fixtures=).with(false)
-          end
+        it "should set ActiveSupport::TestCase.use_instantiated_fixtures to false" do
+          ActiveSupport::TestCase.should_receive(:use_instantiated_fixtures=).with(false)
           config.use_instantiated_fixtures = false
         end
 
-        it "should set #{Spec::Runner::Configuration::TEST_CASE}.use_instantiated_fixtures to true" do
-          Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
-            example_group.should_receive(:use_instantiated_fixtures=).with(true)
-          end
+        it "should set ActiveSupport::TestCase.use_instantiated_fixtures to true" do
+          ActiveSupport::TestCase.should_receive(:use_instantiated_fixtures=).with(true)
           config.use_instantiated_fixtures = true
         end
       end
@@ -51,25 +43,19 @@ module Spec
       describe "#fixture_path" do
         it "should default to RAILS_ROOT + '/spec/fixtures'" do
           config.fixture_path.should == RAILS_ROOT + '/spec/fixtures'
-          Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
-            example_group.fixture_path.should == RAILS_ROOT + '/spec/fixtures'
-          end
+          ActiveSupport::TestCase.fixture_path.should == RAILS_ROOT + '/spec/fixtures'
         end
 
         it "should set fixture_path" do
           config.fixture_path = "/new/path"
           config.fixture_path.should == "/new/path"
-          Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
-            example_group.fixture_path.should == "/new/path"
-          end
+          ActiveSupport::TestCase.fixture_path.should == "/new/path"
         end
       end
 
       describe "#global_fixtures" do
         it "should set fixtures on TestCase" do
-          Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
-            example_group.should_receive(:fixtures).with(:blah)
-          end
+          ActiveSupport::TestCase.should_receive(:fixtures).with(:blah)
           config.global_fixtures = [:blah]
         end
       end

data/spec/spec/rails/example/{controller_spec_spec.rb → controller_example_group_spec.rb}

@@ -1,10 +1,28 @@
 require File.dirname(__FILE__) + '/../../../spec_helper'
 require 'controller_spec_controller'
+require File.join(File.dirname(__FILE__), "/shared_routing_example_group_examples.rb")
 
 ['integration', 'isolation'].each do |mode|
   describe "A controller example running in #{mode} mode", :type => :controller do
     controller_name :controller_spec
     integrate_views if mode == 'integration'
+
+    accesses_configured_helper_methods
+    include RoutingExampleGroupSpec
+
+    describe "with an implicit subject" do
+      it "uses the controller" do
+        subject.should == controller
+      end
+    end
+
+    describe "with a specified subject" do
+      subject { 'specified' }
+      
+      it "uses the specified subject" do
+        subject.should == 'specified'
+      end
+    end
     
     it "should provide controller.session as session" do
       get 'action_with_template'
@@ -86,7 +104,12 @@ require 'controller_spec_controller'
         get 'action_which_gets_session', :expected => "session value"
       end.should_not raise_error
     end
-
+    
+    it "allows inline rendering" do
+      get 'action_that_renders_inline'
+      response.body.should == "inline code"
+    end
+    
     describe "handling should_receive(:render)" do
       it "should warn" do
         controller.should_receive(:render).with(:template => "controller_spec/action_with_template")
@@ -101,22 +124,6 @@ require 'controller_spec_controller'
       end
     end
     
-    describe "handling deprecated expect_render" do
-      it "should warn" do
-        Kernel.should_receive(:warn).with(/expect_render is deprecated/)
-        controller.expect_render(:template => "controller_spec/action_with_template")
-        get :action_with_template
-      end
-    end
-    
-    describe "handling deprecated stub_render" do
-      it "should warn" do
-        Kernel.should_receive(:warn).with(/stub_render is deprecated/)
-        controller.stub_render(:template => "controller_spec/action_with_template")
-        get :action_with_template
-      end
-    end
-    
     describe "setting cookies in the request" do
     
       it "should support a String key" do
@@ -129,11 +136,9 @@ require 'controller_spec_controller'
         get 'action_which_gets_cookie', :expected => "cookie value"
       end
       
-      if Rails::VERSION::STRING >= "2.0.0"
-        it "should support a Hash value" do
-          cookies[:cookie_key] = {'value' => 'cookie value', 'path' => '/not/default'}
-          get 'action_which_gets_cookie', :expected => {'value' => 'cookie value', 'path' => '/not/default'}
-        end
+      it "should support a Hash value" do
+        cookies[:cookie_key] = {'value' => 'cookie value', 'path' => '/not/default'}
+        get 'action_which_gets_cookie', :expected => {'value' => 'cookie value', 'path' => '/not/default'}
       end
       
     end
@@ -142,7 +147,7 @@ require 'controller_spec_controller'
   
       it "should support a Symbol key" do
         get 'action_which_sets_cookie', :value => "cookie value"
-        if Rails::VERSION::STRING >= "2.3"
+        if ::Rails::VERSION::STRING >= "2.3"
           cookies[:cookie_key].should == "cookie+value"
         else
           cookies[:cookie_key].should == ["cookie value"]
@@ -151,7 +156,7 @@ require 'controller_spec_controller'
 
       it "should support a String key" do
         get 'action_which_sets_cookie', :value => "cookie value"
-        if Rails::VERSION::STRING >= "2.3"
+        if ::Rails::VERSION::STRING >= "2.3"
           cookies['cookie_key'].should == "cookie+value"
         else
           cookies['cookie_key'].should == ["cookie value"]
@@ -160,95 +165,35 @@ require 'controller_spec_controller'
     
     end
     
-    describe "with an error that is not rescued in the controller" do
-      context "without rails' error handling" do
-        it "raises the error" do
-          lambda do
-            get 'other_error_action'
-          end.should raise_error(ControllerSpecController::UnRescuedError)
-        end
-      end
-      context "with rails' error handling" do
-        it "does not raise the error" do
-          controller.use_rails_error_handling!
-          lambda do
-            get 'other_error_action'
-          end.should_not raise_error
-        end
-      end
-    end
-    
-    if Rails::VERSION::MAJOR >= 2
-      describe "with an error that is rescued in the controller" do
-        context "without rails' error handling" do
-          it "does not raise error" do
-            lambda do
-              get 'rescued_error_action'
-            end.should_not raise_error
-          end
-
-          it "executes rescue_from" do
-            get 'rescued_error_action'
-            response.body.should == 'Rescued!'
-          end
-        end
-
-        context "with rails' error handling" do
-          before(:each) do
-            controller.use_rails_error_handling!
-          end
-          it "does not raise error" do
-            lambda do
-              get 'rescued_error_action'
-            end.should_not raise_error
-          end
-
-          it "executes rescue_from" do
-            get 'rescued_error_action'
-            response.body.should == 'Rescued!'
-          end
-        end
-      end
-    end
-
-    it "should support custom routes" do
-      route_for(:controller => "custom_route_spec", :action => "custom_route").should == "/custom_route"
-    end
-
-    it "should support existing routes" do
-      route_for(:controller => "controller_spec", :action => "some_action").should == "/controller_spec/some_action"
-    end
-
-    it "should generate params for custom routes" do
-      params_from(:get, '/custom_route').should == {:controller => "custom_route_spec", :action => "custom_route"}
-    end
-    
-    it "should generate params for existing routes" do
-      params_from(:get, '/controller_spec/some_action').should == {:controller => "controller_spec", :action => "some_action"}
-    end
-    
     it "should expose instance vars through the assigns hash" do
       get 'action_setting_the_assigns_hash'
       assigns[:indirect_assigns_key].should == :indirect_assigns_key_value
     end
-    
+
     it "should expose instance vars through the assigns hash that are set to false" do
       get 'action_that_assigns_false_to_a_variable'
       assigns[:a_variable].should be_false
     end
-    
+
     it "should NOT complain when calling should_receive with arguments other than :render" do
       controller.should_receive(:anything_besides_render)
       lambda {
         controller.rspec_verify
       }.should raise_error(Exception, /expected :anything_besides_render/)
     end
-    
+
     it "should not run a skipped before_filter" do
       lambda {
         get 'action_with_skipped_before_filter'
       }.should_not raise_error
     end
+    
+    describe "extending #render on a controller" do
+      it "supports two arguments (as with rails 2.2)" do
+        get 'action_with_two_arg_render'
+        response.body.should =~ /new Effect\.Highlight/
+      end
+    end
   end
 
   describe "Given a controller spec for RedirectSpecController running in #{mode} mode", :type => :controller do
@@ -301,9 +246,8 @@ end
   end
 end
 
-
 describe ControllerSpecController, :type => :controller do
-  it "should not require naming the controller if describe is passed a type" do
+  it "should use the controller passed to #describe" do
   end  
 end
 

data/spec/spec/rails/example/cookies_proxy_spec.rb

@@ -16,29 +16,27 @@ module Spec
         describe "with a String key" do
         
           it "should accept a String value" do
-            cookies = CookiesProxy.new(self)
-            cookies['key'] = 'value'
+            proxy = CookiesProxy.new(self)
+            proxy['key'] = 'value'
             get :index
             if ::Rails::VERSION::STRING >= "2.3"
-              cookies['key'].should == 'value'
+              proxy['key'].should == 'value'
             else
-              cookies['key'].should == ['value']
+              proxy['key'].should == ['value']
             end
           end
           
-          if ::Rails::VERSION::STRING >= "2.0.0"
-            it "should accept a Hash value" do
-              cookies = CookiesProxy.new(self)
-              cookies['key'] = { :value => 'value', :expires => expiration = 1.hour.from_now, :path => path = '/path' }
-              get :index
-              if ::Rails::VERSION::STRING >= "2.3"
-                cookies['key'].should == 'value'
-              else
-                cookies['key'].should == ['value']
-                cookies['key'].value.should == ['value']
-                cookies['key'].expires.should == expiration
-                cookies['key'].path.should == path
-              end
+          it "should accept a Hash value" do
+            proxy = CookiesProxy.new(self)
+            proxy['key'] = { :value => 'value', :expires => expiration = 1.hour.from_now, :path => path = '/path' }
+            get :index
+            if ::Rails::VERSION::STRING >= "2.3"
+              proxy['key'].should == 'value'
+            else
+              proxy['key'].should == ['value']
+              proxy['key'].value.should == ['value']
+              proxy['key'].expires.should == expiration
+              proxy['key'].path.should == path
             end
           end
             
@@ -47,29 +45,27 @@ module Spec
         describe "with a Symbol key" do
         
           it "should accept a String value" do
-            example_cookies = CookiesProxy.new(self)
-            example_cookies[:key] = 'value'
+            proxy = CookiesProxy.new(self)
+            proxy[:key] = 'value'
             get :index
             if ::Rails::VERSION::STRING >= "2.3"
-              example_cookies[:key].should == 'value'
+              proxy[:key].should == 'value'
             else
-              example_cookies[:key].should == ['value']
+              proxy[:key].should == ['value']
             end
           end
 
-          if ::Rails::VERSION::STRING >= "2.0.0"
-            it "should accept a Hash value" do
-              example_cookies = CookiesProxy.new(self)
-              example_cookies[:key] = { :value => 'value', :expires => expiration = 1.hour.from_now, :path => path = '/path' }
-              get :index
-              if ::Rails::VERSION::STRING >= "2.3"
-                example_cookies[:key].should == 'value'
-              else
-                example_cookies[:key].should == ['value']
-                example_cookies[:key].value.should == ['value']
-                example_cookies[:key].expires.should == expiration
-                example_cookies[:key].path.should == path
-              end
+          it "should accept a Hash value" do
+            proxy = CookiesProxy.new(self)
+            proxy[:key] = { :value => 'value', :expires => expiration = 1.hour.from_now, :path => path = '/path' }
+            get :index
+            if ::Rails::VERSION::STRING >= "2.3"
+              proxy[:key].should == 'value'
+            else
+              proxy[:key].should == ['value']
+              proxy[:key].value.should == ['value']
+              proxy[:key].expires.should == expiration
+              proxy[:key].path.should == path
             end
           end
 
@@ -77,11 +73,11 @@ module Spec
     
         describe "#delete" do
           it "should delete from the response cookies" do
-            example_cookies = CookiesProxy.new(self)
+            proxy = CookiesProxy.new(self)
             response_cookies = mock('cookies')
             response.should_receive(:cookies).and_return(response_cookies)
             response_cookies.should_receive(:delete).with('key')
-            example_cookies.delete :key
+            proxy.delete :key
           end
         end
       end

data/spec/spec/rails/example/error_handling_spec.rb

@@ -0,0 +1,90 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'controller_spec_controller'
+
+['integration', 'isolation'].each do |mode|
+  describe "A controller example running in #{mode} mode", :type => :controller do
+    controller_name :controller_spec
+    integrate_views if mode == 'integration'
+    
+    describe "without use_rails_error_handling!" do
+      describe "with an error that is *not* rescued" do
+        it "raises the error" do
+          lambda do
+            get 'un_rescued_error_action'
+          end.should raise_error(ControllerSpecController::UnRescuedError)
+        end
+      end
+      describe "with an error that *is* rescued" do
+        it "returns a 200" do
+          get 'rescued_error_action'
+          response.response_code.should == 200
+        end
+      end
+    end
+
+    describe "with deprecated use_rails_error_handling!" do
+      before(:each) do
+        Kernel.stub!(:warn)
+      end
+
+      it "warns of deprecation" do
+        Kernel.should_receive(:warn).with(/DEPRECATION NOTICE/)
+        controller.use_rails_error_handling!
+      end
+
+      describe "with an error that is *not* rescued" do
+        it "returns the error code" do
+          controller.use_rails_error_handling!
+          get 'un_rescued_error_action'
+          response.response_code.should == 500
+        end
+      end
+
+      describe "with an error that *is* rescued" do
+        it "returns a 200" do
+          controller.use_rails_error_handling!
+          get 'rescued_error_action'
+          response.response_code.should == 200
+        end
+      end
+    end
+
+    describe "with rescue_action_in_public!" do
+      describe "with an error that is *not* rescued" do
+        it "returns the error code" do
+          rescue_action_in_public!
+          get 'un_rescued_error_action'
+          response.response_code.should == 500
+        end
+      end
+
+      describe "with an error that *is* rescued" do
+        it "returns a 200" do
+          rescue_action_in_public!
+          get 'rescued_error_action'
+          response.response_code.should == 200
+        end
+      end
+    end
+    
+    describe "with bypass_rescue" do
+      describe "with an error that is *not* rescued" do
+        it "raises the error" do
+          bypass_rescue
+          lambda do
+            get 'un_rescued_error_action'
+          end.should raise_error(ControllerSpecController::UnRescuedError)
+        end
+      end
+
+      describe "with an error that *is* rescued" do
+        it "raises the error" do
+          bypass_rescue
+          lambda do
+            get 'rescued_error_action'
+          end.should raise_error(ControllerSpecController::RescuedError)
+        end
+      end
+    end
+  end
+end