rspec-rails 1.2.7.1 → 1.2.9

data/lib/spec/rails/example/routing_helpers.rb

@@ -1,38 +1,34 @@
+require 'rack/utils'
+
 module Spec
   module Rails
     module Example
       module RoutingHelpers
         
-        module ParamsFromQueryString # :nodoc:
-          def params_from_querystring(querystring) # :nodoc:
-            params = {}
-            querystring.split('&').each do |piece|
-              key, value = piece.split('=')
-              params[key.to_sym] = value
-            end
-            params
-          end
-        end
-        
         class RouteFor
-          include ::Spec::Rails::Example::RoutingHelpers::ParamsFromQueryString
           def initialize(example, options)
             @example, @options = example, options
           end
-  
+
           def ==(expected)
             if Hash === expected
               path, querystring = expected[:path].split('?')
+              path_string = path
               path = expected.merge(:path => path)
             else
               path, querystring = expected.split('?')
+              path_string = path
+              path = { :path => path, :method => :get }
+            end
+            params = querystring.blank? ? {} : Rack::Utils.parse_query(querystring).symbolize_keys!
+            begin
+              @example.assert_routing(path, @options, {}, params)
+              true
+            rescue ActionController::RoutingError, ::Test::Unit::AssertionFailedError => e
+              raise e.class, "#{e}\nIf you're expecting this failure, we suggest {:#{path[:method]}=>\"#{path[:path]}\"}.should_not be_routable"
             end
-            params = querystring.blank? ? {} : @example.params_from_querystring(querystring)
-            @example.assert_recognizes(@options, path, params)
-            true
           end
         end
-
         # Uses ActionController::Routing::Routes to generate
         # the correct route for a given set of options.
         # == Examples
@@ -46,6 +42,8 @@ module Spec
 
         # Uses ActionController::Routing::Routes to parse
         # an incoming path so the parameters it generates can be checked
+        #
+        # Note that this method is obsoleted by the route_to matcher.
         # == Example
         #   params_from(:get, '/registrations/1/edit')
         #     => :controller => 'registrations', :action => 'edit', :id => '1'
@@ -53,13 +51,11 @@ module Spec
           ensure_that_routes_are_loaded
           path, querystring = path.split('?')
           params = ActionController::Routing::Routes.recognize_path(path, :method => method)
-          querystring.blank? ? params : params.merge(params_from_querystring(querystring))
+          querystring.blank? ? params : params.merge(Rack::Utils.parse_query(querystring).symbolize_keys!)
         end
 
       private
 
-        include ParamsFromQueryString
-
         def ensure_that_routes_are_loaded
           ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
         end

data/lib/spec/rails/extensions/action_controller/rescue.rb

@@ -9,7 +9,7 @@ rspec-rails.
 Use rescue_action_in_public!, which is defined directly in
 rails' testing framework, instead.
 WARNING
-      if Rails::VERSION::STRING =~ /^2\.0/
+      if ::Rails::VERSION::STRING =~ /^2\.0/
         @use_rails_error_handling = true
       else
         # anything but 0.0.0.0 - borrowed from rails own rescue_action_in_public!
@@ -23,7 +23,7 @@ WARNING
 
   protected
   
-    if Rails::VERSION::STRING =~ /^2\.0/
+    if ::Rails::VERSION::STRING =~ /^2\.0/
       def rescue_action_in_public?
         request.respond_to?(:rescue_action_in_public?) and request.rescue_action_in_public?
       end

data/lib/spec/rails/extensions/action_controller/test_case.rb

@@ -2,7 +2,7 @@ module ActionController
   class TestCase
     include ::Spec::Rails::Example::RoutingHelpers
 
-    if Rails::VERSION::STRING =~ /2\.0/
+    if ::Rails::VERSION::STRING =~ /2\.0/
       # Introduced in Rails 2.1, but we need it for 2.0
       def rescue_action_in_public!
         # See rescue.rb in this same directory

data/lib/spec/rails/matchers.rb

@@ -5,6 +5,7 @@ require 'spec/rails/matchers/change'
 require 'spec/rails/matchers/have_text'
 require 'spec/rails/matchers/include_text'
 require 'spec/rails/matchers/redirect_to'
