rspec-rails 1.3.4 → 2.0.0.a2

data/lib/spec/rails/interop/testcase.rb

@@ -1,14 +0,0 @@
-module Test
-  module Unit
-    class TestCase
-      # Edge rails (r8664) introduces class-wide setup & teardown callbacks for Test::Unit::TestCase.
-      # Make sure these still get run when running TestCases under rspec:
-      prepend_before(:each) do
-        run_callbacks :setup if respond_to?(:run_callbacks)
-      end
-      append_after(:each) do
-        run_callbacks :teardown if respond_to?(:run_callbacks)
-      end
-    end
-  end
-end

data/lib/spec/rails/matchers.rb

@@ -1,32 +0,0 @@
-module Spec
-  module Rails
-    # Spec::Rails::Expectations::Matchers provides several expectation matchers
-    # intended to work with Rails components like models and responses. For example:
-    #
-    #   response.should redirect_to("some/url") #redirect_to(url) is the matcher.
-    #
-    # In addition to those you see below, the arbitrary predicate feature of RSpec
-    # makes the following available as well:
-    #
-    #   response.should be_success #passes if response.success?
-    #   response.should be_redirect #passes if response.redirect?
-    #
-    # Note that many of these matchers are part of a wrapper of <tt>assert_select</tt>, so
-    # the documentation comes straight from that with some slight modifications.
-    # <tt>assert_select</tt> is a Test::Unit extension originally contributed to the
-    # Rails community as a plugin by Assaf Arkin and eventually shipped as part of Rails.
-    #
-    # For more info on <tt>assert_select</tt>, see the relevant Rails documentation.
-    module Matchers
-    end
-  end
-end
-
-require 'spec/rails/matchers/ar_be_valid'
-require 'spec/rails/matchers/assert_select'
-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'

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

@@ -1,27 +0,0 @@
-if defined?(ActiveRecord::Base)
-  module Spec
-    module Rails
-      module Matchers
-        # :call-seq:
-        #   response.should be_valid
-        #   response.should_not be_valid
-        def be_valid
-          ::Spec::Matchers::Matcher.new :be_valid do
-            match do |actual|
-              actual.valid?
-            end
-
-            failure_message_for_should do |actual|
-              if actual.respond_to?(:errors) && ActiveRecord::Errors === actual.errors
-                "Expected #{actual.inspect} to be valid, but it was not\nErrors: " + actual.errors.full_messages.join(", ")            
-              else
-                "Expected #{actual.inspect} to be valid"
-              end
-            end
-          end
-        end
-
-      end
-    end
-  end
-end

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