exception2db 0.0.1

data/test/rspec-rails/lib/spec/rails/matchers/change.rb

@@ -0,0 +1,13 @@
+if defined?(ActiveRecord::Base)
+  module Spec
+    module Matchers
+      class Change
+        def evaluate_value_proc_with_ensured_evaluation_of_proxy
+          value = evaluate_value_proc_without_ensured_evaluation_of_proxy
+          ActiveRecord::Associations::AssociationProxy === value ? value.dup : value
+        end
+        alias_method_chain :evaluate_value_proc, :ensured_evaluation_of_proxy
+      end
+    end
+  end
+end

data/test/rspec-rails/lib/spec/rails/matchers/have_text.rb

@@ -0,0 +1,57 @@
+module Spec
+  module Rails
+    module Matchers
+    
+      class HaveText  #:nodoc:
+
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(response_or_text)
+          @actual = response_or_text.respond_to?(:body) ? response_or_text.body : response_or_text
+          return actual =~ expected if Regexp === expected
+          return actual == expected unless Regexp === expected
+        end
+      
+        def failure_message_for_should
+          "expected #{expected.inspect}, got #{actual.inspect}"
+        end
+        
+        def failure_message_for_should_not
+          "expected not to have text #{expected.inspect}"
+        end
+        
+        def description
+          "have text #{expected.inspect}"
+        end
+      
+        private
+          attr_reader :expected
+          attr_reader :actual
+
+      end
+
+      # :call-seq:
+      #   response.should have_text(expected)
+      #   response.should_not have_text(expected)
+      #
+      # Accepts a String or a Regexp, matching a String using ==
+      # and a Regexp using =~.
+      #
+      # If response_or_text has a #body, then that is used as to match against
+      # else it uses response_or_text
+      #
+      # Use this instead of <tt>response.should have_tag()</tt>
+      # when you want to match the whole string or whole body
+      #
+      # == Examples
+      #
+      #   response.should have_text("This is the expected text")
+      def have_text(text)
+        HaveText.new(text)
+      end
+    
+    end
+  end
+end

data/test/rspec-rails/lib/spec/rails/matchers/include_text.rb

@@ -0,0 +1,54 @@
+module Spec
+  module Rails
+    module Matchers
+
+      class IncludeText  #:nodoc:
+
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(response_or_text)
+          @actual = response_or_text.respond_to?(:body) ? response_or_text.body : response_or_text
+          return actual.include?(expected)
+        end
+
+        def failure_message_for_should
+          "expected to find #{expected.inspect} in #{actual.inspect}"
+        end
+
+        def failure_message_for_should_not
+          "expected not to include text #{expected.inspect}"
+        end
+
+        def description
+          "include text #{expected.inspect}"
+        end
+
+        private
+          attr_reader :expected
+          attr_reader :actual
+
+      end
+
+
+      # :call-seq:
+      #   response.should include_text(expected)
+      #   response.should_not include_text(expected)
+      #
+      # Accepts a String, matching using include?
+      #
+      # Use this instead of <tt>response.should have_text()</tt>
+      # when you either don't know or don't care where on the page
+      # this text appears.
+      #
+      # == Examples
+      #
+      #   response.should include_text("This text will be in the actual string")
+      def include_text(text)
+        IncludeText.new(text)
+      end
+
+    end
+  end
+end

data/test/rspec-rails/lib/spec/rails/matchers/redirect_to.rb

