rspec-rails 2.8.0.rc1 → 2.8.0.rc2

data/lib/rspec/rails/matchers/have_extension.rb

@@ -1,23 +1,35 @@
 require 'active_support/core_ext/module/aliasing'
 require 'rspec/matchers/have'
 
-module RSpec
-  module Matchers
-    class Have
-      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
+module RSpec::Rails::Matchers
+  module HaveExtensions
+    extend ActiveSupport::Concern
+
+    # @api private
+    #
+    # Enhances the failure message for `should have(n)` matchers
+    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
 
-      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
+    # @api private
+    #
+    # Enhances the description for `should have(n)` matchers
+    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
+
+    included do
+      alias_method_chain :failure_message_for_should, :errors_on_extensions
       alias_method_chain :description, :errors_on_extensions
     end
   end
 end
 
+RSpec::Matchers::Have.class_eval do
+  include RSpec::Rails::Matchers::HaveExtensions
+end

data/lib/rspec/rails/matchers/redirect_to.rb

@@ -1,19 +1,38 @@
 module RSpec::Rails::Matchers
   module RedirectTo
-    extend RSpec::Matchers::DSL
+    class RedirectTo
+      include RSpec::Matchers::BaseMatcher
 
-    matcher :redirect_to do |destination|
-      match_unless_raises ActiveSupport::TestCase::Assertion do |_|
-        assert_redirected_to destination
+      def initialize(scope, expected)
+        super(expected)
+        @scope = scope
       end
 
-      failure_message_for_should do |_|
+      # @api private
+      def matches?(actual)
+        match_unless_raises ActiveSupport::TestCase::Assertion do
+          @scope.assert_redirected_to(expected)
+        end
+      end
+
+      # @api private
+      def failure_message_for_should
         rescued_exception.message
       end
 
-      failure_message_for_should_not do |_|
-        "expected not to redirect to #{destination.inspect}, but did"
+      # @api private
+      def failure_message_for_should_not
+        "expected not to redirect to #{expected.inspect}, but did"
       end
     end
+
+    # Delegates to `assert_redirected_to`
+    #
+    # @example
+    #
+    #     response.should redirect_to(:action => "new")
+    def redirect_to(target)
+      RedirectTo.new(self, target)
+    end
   end
 end

data/lib/rspec/rails/matchers/relation_match_array.rb

@@ -1,3 +1,3 @@
-if defined?(ActiveRecord)
+if defined?(ActiveRecord::Relation)
   RSpec::Matchers::OperatorMatcher.register(ActiveRecord::Relation, '=~', RSpec::Matchers::MatchArray)
 end

data/lib/rspec/rails/matchers/render_template.rb

@@ -1,20 +1,39 @@
 module RSpec::Rails::Matchers
   module RenderTemplate
-    extend RSpec::Matchers::DSL
+    class RenderTemplateMatcher
+      include RSpec::Matchers::BaseMatcher
 
-    matcher :render_template do |options, message|
-      match_unless_raises ActiveSupport::TestCase::Assertion do |_|
-        options = options.to_s if Symbol === options
-        assert_template options, message
+      def initialize(scope, expected, message=nil)
+        super(Symbol === expected ? expected.to_s : expected)
+        @message = message
+        @scope = scope
       end
 
-      failure_message_for_should do
+      # @api private
+      def matches?(*)
+        match_unless_raises ActiveSupport::TestCase::Assertion do
+          @scope.assert_template expected, @message
+        end
+      end
+
+      # @api private
+      def failure_message_for_should
         rescued_exception.message
       end
 
-      failure_message_for_should_not do |_|
-        "expected not to render #{options.inspect}, but did"
+      # @api private
+      def failure_message_for_should_not
+        "expected not to render #{expected.inspect}, but did"
       end
     end
+
+    # Delegates to `assert_template`
+    #
+    # @example
+    #
+    #     response.should render_template("new")
+    def render_template(options, message=nil)
+      RenderTemplateMatcher.new(self, options, message)
+    end
   end
 end

data/lib/rspec/rails/matchers/routing_matchers.rb

@@ -2,50 +2,98 @@ module RSpec::Rails::Matchers
   module RoutingMatchers
     extend RSpec::Matchers::DSL
 
-    matcher :route_to do |*expected|
-      expected_options = expected[1] || {}
-      if Hash === expected[0]
-        expected_options.merge!(expected[0])
-      else
-        controller, action = expected[0].split('#')
-        expected_options.merge!(:controller => controller, :action => action)
+    class RouteToMatcher
+      include RSpec::Matchers::BaseMatcher
+
+      def initialize(scope, *expected)
+        @scope = scope
+        @expected_options = expected[1] || {}
+        if Hash === expected[0]
+          @expected_options.merge!(expected[0])
+        else
+          controller, action = expected[0].split('#')
+          @expected_options.merge!(:controller => controller, :action => action)
+        end
       end
 
