richzhou-rspec-rails 1.3.4

data/lib/spec/rails/extensions.rb

@@ -0,0 +1,11 @@
+require 'spec'
+
+require 'spec/rails/extensions/spec/runner/configuration'
+require 'spec/rails/extensions/spec/matchers/have'
+
+require 'spec/rails/extensions/active_support/test_case'
+require 'spec/rails/extensions/active_record/base'
+require 'spec/rails/extensions/action_controller/rescue'
+require 'spec/rails/extensions/action_controller/test_case'
+require 'spec/rails/extensions/action_controller/test_response'
+require 'spec/rails/extensions/action_view/base'

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

@@ -0,0 +1,42 @@
+module ActionController
+  module Rescue
+    def use_rails_error_handling!
+      Kernel.warn <<-WARNING
+DEPRECATION NOTICE: controller.use_rails_error_handling! is
+deprecated and will be removed from a future version of
+rspec-rails.
+
+Use rescue_action_in_public!, which is defined directly in
+rails' testing framework, instead.
+WARNING
+      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!
+        request.remote_addr = '208.77.188.166'
+      end
+    end
+    
+    def use_rails_error_handling?
+      @use_rails_error_handling ||= false
+    end
+
+  protected
+  
+    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
+      
+      def rescue_action_with_handler_with_fast_errors(exception)
+        if (use_rails_error_handling? || rescue_action_in_public?) & !handler_for_rescue(exception)
+          rescue_action_in_public(exception)
+        else
+          rescue_action_with_handler_without_fast_errors(exception)
+        end
+      end
+      alias_method_chain :rescue_action_with_handler, :fast_errors
+    end
+
+  end
+end

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

@@ -0,0 +1,16 @@
+module ActionController
+  class TestCase
+    include ::Spec::Rails::Example::RoutingHelpers
+
+    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
+        def request.rescue_action_in_public?
+          true
+        end
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module ActionController #:nodoc:
+  class TestResponse #:nodoc:
+    attr_writer :controller_path
+
+    def capture(name)
+      template.instance_variable_get "@content_for_#{name.to_s}"
+    end
+    
+    if ::Rails::VERSION::STRING < "2.3"
+      def [](name)
+        Kernel.warn <<-WARNING
+DEPRECATION NOTICE: [](name) as an alias for capture(name) (TestResponse
+extension in rspec-rails) is deprecated and will not be defined by rspec-rails
+when working with rails >= 2.3.0. It will also be removed entirely from
+a future version of rspec-rails.
+WARNING
+        capture(name)
+      end
+    end
+  end
+end

data/lib/spec/rails/extensions/action_view/base.rb

@@ -0,0 +1,35 @@
+module ActionView #:nodoc:
+  class Base #:nodoc:
+    include Spec::Rails::Example::RenderObserver
+    cattr_accessor :base_view_path
+
+    def render_partial_with_base_view_path_handling(partial_path, local_assigns = nil, deprecated_local_assigns = nil) #:nodoc:
+      if partial_path.is_a?(String)
+        unless partial_path.include?("/")
+          unless self.class.base_view_path.nil?
+            partial_path = "#{self.class.base_view_path}/#{partial_path}"
+          end
+        end
+      end
+      begin
+        render_partial_without_base_view_path_handling(partial_path, local_assigns, deprecated_local_assigns)
+      rescue ArgumentError # edge rails > 2.1 changed render_partial to accept only one arg
+        render_partial_without_base_view_path_handling(partial_path)
+      end
+    end
+    alias_method_chain :render_partial, :base_view_path_handling
+
+    def render_with_mock_proxy(options = {}, old_local_assigns = {}, &block)
+      if render_proxy.__send__(:__mock_proxy).__send__(:find_matching_expectation, :render, options, old_local_assigns)
+        render_proxy.render(options, old_local_assigns)
+      elsif render_proxy.__send__(:__mock_proxy).__send__(:find_matching_expectation, :render, options)
+        render_proxy.render(options)
+      else
+        unless render_proxy.__send__(:__mock_proxy).__send__(:find_matching_method_stub, :render, options)
+          render_without_mock_proxy(options, old_local_assigns, &block)
+        end
+      end
+    end
+    alias_method_chain :render, :mock_proxy
+  end
+end

