cavalle-rspec-rails 1.2.2.0.1

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

@@ -0,0 +1,186 @@
+module Spec
+  module Rails
+    module Example
+      class ViewExampleGroupController < ApplicationController #:nodoc:
+        include Spec::Rails::Example::RenderObserver
+        attr_reader :template
+
+        def add_helper_for(template_path)
+          add_helper(template_path.split('/')[0])
+        end
+
+        def add_helper(name)
+          begin
+            helper_module = "#{name}_helper".camelize.constantize
+          rescue
+            return
+          end
+          (class << template; self; end).class_eval do
+            include helper_module
+          end
+        end
+        
+        def forget_variables_added_to_assigns
+        end
+      end
+
+      # View Examples live in $RAILS_ROOT/spec/views/.
+      #
+      # View Specs use Spec::Rails::Example::ViewExampleGroup,
+      # which provides access to views without invoking any of your controllers.
+      # See Spec::Rails::Expectations::Matchers for information about specific
+      # expectations that you can set on views.
+      #
+      # == Example
+      #
+      #   describe "login/login" do
+      #     before do
+      #       render 'login/login'
+      #     end
+      # 
+      #     it "should display login form" do
+      #       response.should have_tag("form[action=/login]") do
+      #         with_tag("input[type=text][name=email]")
+      #         with_tag("input[type=password][name=password]")
+      #         with_tag("input[type=submit][value=Login]")
+      #       end
+      #     end
+      #   end
+      class ViewExampleGroup < FunctionalExampleGroup
+        tests ViewExampleGroupController
+        class << self
+          def inherited(klass) # :nodoc:
+            klass.subject { template }
+            super
+          end
+        end
+
+        before {ensure_that_flash_and_session_work_properly}
+        after  {ensure_that_base_view_path_is_not_set_across_example_groups}
+
+        def ensure_that_flash_and_session_work_properly #:nodoc:
+          @controller.class.__send__ :public, :flash
+          @controller.__send__ :initialize_template_class, @response
+          @controller.__send__ :assign_shortcuts, @request, @response
+          @controller.__send__ :initialize_current_url
+          @session = @controller.session
+        end
+
+        def ensure_that_base_view_path_is_not_set_across_example_groups #:nodoc:
+          ActionView::Base.base_view_path = nil
+        end
+
+        def set_base_view_path(options) #:nodoc:
+          ActionView::Base.base_view_path = base_view_path(options)
+        end
+
+        def base_view_path(options) #:nodoc:
+          "/#{derived_controller_name(options)}/"
+        end
+
+        def derived_controller_name(options) #:nodoc:
+          parts = subject_of_render(options).split('/').reject { |part| part.empty? }
+          "#{parts[0..-2].join('/')}"
+        end
+
+        def derived_action_name(options) #:nodoc:
+          parts = subject_of_render(options).split('/').reject { |part| part.empty? }
+          "#{parts.last}".split('.').first
+        end
+
+        def subject_of_render(options) #:nodoc:
+          [:template, :partial, :file].each do |render_type|
+            if options.has_key?(render_type)
+              return options[render_type]
+            end
+          end
+          return ""
+        end
+
+        def add_helpers(options) #:nodoc:
+          @controller.add_helper("application")
+          @controller.add_helper(derived_controller_name(options))
+          @controller.add_helper(options[:helper]) if options[:helper]
+          options[:helpers].each { |helper| @controller.add_helper(helper) } if options[:helpers]
+        end
+
+        # Renders a template for a View Spec, which then provides access to the result
+        # through the +response+. Also supports render with :inline, which you can
+        # use to spec custom form builders, helpers, etc, in the context of a view.
+        #
+        # == Examples
+        #
+        #   render('/people/list')
+        #   render('/people/list', :helper => MyHelper)
+        #   render('/people/list', :helpers => [MyHelper, MyOtherHelper])
+        #   render(:partial => '/people/_address')
+        #   render(:inline => "<% custom_helper 'argument', 'another argument' %>")
+        #
+        # See Spec::Rails::Example::ViewExampleGroup for more information.
+        def render(*args)
+          options = Hash === args.last ? args.pop : {}
+          
+          if args.empty? 
+            unless [:partial, :inline, :file, :template, :xml, :json, :update].any? {|k| options.has_key? k} 
+              args << self.class.description_parts.first
+            end
+          end
+          
+          options[:template] = args.first.to_s.sub(/^\//,'') unless args.empty?
+          
+          set_base_view_path(options)
+          add_helpers(options)
+
+          assigns[:action_name] = @action_name
+          
+          @request.path_parameters = @request.path_parameters.merge(
+            :controller => derived_controller_name(options),
+            :action => derived_action_name(options)
+          ).merge(options[:path_parameters] || {})
+
+          defaults = { :layout => false }
+          options = defaults.merge options
+
+          @controller.__send__(:params).reverse_merge! @request.parameters
+
+          @controller.class.instance_eval %{
+            def controller_path
+              "#{derived_controller_name(options)}"
+            end
+
+            def controller_name
+              "#{derived_controller_name(options).split('/').last}"
+            end
+          }
+
+          @controller.__send__ :forget_variables_added_to_assigns
+          @controller.__send__ :render, options
+          @controller.__send__ :process_cleanup
+        end
+
+        # This provides the template. Use this to set mock
+        # expectations for dealing with partials
+        #
+        # == Example
+        #
+        #   describe "/person/new" do
+        #     it "should use the form partial" do
+        #       template.should_receive(:render).with(:partial => 'form')
+        #       render "/person/new"
+        #     end
+        #   end
+        def template
+          @controller.template
+        end
+
+        Spec::Example::ExampleGroupFactory.register(:view, self)
+
+      protected
+        def _assigns_hash_proxy
+          @_assigns_hash_proxy ||= AssignsHashProxy.new(self) {@response.template}
+        end
+      end
+
+    end
+  end
+end

data/lib/spec/rails/example.rb

@@ -0,0 +1,47 @@
+dir = File.dirname(__FILE__)
+
+require 'spec/rails/example/routing_helpers'
+require 'spec/rails/example/assigns_hash_proxy'
+require "spec/rails/example/render_observer"
+require "spec/rails/example/model_example_group"
+require "spec/rails/example/functional_example_group"
+require "spec/rails/example/controller_example_group"
+require "spec/rails/example/helper_example_group"
+require "spec/rails/example/view_example_group"
+require "spec/rails/example/routing_example_group"
+require "spec/rails/example/cookies_proxy"
+
+module Spec
+  module Rails
+    # Spec::Rails::Example extends Spec::Example (RSpec's core Example module) to provide
+    # Rails-specific contexts for describing Rails Models, Views, Controllers and Helpers.
+    #
+    # == Model Examples
+    #
+    # These are the equivalent of unit tests in Rails' built in testing. Ironically (for the traditional TDD'er) these are the only specs that we feel should actually interact with the database.
+    #
+    # See Spec::Rails::Example::ModelExampleGroup
+    #
+    # == Controller Examples
+    #
+    # These align somewhat with functional tests in rails, except that they do not actually render views (though you can force rendering of views if you prefer). Instead of setting expectations about what goes on a page, you set expectations about what templates get rendered.
+    #
+    # See Spec::Rails::Example::ControllerExampleGroup
+    #
+    # == View Examples
+    #
+    # This is the other half of Rails functional testing. View specs allow you to set up assigns and render
+    # a template. By assigning mock model data, you can specify view behaviour with no dependency on a database
+    # or your real models.
+    #
+    # See Spec::Rails::Example::ViewExampleGroup
+    #
+    # == Helper Examples
+    #
+    # These let you specify directly methods that live in your helpers.
+    #
+    # See Spec::Rails::Example::HelperExampleGroup
+    module Example
+    end
+  end
+end

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,33 @@
+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)
+        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_without_errors_on_extensions
+      end
+      alias_method_chain :failure_message_for_should, :errors_on_extensions
+      
+      def description_with_errors_on_extensions
+        return "should have #{relativities[@relativity]}#{@expected} errors on :#{@args[0]}" if @collection_name == :errors_on
+        return "should 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,44 @@
+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
+        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/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/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/ar_be_valid.rb