-      match_unless_raises ActiveSupport::TestCase::Assertion do |verb_to_path_map|
-        path, query = *verb_to_path_map.values.first.split('?')
-        assert_recognizes(
-          expected_options,
-          {:method => verb_to_path_map.keys.first, :path => path},
-          Rack::Utils::parse_query(query)
-        )
+      # @api private
+      def matches?(verb_to_path_map)
+        match_unless_raises ActiveSupport::TestCase::Assertion do
+          path, query = *verb_to_path_map.values.first.split('?')
+          @scope.assert_recognizes(
+            @expected_options,
+            {:method => verb_to_path_map.keys.first, :path => path},
+            Rack::Utils::parse_query(query)
+          )
+        end
       end
 
-      failure_message_for_should do
+      # @api private
+      def failure_message_for_should
         rescued_exception.message
       end
+    end
 
+    # Delegates to `assert_recognizes`. Supports short-hand controller/action
+    # declarations (e.g. `"controller#action"`).
+    #
+    # @example
+    #
+    #     { :get => "/things/special" }.should route_to(
+    #       :controller => "things",
+    #       :action     => "special"
+    #     )
+    #
+    #     { :get => "/things/special" }.should route_to("things#special")
+    #
+    # @see http://api.rubyonrails.org/classes/ActionDispatch/Assertions/RoutingAssertions.html#method-i-assert_recognizes
+    def route_to(*expected)
+      RouteToMatcher.new(self, *expected)
     end
 
-    matcher :be_routable do
-      match_unless_raises ActionController::RoutingError do |path|
-        @routing_options = routes.recognize_path(
-          path.values.first, :method => path.keys.first
-        )
+    class BeRoutableMatcher
+      include RSpec::Matchers::BaseMatcher
+
+      def initialize(scope)
+        @scope = scope
+      end
+
+      # @api private
+      def matches?(path)
+        super(path)
+        match_unless_raises ActionController::RoutingError do
+          @routing_options = @scope.routes.recognize_path(
+            path.values.first, :method => path.keys.first
+          )
+        end
       end
 
-      failure_message_for_should_not do |path|
-        "expected #{path.inspect} not to be routable, but it routes to #{@routing_options.inspect}"
+      # @api private
+      def failure_message_for_should_not
+        "expected #{actual.inspect} not to be routable, but it routes to #{@routing_options.inspect}"
       end
     end
 
-    module RouteHelpers
+    # Passes if the route expression is recognized by the Rails router based on
+    # the declarations in `config/routes.rb`. Delegates to
+    # `RouteSet#recognize_path`.
+    #
+    # @example
+    #
+    # You can use route helpers provided by rspec-rails.
+    #     {:get =>  "/a/path"}.should be_routable
+    #     {:post => "/another/path"}.should be_routable
+    #     {:put => "/yet/another/path"}.should_not be_routable
+    def be_routable
+      BeRoutableMatcher.new(self)
+    end
 
+    module RouteHelpers
       %w(get post put delete options head).each do |method|
         define_method method do |path|
           { method.to_sym => path }
         end
       end
-
     end
   end
 end

data/lib/rspec/rails/mocks.rb

@@ -9,7 +9,7 @@ module RSpec
     module Mocks
 
       module ActiveModelInstanceMethods
-        # Stubs +persisted?+ to return false and +id+ to return nil
+        # Stubs `persisted?` to return false and `id` to return nil
         # @return self
         def as_new_record
           self.stub(:persisted?) { false }
@@ -30,7 +30,7 @@ module RSpec
       end
 
       module ActiveRecordInstanceMethods
-        # Stubs +persisted?+ to return +false+ and +id+ to return +nil+.
+        # Stubs `persisted?` to return `false` and `id` to return `nil`.
         def destroy
           self.stub(:persisted?) { false }
           self.stub(:id) { nil }
@@ -41,15 +41,15 @@ module RSpec
           send(key)
         end
 
-        # Returns the opposite of +persisted?+
+        # Returns the opposite of `persisted?`
         def new_record?
           !persisted?
         end
       end
 
-      # Creates a test double representing +string_or_model_class+ with common
+      # Creates a test double representing `string_or_model_class` with common
       # ActiveModel methods stubbed out. Additional methods may be easily
-      # stubbed (via add_stubs) if +stubs+ is passed. This is most useful for
+      # stubbed (via add_stubs) if `stubs` is passed. This is most useful for
       # impersonating models that don't exist yet.
       #
       # NOTE that only ActiveModel's methods, plus <tt>new_record?</tt>, are
@@ -59,7 +59,7 @@ module RSpec
       # ActiveModel API (which declares <tt>persisted?</tt>, not
       # <tt>new_record?</tt>).
       #
-      # +string_or_model_class+ can be any of:
+      # `string_or_model_class` can be any of:
       #
       #   * A String representing a Class that does not exist
       #   * A String representing a Class that extends ActiveModel::Naming
@@ -90,20 +90,22 @@ EOM
         end
 
         stubs = stubs.reverse_merge(:id => next_id)
-        stubs = stubs.reverse_merge(:persisted? => !!stubs[:id])
-        stubs = stubs.reverse_merge(:destroyed? => false)
-        stubs = stubs.reverse_merge(:marked_for_destruction? => false)
-        stubs = stubs.reverse_merge(:blank? => false)
+        stubs = stubs.reverse_merge(:persisted? => !!stubs[:id],
+                                    :destroyed? => false,
+                                    :marked_for_destruction? => false,
+                                    :blank? => false)
 
         mock("#{model_class.name}_#{stubs[:id]}", stubs).tap do |m|