+require 'spec/rails/matchers/route_to'
 require 'spec/rails/matchers/render_template'
 
 module Spec

data/lib/spec/rails/matchers/render_template.rb

@@ -14,7 +14,9 @@ module Spec
                       response_or_controller.response :
                       response_or_controller
 
-          if response.respond_to?(:rendered_file)
+          if response.respond_to?(:redirect?) && response.redirect?
+            @redirect_url = response.redirect_url
+          elsif response.respond_to?(:rendered_file)
             @actual = response.rendered_file
           elsif response.respond_to?(:rendered)
             case template = response.rendered[:template]
@@ -46,7 +48,11 @@ module Spec
         end
         
         def failure_message_for_should
-          "expected #{@expected.inspect}, got #{@actual.inspect}"
+          if @redirect_url
+            "expected #{@expected.inspect}, got redirected to #{@redirect_url.inspect}"
+          else
+            "expected #{@expected.inspect}, got #{@actual.inspect}"
+          end
         end
         
         def failure_message_for_should_not

data/lib/spec/rails/matchers/route_to.rb

@@ -0,0 +1,149 @@
+require 'rack/utils'
+
+module Spec
+  module Rails
+    module Matchers
+      USAGE = ArgumentError.new( 'usage: { :method => "path" }.should route_to( :controller => "controller", :action => "action", [ args ] )' )
+
+      class PathDecomposer
+        def self.decompose_path(path)
+          method, path = if Hash === path
+                           raise USAGE if path.keys.size > 1
+                           path.entries.first
+                         else
+                           [:get, path]
+                         end
+          path, querystring = path.split('?')
+          return method, path, querystring
+        end
+      end
+
+      class RouteTo #:nodoc:
+        def initialize(expected, example)
+          @route, @example = expected,example
+        end
+
+        def matches?(path)
+          begin
+            @actual = path
+            method, path, querystring = PathDecomposer.decompose_path(path)
+            params = querystring.blank? ? {} : Rack::Utils.parse_query(querystring).symbolize_keys!
+            @example.assert_routing({ :method => method, :path => path }, @route, {}, params)
+            true
+          rescue ActionController::RoutingError, ::Test::Unit::AssertionFailedError, ActionController::MethodNotAllowed => e
+            raise e.class, "#{e}\nIf you're expecting this failure, we suggest { :#{method} => \"#{path}\" }.should_not be_routable"
+          rescue Exception => e
+            raise e.class, "#{e}\n#{e.backtrace.join( "\n" )}"
+          end
+        end
+
+        def does_not_match(path)
+          raise ArgumentError, "Don't test a negative route like this."
+        end
+
+        def failure_message_for_should
+          "Expected #{@expected.inspect} to route to #{@actual.inspect}, but it didn't.\n"+
+          "In this case, we expected you to get an exception.  So this message probably means something weird happened."
+        end
+
+        def failure_message_for_should_not
+          "Expected a routing error, but the route passed instead.  \nNote, when expecting routes to fail, you should use 'should_not be_routable' instead."
+        end
+
+        def description
+          "route to #{@expected.inspect}"
+        end
+
+        private
+          attr_reader :expected
+          attr_reader :actual
+
+      end
+
+      # :call-seq:
+      #   "path".should route_to(expected)  # assumes GET
+      #   { :get => "path" }.should route_to(expected)
+      #   { :put => "path" }.should route_to(expected)
+      #
+      # Uses ActionController::Routing::Routes to verify that
+      # the path-and-method routes to a given set of options.
+      # Also verifies route-generation, so that the expected options
+      # do generate a pathname consisten with the indicated path/method.
+      #
+      # For negative tests, only the route recognition failure can be
+      # tested; since route generation via path_to() will always generate
+      # a path as requested.  Use .should_not be_routable() in this case.
+      #
+      # == Examples
+      # { :get => '/registrations/1/edit' }.
+      #   should route_to(:controller => 'registrations', :action => 'edit', :id => '1')
+      # { :put => "/registrations/1" }.should
+      #   route_to(:controller => 'registrations', :action => 'update', :id => 1)
+      # { :post => "/registrations/" }.should
+      #   route_to(:controller => 'registrations', :action => 'create')
+
+      def route_to(expected)
+        RouteTo.new(expected, self)
+      end
+
+      class BeRoutable
+        def initialize(example)
+          @example = example
+        end
+
+        def matches?(path)
+          begin
+            @actual = path
+            method, path = PathDecomposer.decompose_path(path)
+            @example.assert_recognizes({}, { :method => method, :path => path }, {} )
+            true
+          rescue ActionController::RoutingError, ActionController::MethodNotAllowed
+            false
+          rescue ::Test::Unit::AssertionFailedError => e
+            # the second thingy will always be "<{}>" becaues of the way we called assert_recognizes({}...) above.
+            e.to_s =~ /<(.*)> did not match <\{\}>/ and @actual_place = $1 or raise
+            true
+          end
+        end
+        def failure_message_for_should
+          "Expected '#{@actual.keys.first.to_s.upcase} #{@actual.values.first}' to be routable, but it wasn't.\n"+
+          "To really test routability, we recommend #{@actual.inspect}.\n"+
+          "  should route_to( :action => 'action', :controller => 'controller' )\n\n"+
+
+          "That way, you'll verify where your route goes to.  Plus, we'll verify\n"+
+          "the generation of the expected path from the action/controller, as in\n"+
+          "the url_for() helper."
+        end
+
+        def failure_message_for_should_not
+          "Expected '#{@actual.keys.first.to_s.upcase} #{@actual.values.first}' to fail, but it routed to #{@actual_place} instead"
+        end
+
+      end
+      # :call-seq:
+      #   { "path" }.should_not be_routable # assumes GET
+      #   { :get => "path" }.should_not be_routable
+      #   { :put => "path" }.should_not be_routable
+      #
+      # Uses ActionController::Routing::Routes to verify that
+      # the path-and-method cannot be routed to a controller.
+      # Since url_for() will always generate a path, even if that
+      # path is not routable, the negative test only needs to be
+      # performed on the route recognition.
+      #
+      # Don't use this matcher for testing expected routability -
+      # use .should route_to( :controller => "controller", :action => "action" ) instead
+      #
+      # == Examples
+      # { :get => '/registrations/1/attendees/3/edit' }.should_not be_routable
+      # { :get => '/attendees/3/edit' }.should route_to( ...<controller/action>... )
+
+      def be_routable
+        BeRoutable.new(self)
+      end
+
+      alias_method :be_routeable, :be_routable
+    end
+  end
+end
+