@@ -0,0 +1,44 @@
+module Spec
+  module Rails
+    module Matchers
+    
+      class ArBeValid  #:nodoc:
+        
+        def initialize
+          @matcher = Spec::Matchers::Be.new :be_valid
+          @matcher.__send__ :handling_predicate!
+        end
+
+        def matches?(actual)
+          @actual = actual
+          @matcher.matches? @actual
+        end
+      
+        def failure_message_for_should
+          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
+            @matcher.failure_message_for_should
+          end
+        end
+        
+        def failure_message_for_should_not
+          @matcher.failure_message_for_should_not
+        end
+        
+        def description
+          "be valid"
+        end
+      end
+
+      # :call-seq:
+      #   response.should be_valid
+      #   response.should_not be_valid
+      def be_valid
+        ArBeValid.new
+      end
+    
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+# This is a wrapper of assert_select for rspec.
+
+module Spec # :nodoc:
+  module Rails
+    module Matchers
+
+      class AssertSelect #:nodoc:
+        
+        def initialize(assertion, spec_scope, *args, &block)
+          @assertion = assertion
+          @spec_scope = spec_scope
+          @args = args
+          @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__(@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)}",
+          }[@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
+          markup = response_or_text.body if response_or_text.test_response?
+          markup = response_or_text if response_or_text.string?
+          HTML::Document.new(markup, false, response_or_text.test_response?).root if markup
+        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
+        
+      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.
+      #
+      # == Examples
+      #
+      #   # in a controller spec
+      #   response.should have_tag("div", "some text")
+      #
+      #   # 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)
+        @__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)
+        @__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
+    end
+  end
+end