-          m.extend ActiveModelInstanceMethods
-          m.singleton_class.__send__ :include, ActiveModel::Conversion
-          m.singleton_class.__send__ :include, ActiveModel::Validations
+          m.singleton_class.class_eval do
+            include ActiveModelInstanceMethods
+            include ActiveRecordInstanceMethods if defined?(ActiveRecord)
+            include ActiveModel::Conversion
+            include ActiveModel::Validations
+          end
           if defined?(ActiveRecord)
-            m.extend ActiveRecordInstanceMethods
             [:save, :update_attributes].each do |key|
               if stubs[key] == false
-                m.errors.stub(:empty?) { false }
+                m.errors.stub(:empty? => false)
               end
             end
           end
@@ -119,11 +121,19 @@ EOM
             def @object.instance_of?(other)
               other == #{model_class}
             end unless #{stubs.has_key?(:instance_of?)}
-            
+
+            def @object.__model_class_has_column?(method_name)
+              #{model_class}.respond_to?(:column_names) && #{model_class}.column_names.include?(method_name.to_s)
+            end
+
             def @object.respond_to?(method_name, include_private=false)
-              #{model_class}.respond_to?(:column_names) && #{model_class}.column_names.include?(method_name.to_s) || super
+              __model_class_has_column?(method_name) ? true : super
             end unless #{stubs.has_key?(:respond_to?)}
             
+            def @object.method_missing(m, *a, &b)
+              respond_to?(m) ? nil : super
+            end
+
             def @object.class
               #{model_class}
             end unless #{stubs.has_key?(:class)}
@@ -137,27 +147,27 @@ EOM
       end
 
       module ActiveModelStubExtensions
-        # Stubs +persisted+ to return false and +id+ to return nil
+        # Stubs `persisted` to return false and `id` to return nil
         def as_new_record
           self.stub(:persisted?)  { false }
           self.stub(:id)          { nil }
           self
         end
 
-        # Returns +true+ by default. Override with a stub.
+        # Returns `true` by default. Override with a stub.
         def persisted?
           true
         end
       end
 
       module ActiveRecordStubExtensions
-        # Stubs +id+ (or other primary key method) to return nil
+        # Stubs `id` (or other primary key method) to return nil
         def as_new_record
           self.__send__("#{self.class.primary_key}=", nil)
           super
         end
 
-        # Returns the opposite of +persisted?+.
+        # Returns the opposite of `persisted?`.
         def new_record?
           !persisted?
         end
@@ -169,11 +179,11 @@ EOM
         end
       end
 
-      # Creates an instance of +Model+ with +to_param+ stubbed using a
-      # generated value that is unique to each object.. If +Model+ is an
-      # +ActiveRecord+ model, it is prohibited from accessing the database*.
+      # Creates an instance of `Model` with `to_param` stubbed using a
+      # generated value that is unique to each object.. If `Model` is an
+      # `ActiveRecord` model, it is prohibited from accessing the database*.
       #
-      # For each key in +hash_of_stubs+, if the model has a matching attribute
+      # For each key in `hash_of_stubs`, if the model has a matching attribute
       # (determined by asking it) are simply assigned the submitted values. If
       # the model does not have a matching attribute, the key/value pair is
       # assigned as a stub return value using RSpec's mocking/stubbing
@@ -181,23 +191,21 @@ EOM
       #
       # <tt>persisted?</tt> is overridden to return the result of !id.nil?
       # This means that by default persisted? will return true. If  you want
-      # the object to behave as a new record, sending it +as_new_record+ will
+      # the object to behave as a new record, sending it `as_new_record` will
       # set the id to nil. You can also explicitly set :id => nil, in which
-      # case persisted? will return false, but using +as_new_record+ makes the
+      # case persisted? will return false, but using `as_new_record` makes the
       # example a bit more descriptive.
       #
       # While you can use stub_model in any example (model, view, controller,
       # helper), it is especially useful in view examples, which are
       # inherently more state-based than interaction-based.
       #
-      # == Examples
+      # @example
       #
-      #   stub_model(Person)
-      #   stub_model(Person).as_new_record
-      #   stub_model(Person, :to_param => 37)
-      #   stub_model(Person) do |person|
-      #     person.first_name = "David"
-      #   end
+      #     stub_model(Person)
+      #     stub_model(Person).as_new_record
+      #     stub_model(Person, :to_param => 37)
+      #     stub_model(Person) {|person| person.first_name = "David"}
       def stub_model(model_class, stubs={})
         model_class.new.tap do |m|
           m.extend ActiveModelStubExtensions

data/lib/rspec/rails/module_inclusion.rb

@@ -1,6 +1,7 @@
 module RSpec::Rails
   module ModuleInclusion
-    # Deprecated as of rspec-rails-2.4
+    # @deprecated No replacement.
+    #
     # Will be removed from rspec-rails-3.0
     #
     # This was never intended to be a public API and is no longer needed