data/lib/spec/rails/version.rb

@@ -4,10 +4,10 @@ module Spec # :nodoc:
       unless defined? MAJOR
         MAJOR  = 1
         MINOR  = 2
-        TINY   = 7
-        REALLY_TINY    = 1
+        TINY   = 9
+        PRE    = nil
       
-        STRING = [MAJOR, MINOR, TINY, REALLY_TINY].compact.join('.')
+        STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
 
         SUMMARY = "rspec-rails #{STRING}"
       end

data/spec/autotest/mappings_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 require File.dirname(__FILE__) + '/../../lib/autotest/rails_rspec'
 require File.dirname(__FILE__) + '/../../../rspec/spec/autotest/autotest_matchers'
 

data/spec/resources/controllers/controller_spec_controller.rb

@@ -114,10 +114,14 @@ class ControllerSpecController < ActionController::Base
   def un_rescued_error_action
     raise ControllerSpecController::UnRescuedError
   end
+  
+  def action_that_returns_headers
+    render :text => request.headers[params[:header]]
+  end
 end
 
 class ControllerInheritingFromApplicationControllerController < ApplicationController
   def action_with_inherited_before_filter
     render :text => ""
   end
-end
+end

data/spec/resources/controllers/render_spec_controller.rb

@@ -15,6 +15,10 @@ class RenderSpecController < ApplicationController
   def text_action
     render :text => "this is the text for this action"
   end
+
+  def action_with_redirect
+    redirect_to :action => :some_action
+  end
   
   def action_with_partial
     render :partial => "a_partial"

data/spec/spec/rails/example/assigns_hash_proxy_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'spec_helper'
 
 describe "AssignsHashProxy" do
   def orig_assigns

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

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'spec_helper'
 
 module Spec
   module Runner

