rspec-rails 1.3.2 → 7.0.2

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

@@ -1,180 +0,0 @@
-# This is a wrapper of assert_select for rspec.
-
-module Spec # :nodoc:
-  module Rails
-    module Matchers
-
-      class AssertSelect #:nodoc:
-        attr_reader :options
-
-        def initialize(selector_assertion, spec_scope, *args, &block)
-          @args, @options = args_and_options(args)
-          @spec_scope = spec_scope
-          @selector_assertion = selector_assertion
-          @block = block
-        end
-        
-        def matches?(response_or_text, &block)
-          @block = block if block
-
-          if doc = doc_from(response_or_text)
-            @args.unshift(doc)
-          end
-
-          begin
-            @spec_scope.__send__(@selector_assertion, *@args, &@block)
-            true
-          rescue ::Test::Unit::AssertionFailedError => @error
-            false
-          end
-        end
-        
-        def failure_message_for_should; @error.message; end
-        def failure_message_for_should_not; "should not #{description}, but did"; end
-
-        def description
-          {
-            :assert_select => "have tag#{format_args(*@args)}",
-            :assert_select_email => "send email#{format_args(*@args)}",
-          }[@selector_assertion]
-        end
-
-      private
-
-        module TestResponseOrString
-          def test_response?
-            ActionController::TestResponse === self and
-                                               !self.headers['Content-Type'].blank? and
-                                               self.headers['Content-Type'].to_sym == :xml
-          end
-        
-          def string?
-            String === self
-          end
-        end
-
-        def doc_from(response_or_text)
-          response_or_text.extend TestResponseOrString
-          if response_or_text.test_response?
-            HTML::Document.new(response_or_text.body, @options[:strict], @options[:xml]).root
-          elsif response_or_text.string?
-            HTML::Document.new(response_or_text, @options[:strict], @options[:xml]).root
-           end
-        end
-
-        def format_args(*args)
-          args.empty? ? "" : "(#{arg_list(*args)})"
-        end
-
-        def arg_list(*args)
-          args.map do |arg|
-            arg.respond_to?(:description) ? arg.description : arg.inspect
-          end.join(", ")
-        end
-        
-        def args_and_options(args)
-          opts = {:xml => false, :strict => false}
-          if args.last.is_a?(::Hash)
-            opts[:strict] = args.last.delete(:strict) unless args.last[:strict].nil?
-            opts[:xml]    = args.last.delete(:xml)    unless args.last[:xml].nil?
-            args.pop if args.last.empty?
-          end
-          return [args, opts]
-        end
-        
-      end
-      
-      # :call-seq:
-      #   response.should have_tag(*args, &block)
-      #   string.should have_tag(*args, &block)
-      #
-      # wrapper for assert_select with additional support for using
-      # css selectors to set expectation on Strings. Use this in
-      # helper specs, for example, to set expectations on the results
-      # of helper methods. Also allow specification of how the 
-      # response is parsed using the options :xml and :strict options.
-      # By default, these options are set to false.
-      #
-      # == Examples
-      #
-      #   # in a controller spec
-      #   response.should have_tag("div", "some text")
-      #
-      #   # to force xml and/or strict parsing of the response
-      #   response.should have_tag("div", "some text", :xml => true)
-      #   response.should have_tag("div", "some text", :strict => true)
-      #   response.should have_tag("div", "some text", :xml => true, :strict => false)
-      #
-      #   # in a helper spec (person_address_tag is a method in the helper)
-      #   person_address_tag.should have_tag("input#person_address")
-      #
-      # see documentation for assert_select at http://api.rubyonrails.org/
-      def have_tag(*args, &block)
-        @__current_scope_for_assert_select = AssertSelect.new(:assert_select, self, *args, &block)
-      end
-    
-      # wrapper for a nested assert_select
-      #
-      #   response.should have_tag("div#form") do
-      #     with_tag("input#person_name[name=?]", "person[name]")
-      #   end
-      #
-      # see documentation for assert_select at http://api.rubyonrails.org/
-      def with_tag(*args, &block)
-        args = prepare_args(args, @__current_scope_for_assert_select)
-        @__current_scope_for_assert_select.should have_tag(*args, &block)
-      end
-    
-      # wrapper for a nested assert_select with false
-      #
-      #   response.should have_tag("div#1") do
-      #     without_tag("span", "some text that shouldn't be there")
-      #   end
-      #
-      # see documentation for assert_select at http://api.rubyonrails.org/
-      def without_tag(*args, &block)
-        args = prepare_args(args, @__current_scope_for_assert_select)
-        @__current_scope_for_assert_select.should_not have_tag(*args, &block)
-      end
-    
-      # :call-seq:
-      #   response.should have_rjs(*args, &block)
-      #
-      # wrapper for assert_select_rjs
-      #
-      # see documentation for assert_select_rjs at http://api.rubyonrails.org/
-      def have_rjs(*args, &block)
-        AssertSelect.new(:assert_select_rjs, self, *args, &block)
-      end
-      
-      # :call-seq:
-      #   response.should send_email(*args, &block)
-      #
-      # wrapper for assert_select_email
-      #
-      # see documentation for assert_select_email at http://api.rubyonrails.org/
-      def send_email(*args, &block)
-        AssertSelect.new(:assert_select_email, self, *args, &block)
-      end
-      
-      # wrapper for assert_select_encoded
-      #
-      # see documentation for assert_select_encoded at http://api.rubyonrails.org/
-      def with_encoded(*args, &block)
-        should AssertSelect.new(:assert_select_encoded, self, *args, &block)
-      end
-
-    private
-    
-      def prepare_args(args, current_scope = nil)
-        return args if current_scope.nil?
-        defaults = current_scope.options || {:strict => false, :xml => false}
-        args << {} unless args.last.is_a?(::Hash)
-        args.last[:strict] = defaults[:strict] if args.last[:strict].nil?
-        args.last[:xml] = defaults[:xml] if args.last[:xml].nil?
-        args
-      end
-
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-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/lib/spec/rails/matchers/have_text.rb

@@ -1,57 +0,0 @@
-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/lib/spec/rails/matchers/include_text.rb

@@ -1,54 +0,0 @@
-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/lib/spec/rails/matchers/redirect_to.rb

@@ -1,126 +0,0 @@
-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/lib/spec/rails/matchers/render_template.rb

@@ -1,129 +0,0 @@
-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