@@ -0,0 +1,126 @@
+module Spec
+  module Rails
+    module Matchers
+
+      class RedirectTo  #:nodoc:
+
+        include ActionController::StatusCodes
+
+        def initialize(request, expected)
+          @expected = expected
+          @request = request
+        end
+
+        def matches?(response_or_controller)
+          response  = response_or_controller.respond_to?(:response) ?
+                      response_or_controller.response :
+                      response_or_controller
+
+          @redirected = response.redirect?
+          @actual = response.redirect_url
+          return false unless @redirected
+
+          if @expected_status
+            @actual_status = interpret_status(response.code.to_i)
+            @status_matched = @expected_status == @actual_status
+          else
+            @status_matched = true
+          end
+
+          if @expected.instance_of? Hash
+            return false unless @actual =~ %r{^\w+://#{@request.host}}
+            return false unless actual_redirect_to_valid_route
+            return actual_hash == expected_hash && @status_matched
+          else
+            return @actual == expected_url && @status_matched
+          end
+        end
+
+        def actual_hash
+          hash_from_url @actual
+        end
+
+        def expected_hash
+          hash_from_url expected_url
+        end
+
+        def actual_redirect_to_valid_route
+          actual_hash
+        end
+
+        def hash_from_url(url)
+          query_hash(url).merge(path_hash(url)).with_indifferent_access
+        end
+
+        def path_hash(url)
+          path = url.sub(%r{^\w+://#{@request.host}(?::\d+)?}, "").split("?", 2)[0]
+          ActionController::Routing::Routes.recognize_path path, { :method => :get }
+        end
+
+        def query_hash(url)
+          query = url.split("?", 2)[1] || ""
+          Rack::Utils.parse_query(query)
+        end
+
+        def with(options)
+          @expected_status = interpret_status(options[:status])
+          self
+        end
+        
+       def expected_url
+          case @expected
+            when Hash
+              return ActionController::UrlRewriter.new(@request, {}).rewrite(@expected)
+            when :back
+              return @request.env['HTTP_REFERER']
+            when %r{^\w+://.*}
+              return @expected
+            else
+              return "http://#{@request.host}" + (@expected.split('')[0] == '/' ? '' : '/') + @expected
+          end
+        end
+
+        def failure_message_for_should
+          if @redirected
+            if @status_matched
+              return %Q{expected redirect to #{@expected.inspect}, got redirect to #{@actual.inspect}}
+            else
+              return %Q{expected redirect to #{@expected.inspect} with status #{@expected_status}, got #{@actual_status}}
+            end
+          else
+            return %Q{expected redirect to #{@expected.inspect}, got no redirect}
+          end
+        end
+
+        def failure_message_for_should_not
+            return %Q{expected not to be redirected to #{@expected.inspect}, but was} if @redirected
+        end
+
+        def description
+          "redirect to #{@expected.inspect}"
+        end
+      end
+
+      # :call-seq:
+      #   response.should redirect_to(url)
+      #   response.should redirect_to(:action => action_name)
+      #   response.should redirect_to(:controller => controller_name, :action => action_name)
+      #   response.should_not redirect_to(url)
+      #   response.should_not redirect_to(:action => action_name)
+      #   response.should_not redirect_to(:controller => controller_name, :action => action_name)
+      #
+      # Passes if the response is a redirect to the url, action or controller/action.
+      # Useful in controller specs (integration or isolation mode).
+      #
+      # == Examples
+      #
+      #   response.should redirect_to("path/to/action")
+      #   response.should redirect_to("http://test.host/path/to/action")
+      #   response.should redirect_to(:action => 'list')
+      def redirect_to(opts)
+        RedirectTo.new(request, opts)
+      end
+    end
+
+  end
+end

data/test/rspec-rails/lib/spec/rails/matchers/render_template.rb

@@ -0,0 +1,129 @@
+module Spec
+  module Rails
+    module Matchers
+    
+      class RenderTemplate #:nodoc:
+    
+        def initialize(expected, controller)
+          @controller = controller
+          @expected = expected
+        end
+      
+        def matches?(response_or_controller)
+          response  = response_or_controller.respond_to?(:response) ?
+                      response_or_controller.response :
+                      response_or_controller
+
+          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]
+            when nil
+              unless response.rendered[:partials].empty?
+                @actual = path_and_file(response.rendered[:partials].keys.first).join("/_")
+              end
+            when ActionView::Template
+              @actual = template.path
+            when String
+              @actual = template
+            end
+          else
+            @actual = response.rendered_template.to_s
+          end
+          return false if @actual.blank?
+          given_controller_path, given_file = path_and_file(@actual)
+          expected_controller_path, expected_file = path_and_file(@expected)
+          given_controller_path == expected_controller_path && match_files(given_file, expected_file)
+        end
+        
+        def match_files(actual, expected)
+          actual_parts = actual.split('.')
+          expected_parts = expected.split('.')
+          expected_parts.each_with_index do |expected_part, index|
+            return false unless expected_part == actual_parts[index]
+          end
+          true
+        end
+        
+        def failure_message_for_should
+          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
+          "expected not to render #{@expected.inspect}, but did"
+        end
+        
+        def description
+          "render template #{@expected.inspect}"
+        end
+      
+        private
+          def path_and_file(path)
+            parts = path.split('/')
+            file = parts.pop
+            controller = parts.empty? ? current_controller_path : parts.join('/')
+            return controller, file
+          end
+        
+          def controller_path_from(path)
+            parts = path.split('/')
+            parts.pop
+            parts.join('/')
+          end
+
+          def current_controller_path
+            @controller.class.to_s.underscore.gsub(/_controller$/,'')
+          end
+        
+      end
+      
+      # :call-seq:
+      #   response.should render_template(template)
+      #   response.should_not render_template(template)
+      #
+      # For use in controller code examples (integration or isolation mode).
+      #
+      # Passes if the specified template (view file) is rendered by the
+      # response. This file can be any view file, including a partial. However
+      # if it is a partial it must be rendered directly i.e. you can't detect
+      # that a partial has been rendered as part of a view using
+      # render_template. For that you should use a message expectation
+      # (mock) instead:
+      #
+      #   controller.should_receive(:render).with(:partial => 'path/to/partial')
+      #
+      # <code>template</code> can include the controller path. It can also
+      # include an optional extension, which you only need to use when there
+      # is ambiguity.
+      #
+      # Note that partials must be spelled with the preceding underscore.
+      #
+      # == Examples
+      #
+      #   response.should render_template('list')
+      #   response.should render_template('same_controller/list')
+      #   response.should render_template('other_controller/list')
+      #
+      #   # with extensions
+      #   response.should render_template('list.rjs')
+      #   response.should render_template('list.haml')
+      #   response.should render_template('same_controller/list.rjs')
+      #   response.should render_template('other_controller/list.rjs')
+      #
+      #   # partials
+      #   response.should render_template('_a_partial')
+      #   response.should render_template('same_controller/_a_partial')
+      #   response.should render_template('other_controller/_a_partial')
+      def render_template(path)
+        RenderTemplate.new(path.to_s, @controller)
+      end
+
+    end
+  end
+end

data/test/rspec-rails/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
+