data/spec/spec/rails/example/controller_example_group_spec.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'spec_helper'
 require 'controller_spec_controller'
 require File.join(File.dirname(__FILE__), "/shared_routing_example_group_examples.rb")
 
@@ -148,7 +148,7 @@ require File.join(File.dirname(__FILE__), "/shared_routing_example_group_example
       it "should support a Symbol key" do
         get 'action_which_sets_cookie', :value => "cookie value"
         if ::Rails::VERSION::STRING >= "2.3"
-          cookies[:cookie_key].should == "cookie+value"
+          cookies[:cookie_key].should match("cookie[\+ ]value")
         else
           cookies[:cookie_key].should == ["cookie value"]
         end
@@ -157,7 +157,7 @@ require File.join(File.dirname(__FILE__), "/shared_routing_example_group_example
       it "should support a String key" do
         get 'action_which_sets_cookie', :value => "cookie value"
         if ::Rails::VERSION::STRING >= "2.3"
-          cookies['cookie_key'].should == "cookie+value"
+          cookies['cookie_key'].should match("cookie[\+ ]value")
         else
           cookies['cookie_key'].should == ["cookie value"]
         end
@@ -188,12 +188,20 @@ require File.join(File.dirname(__FILE__), "/shared_routing_example_group_example
       }.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/
+    if ::Rails::VERSION::STRING > '2.1'
+      describe "extending #render on a controller" do
+        it "supports two arguments (as with rails 2.1)" do
+          get 'action_with_two_arg_render'
+          response.body.should =~ /new Effect\.Highlight/
+        end
       end
     end
+    
+    it "should access headers" do
+      request.env['ACCEPT'] = "application/json"
+      get 'action_that_returns_headers', :header => 'ACCEPT'
+      response.body.should == "application/json"
+    end
   end
 
   describe "Given a controller spec for RedirectSpecController running in #{mode} mode", :type => :controller do

data/spec/spec/rails/example/controller_isolation_spec.rb

@@ -1,47 +1,60 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'spec_helper'
 require 'controller_spec_controller'
 
 describe "a controller spec running in isolation mode", :type => :controller do
   controller_name :controller_spec
 
-  it "should not care if the specified template doesn't exist" do
+  it "does not care if the specified template doesn't exist" do
     get 'some_action'
     response.should be_success
     response.should render_template("template/that/does/not/actually/exist")
   end
-
-  it "should not care if the implied template doesn't exist" do
+  
+  it "does not care if the implied template doesn't exist" do
     get 'some_action_with_implied_template'
     response.should be_success
     response.should render_template("some_action_with_implied_template")
   end
 
-  it "should not care if the template has errors" do
+  it "does not care if the template has errors" do
     get 'action_with_errors_in_template'
     response.should be_success
     response.should render_template("action_with_errors_in_template")
   end
+  
+  it "does not care if the template exists but the action doesn't" do
+    get 'non_existent_action_with_existent_template'
+    response.should be_success
+  end
+  
+  it "fails if the neither the action nor the template exist" do
+    expect {get 'non_existent_action'}.to raise_error(ActionController::UnknownAction)
+  end
 end
 
 describe "a controller spec running in integration mode", :type => :controller do
   controller_name :controller_spec
   integrate_views
-  
-  it "should render a template" do
+
+  it "renders a template" do
     get 'action_with_template'
     response.should be_success
     response.should have_tag('div', 'This is action_with_template.rhtml')
   end
 
-  it "should choke if the template doesn't exist" do
+  it "fails if the template doesn't exist" do
     error = defined?(ActionController::MissingTemplate) ? ActionController::MissingTemplate : ActionView::MissingTemplate    
     lambda { get 'some_action' }.should raise_error(error)
   end
 
-  it "should choke if the template has errors" do
+  it "fails if the template has errors" do
     lambda { get 'action_with_errors_in_template' }.should raise_error(ActionView::TemplateError)
   end
   
+  it "fails if the action doesn't exist" do
+    expect {get 'non_existent_action'}.to raise_error(ActionController::UnknownAction)
+  end
+  
   describe "nested" do
     it "should render a template" do
       get 'action_with_template'