data/lib/spec/rails/extensions/active_record/base.rb

@@ -0,0 +1,45 @@
+if defined?(ActiveRecord::Base)
+  module Spec
+    module Rails
+      module Extensions
+        module ActiveRecord
+          module ClassMethods
+            # :call-seq:
+            #   ModelClass.should have(:no).records
+            #   ModelClass.should have(1).record
+            #   ModelClass.should have(n).records
+            #
+            # Extension to enhance <tt>should have</tt> on AR Model classes
+            def records
+              find(:all)
+            end
+            alias :record :records
+          end
+
+          module InstanceMethods
+            # :call-seq:
+            #   model.should have(:no).errors_on(:attribute)
+            #   model.should have(1).error_on(:attribute)
+            #   model.should have(n).errors_on(:attribute)
+            #
+            # Extension to enhance <tt>should have</tt> on AR Model instances.
+            # Calls model.valid? in order to prepare the object's errors
+            # object.
+            def errors_on(attribute)
+              self.valid?
+              [self.errors.on(attribute)].flatten.compact
+            end
+            alias :error_on :errors_on
+          end
+        end
+      end
+    end
+  end
+  
+  module ActiveRecord #:nodoc:
+    class Base
+      extend  Spec::Rails::Extensions::ActiveRecord::ClassMethods
+      include Spec::Rails::Extensions::ActiveRecord::InstanceMethods
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module ActiveSupport
+  class TestCase
+    include ::Spec::Rails::Matchers
+    include ::Spec::Rails::Mocks
+  end
+end
+

data/lib/spec/rails/extensions/spec/matchers/have.rb

@@ -0,0 +1,23 @@
+require 'spec/matchers/have'
+
+module Spec #:nodoc:
+  module Matchers #:nodoc:
+    class Have #:nodoc:
+
+      def failure_message_for_should_with_errors_on_extensions
+        return "expected #{relativities[@relativity]}#{@expected} errors on :#{@args[0]}, got #{@actual}" if @collection_name == :errors_on
+        return "expected #{relativities[@relativity]}#{@expected} error on :#{@args[0]}, got #{@actual}"  if @collection_name == :error_on
+        return failure_message_for_should_without_errors_on_extensions
+      end
+      alias_method_chain :failure_message_for_should, :errors_on_extensions
+      
+      def description_with_errors_on_extensions
+        return "have #{relativities[@relativity]}#{@expected} errors on :#{@args[0]}" if @collection_name == :errors_on
+        return "have #{relativities[@relativity]}#{@expected} error on :#{@args[0]}"  if @collection_name == :error_on
+        return description_without_errors_on_extensions
+      end
+      alias_method_chain :description, :errors_on_extensions
+
+    end
+  end
+end

data/lib/spec/rails/extensions/spec/runner/configuration.rb

@@ -0,0 +1,45 @@
+require 'spec/runner/configuration'
+require 'test_help'
+
+if defined?(ActiveRecord::Base)
+  module Spec
+    module Runner
+      class Configuration
+      
+        def initialize
+          super
+          self.fixture_path = RAILS_ROOT + '/spec/fixtures'
+        end
+
+        def use_transactional_fixtures
+          ActiveSupport::TestCase.use_transactional_fixtures
+        end
+        def use_transactional_fixtures=(value)
+          ActiveSupport::TestCase.use_transactional_fixtures = value
+        end
+
+        def use_instantiated_fixtures
+          ActiveSupport::TestCase.use_instantiated_fixtures
+        end
+        def use_instantiated_fixtures=(value)
+          ActiveSupport::TestCase.use_instantiated_fixtures = value
+        end
+
+        def fixture_path
+          ActiveSupport::TestCase.fixture_path
+        end
+        def fixture_path=(path)
+          ActiveSupport::TestCase.fixture_path = path
+          ActionController::IntegrationTest.fixture_path = path
+        end
+
+        def global_fixtures
+          ActiveSupport::TestCase.fixture_table_names
+        end
+        def global_fixtures=(fixtures)
+          ActiveSupport::TestCase.fixtures(*fixtures)
+        end
+      end
+    end
+  end
+end

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

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

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

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

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