rspec-rails 2.0.0.beta.22 → 2.6.0

data/lib/rspec/rails/example/request_example_group.rb

@@ -13,51 +13,26 @@ module RSpec::Rails
   #   => delegates to assert_redirected_to(destination)
   module RequestExampleGroup
     extend ActiveSupport::Concern
-    extend RSpec::Rails::ModuleInclusion
-
     include RSpec::Rails::RailsExampleGroup
-
     include ActionDispatch::Integration::Runner
     include ActionDispatch::Assertions
-    include RSpec::Rails::BrowserSimulators
-
-    webrat do
-      include Webrat::Matchers
-      include Webrat::Methods
-    end
-
-    capybara do
-      include Capybara
-    end
-
-    include RSpec::Rails::Matchers::RedirectTo
-    include RSpec::Rails::Matchers::RenderTemplate
-    include ActionController::TemplateAssertions
 
     module InstanceMethods
       def app
         ::Rails.application
       end
-
-      def last_response
-        response
-      end
     end
 
+    include RSpec::Rails::Matchers::RedirectTo
+    include RSpec::Rails::Matchers::RenderTemplate
+    include ActionController::TemplateAssertions
+
     included do
       metadata[:type] = :request
 
       before do
-        @router = ::Rails.application.routes
-      end
-
-      webrat do
-        Webrat.configure do |config|
-          config.mode = :rack
-        end
+        @routes = ::Rails.application.routes
       end
     end
-
-    RSpec.configure &include_self_when_dir_matches('spec','requests')
   end
 end

data/lib/rspec/rails/example/routing_example_group.rb

@@ -3,16 +3,16 @@ require "action_dispatch/testing/assertions/routing"
 module RSpec::Rails
   module RoutingExampleGroup
     extend ActiveSupport::Concern
-    extend RSpec::Rails::ModuleInclusion
-
     include RSpec::Rails::RailsExampleGroup
-
     include ActionDispatch::Assertions::RoutingAssertions
     include RSpec::Rails::Matchers::RoutingMatchers
+    include RSpec::Rails::Matchers::RoutingMatchers::RouteHelpers
 
     module InstanceMethods
       attr_reader :routes
 
+      private
+
       def method_missing(m, *args, &block)
         routes.url_helpers.respond_to?(m) ? routes.url_helpers.send(m, *args) : super
       end
@@ -25,7 +25,5 @@ module RSpec::Rails
         @routes = ::Rails.application.routes
       end
     end
-
-    RSpec.configure &include_self_when_dir_matches('spec','routing')
   end
 end

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

@@ -19,21 +19,14 @@ module RSpec::Rails
   #   end
   module ViewExampleGroup
     extend ActiveSupport::Concern
-    extend RSpec::Rails::ModuleInclusion
-
     include RSpec::Rails::RailsExampleGroup
     include ActionView::TestCase::Behavior
     include RSpec::Rails::ViewAssigns
     include RSpec::Rails::Matchers::RenderTemplate
-    include RSpec::Rails::BrowserSimulators
-
-    webrat do
-      include Webrat::Matchers
-    end
 
     module ClassMethods
       def _default_helper
-        base = metadata[:behaviour][:description].split('/').first
+        base = metadata[:example_group][:description].split('/').first
         (base.camelize + 'Helper').constantize if base
       rescue NameError
         nil
@@ -85,6 +78,18 @@ module RSpec::Rails
         _view
       end
 
+      # Simulates the presence of a template on the file system by adding a
+      # Rails' FixtureResolver to the front of the view_paths list. Designed to
+      # help isolate view examples from partials rendered by the view template
+      # that is the subject of the example.
+      #
+      # == Example
+      #
+      #   stub_template("widgets/_widget.html.erb" => "This content.")
+      def stub_template(hash)
+        view.view_paths.unshift(ActionView::FixtureResolver.new(hash))
+      end
+
       # Provides access to the params hash that will be available within the
       # view:
       #
@@ -137,13 +142,17 @@ module RSpec::Rails
 
       before do
         _include_controller_helpers
-        controller.controller_path = _controller_path
+        if view.lookup_context.respond_to?(:prefixes)
+          # rails 3.1
+          view.lookup_context.prefixes << _controller_path
+        else
+          # rails 3.0
+          controller.controller_path = _controller_path
+        end
         controller.request.path_parameters["controller"] = _controller_path
         controller.request.path_parameters["action"]     = _inferred_action unless _inferred_action =~ /^_/
       end
     end
-
-    RSpec.configure &include_self_when_dir_matches('spec','views')
   end
 end
 

data/lib/rspec/rails/example.rb

@@ -5,4 +5,34 @@ require 'rspec/rails/example/helper_example_group'
 require 'rspec/rails/example/view_example_group'
 require 'rspec/rails/example/mailer_example_group'
 require 'rspec/rails/example/routing_example_group'
-require 'rspec/rails/example/model_example_group'
+require 'rspec/rails/example/model_example_group'
+
+RSpec::configure do |c|
+  def c.escaped_path(*parts)
+    Regexp.compile(parts.join('[\\\/]'))
+  end
+
+  c.include RSpec::Rails::ControllerExampleGroup, :type => :controller, :example_group => {
+    :file_path => c.escaped_path(%w[spec controllers])
+  }
+  c.include RSpec::Rails::HelperExampleGroup, :type => :helper, :example_group => {
+    :file_path => c.escaped_path(%w[spec helpers])
+  }
+  if defined?(RSpec::Rails::MailerExampleGroup)
+    c.include RSpec::Rails::MailerExampleGroup, :type => :mailer, :example_group => {
+      :file_path => c.escaped_path(%w[spec mailers])
+    }
+  end
+  c.include RSpec::Rails::ModelExampleGroup, :type => :model, :example_group => {
+    :file_path => c.escaped_path(%w[spec models])
+  }
+  c.include RSpec::Rails::RequestExampleGroup, :type => :request, :example_group => {
+    :file_path => c.escaped_path(%w[spec (requests|integration)])
+  }
+  c.include RSpec::Rails::RoutingExampleGroup, :type => :routing, :example_group => {
+    :file_path => c.escaped_path(%w[spec routing])
+  }
+  c.include RSpec::Rails::ViewExampleGroup, :type => :view, :example_group => {
+    :file_path => c.escaped_path(%w[spec views])
+  }
+end

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

@@ -1,44 +1,40 @@
 module RSpec
   module Rails
-    if using_active_record?
+    if defined?(ActiveRecord)
       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[attribute]].flatten.compact
-            end
-            alias :error_on :errors_on
+          # :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
-      end
 
-      class ::ActiveRecord::Base #:nodoc:
-        extend  RSpec::Rails::Extensions::ActiveRecord::ClassMethods
-        include RSpec::Rails::Extensions::ActiveRecord::InstanceMethods
+        class ::ActiveRecord::Base #:nodoc:
+          extend RSpec::Rails::Extensions::ActiveRecord
+        end
       end
     end
   end
 end
 
+module ::ActiveModel::Validations
+  # :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[attribute]].flatten.compact
+  end
+  alias :error_on :errors_on
+end

data/lib/rspec/rails/fixture_support.rb

@@ -1,6 +1,6 @@
 module RSpec
   module Rails
-    if using_active_record?
+    if defined?(ActiveRecord)
       module FixtureSupport
         extend ActiveSupport::Concern
 

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

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :be_new_record do
+  match do |actual|
+    !actual.persisted?
+  end
+end

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

@@ -3,13 +3,17 @@ module RSpec::Rails::Matchers
     extend RSpec::Matchers::DSL
 
     matcher :redirect_to do |destination|
-      match_unless_raises Test::Unit::AssertionFailedError do |_|
+      match_unless_raises ActiveSupport::TestCase::Assertion do |_|
         assert_redirected_to destination
       end
 
-      failure_message_for_should do
+      failure_message_for_should do |_|
         rescued_exception.message
       end
+
+      failure_message_for_should_not do |_|
+        "expected not to redirect to #{destination.inspect}, but did"
+      end
     end
   end
 end

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

@@ -3,7 +3,7 @@ module RSpec::Rails::Matchers
     extend RSpec::Matchers::DSL
 
     matcher :render_template do |options, message|
-      match_unless_raises Test::Unit::AssertionFailedError do |_|
+      match_unless_raises ActiveSupport::TestCase::Assertion do |_|
         options = options.to_s if Symbol === options
         assert_template options, message
       end
@@ -11,6 +11,10 @@ module RSpec::Rails::Matchers
       failure_message_for_should do
         rescued_exception.message
       end
+
+      failure_message_for_should_not do |_|
+        "expected not to render #{options.inspect}, but did"
+      end
     end
   end
 end

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

@@ -2,10 +2,21 @@ module RSpec::Rails::Matchers
   module RoutingMatchers
     extend RSpec::Matchers::DSL
 
-    matcher :route_to do |route_options|
-      match_unless_raises Test::Unit::AssertionFailedError do |path|
+    matcher :route_to do |*route_options|
+      match_unless_raises ActiveSupport::TestCase::Assertion do |path|
         assertion_path = { :method => path.keys.first, :path => path.values.first }
-        assert_routing(assertion_path, route_options)
+
+        path, options = *route_options
+
+        if path.is_a?(String)
+          controller, action = path.split("#")
+          options ||= {}
+          options.merge!(:controller => controller, :action => action)
+        else
+          options = path
+        end
+
+        assert_recognizes(options, assertion_path)
       end
 
       failure_message_for_should do
@@ -24,5 +35,15 @@ module RSpec::Rails::Matchers
         "expected #{path.inspect} not to be routable, but it routes to #{@routing_options.inspect}"
       end
     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/matchers.rb

@@ -1,5 +1,4 @@
 require 'rspec/core/deprecation'
-require 'rspec/core/backward_compatibility'
 require 'rspec/matchers'
 
 module RSpec::Rails
@@ -21,5 +20,6 @@ end
 require 'rspec/rails/matchers/render_template'
 require 'rspec/rails/matchers/redirect_to'
 require 'rspec/rails/matchers/routing_matchers'
+require 'rspec/rails/matchers/be_new_record'
 require 'rspec/rails/matchers/be_a_new'
 require 'rspec/rails/matchers/have_extension'

data/lib/rspec/rails/mocks.rb

@@ -1,3 +1,6 @@
+require 'active_support/core_ext'
+require 'active_model'
+
 module RSpec
   module Rails
 
@@ -5,39 +8,55 @@ module RSpec
 
     module Mocks
 
-      module InstanceMethods
-        def valid?
-          true
-        end
-
+      module ActiveModelInstanceMethods
         def as_new_record
+          self.stub(:persisted?) { false }
           self.stub(:id) { nil }
           self
         end
 
-        def new_record?
-          !persisted?
+        def persisted?
+          true
         end
 
-        def persisted?
-          !!id
+        def respond_to?(message, include_private=false)
+          message.to_s =~ /_before_type_cast$/ ? false : super
         end
+      end
 
+      module ActiveRecordInstanceMethods
         def destroy
+          self.stub(:persisted?) { false }
           self.stub(:id) { nil }
         end
+
+        def [](key)
+          send(key)
+        end
+
+        def new_record?
+          !persisted?
+        end
       end
 
-      # Creates a mock object instance for a +string_or_model_class+ with
-      # common methods stubbed out. Additional methods may be easily stubbed
-      # (via add_stubs) if +stubs+ is passed.
+      # 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
+      # impersonating models that don't exist yet.
       #
-      # +model_class+ can be any of:
+      # NOTE that only ActiveModel's methods, plus <tt>new_record?</tt>, are
+      # stubbed out implicitly.  <tt>new_record?</tt> returns the inverse of
+      # <tt>persisted?</tt>, and is present only for compatibility with
+      # extension frameworks that have yet to update themselves to the
+      # ActiveModel API (which declares <tt>persisted?</tt>, not
+      # <tt>new_record?</tt>).
+      #
+      # +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
       #   * A Class that extends ActiveModel::Naming
-      def mock_model(string_or_model_class, options_and_stubs = {})
+      def mock_model(string_or_model_class, stubs = {})
         if String === string_or_model_class
           if Object.const_defined?(string_or_model_class)
             model_class = Object.const_get(string_or_model_class)
@@ -61,57 +80,72 @@ It received #{model_class.inspect}
 EOM
         end
 
-        id = options_and_stubs.has_key?(:id) ? options_and_stubs[:id] : next_id
-        options_and_stubs = options_and_stubs.reverse_merge({
-          :id => id,
-          :destroyed? => false,
-          :marked_for_destruction? => false
-        })
-        derived_name = "#{model_class.name}_#{id}"
-        m = mock(derived_name, options_and_stubs)
-        m.extend InstanceMethods
-        m.extend ActiveModel::Conversion
-        errors = ActiveModel::Errors.new(m)
-        [:save, :update_attributes].each do |key|
-          if options_and_stubs[key] == false
-            errors.stub(:empty?) { false }
+        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)
+
+        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
+          if defined?(ActiveRecord)
+            m.extend ActiveRecordInstanceMethods
+            [:save, :update_attributes].each do |key|
+              if stubs[key] == false
+                m.errors.stub(:empty?) { false }
+              end
+            end
           end
+          m.__send__(:__mock_proxy).instance_eval(<<-CODE, __FILE__, __LINE__)
+            def @object.is_a?(other)
+              #{model_class}.ancestors.include?(other)
+            end
+            def @object.kind_of?(other)
+              #{model_class}.ancestors.include?(other)
+            end
+            def @object.instance_of?(other)
+              other == #{model_class}
+            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
+            end
+            def @object.class
+              #{model_class}
+            end
+            def @object.to_s
+              "#{model_class.name}_#{to_param}"
+            end
+          CODE
+          yield m if block_given?
         end
-        m.stub(:errors) { errors }
-        m.__send__(:__mock_proxy).instance_eval(<<-CODE, __FILE__, __LINE__)
-          def @object.is_a?(other)
-            #{model_class}.ancestors.include?(other)
-          end
-          def @object.kind_of?(other)
-            #{model_class}.ancestors.include?(other)
-          end
-          def @object.instance_of?(other)
-            other == #{model_class}
-          end
-          def @object.respond_to?(method_name)
-            #{model_class}.respond_to?(:column_names) && #{model_class}.column_names.include?(method_name.to_s) || super
-          end
-          def @object.class
-            #{model_class}
-          end
-          def @object.to_s
-            "#{model_class.name}_#{id}"
-          end
-        CODE
-        yield m if block_given?
-        m
       end
 
-      module ModelStubber
-        def connection
-          raise RSpec::Rails::IllegalDataAccessException.new("stubbed models are not allowed to access the database")
+      module ActiveModelStubExtensions
+        def as_new_record
+          self.stub(:persisted?)  { false }
+          self.stub(:id)          { nil }
+          self
         end
-        def new_record?
-          __send__(self.class.primary_key).nil?
+
+        def persisted?
+          true
         end
+      end
+
+      module ActiveRecordStubExtensions
         def as_new_record
           self.__send__("#{self.class.primary_key}=", nil)
-          self
+          super
+        end
+
+        def new_record?
+          !persisted?
+        end
+
+        def connection
+          raise RSpec::Rails::IllegalDataAccessException.new("stubbed models are not allowed to access the database")
         end
       end
 
@@ -121,46 +155,51 @@ EOM
       #   stub_model(Model, hash_of_stubs)
       #   stub_model(Model, instance_variable_name, hash_of_stubs)
       #
-      # Creates an instance of +Model+ that is prohibited from accessing the
-      # database*. 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 framework.
+      # 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*.
       #
-      # <tt>new_record?</tt> is overridden to return the result of id.nil?
-      # This means that by default new_record? will return false. If  you want
+      # 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
+      # framework.
+      #
+      # <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
       # set the id to nil. You can also explicitly set :id => nil, in which
-      # case new_record? will return true, 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.
       #
-      # == Database Independence
-      #
-      # +stub_model+ does not make your examples entirely
-      # database-independent. It does not stop the model class itself from
-      # loading up its columns from the database. It just prevents data access
-      # from the object itself. To completely decouple from the database, take
-      # a look at libraries like unit_record or NullDB.
-      #
       # == Examples
       #
       #   stub_model(Person)
       #   stub_model(Person).as_new_record
-      #   stub_model(Person, :id => 37)
+      #   stub_model(Person, :to_param => 37)
       #   stub_model(Person) do |person|
       #     person.first_name = "David"
       #   end
       def stub_model(model_class, stubs={})
-        primary_key = model_class.primary_key.to_sym
-        stubs = {primary_key => next_id}.merge(stubs)
         model_class.new.tap do |m|
-          m.__send__("#{primary_key}=", stubs.delete(primary_key))
-          m.extend ModelStubber
+          m.extend ActiveModelStubExtensions
+          if defined?(ActiveRecord) && model_class < ActiveRecord::Base
+            m.extend ActiveRecordStubExtensions
+            primary_key = model_class.primary_key.to_sym
+            stubs = stubs.reverse_merge(primary_key => next_id)
+            stubs = stubs.reverse_merge(:persisted? => !!stubs[primary_key])
+          else
+            stubs = stubs.reverse_merge(:id => next_id)
+            stubs = stubs.reverse_merge(:persisted? => !!stubs[:id])
+          end
+          stubs = stubs.reverse_merge(:blank? => false)
+          stubs.each do |k,v|
+            m.__send__("#{k}=", stubs.delete(k)) if m.respond_to?("#{k}=")
+          end
           m.stub(stubs)
           yield m if block_given?
         end

data/lib/rspec/rails/module_inclusion.rb

@@ -1,7 +1,24 @@
 module RSpec::Rails
   module ModuleInclusion
+    # Deprecated as of rspec-rails-2.4
+    # Will be removed from rspec-rails-3.0
+    #
+    # This was never intended to be a public API and is no longer needed
+    # internally. As it happens, there are a few blog posts citing its use, so
+    # I'm leaving it here, but deprecated.
     def include_self_when_dir_matches(*path_parts)
+        instead = <<-INSTEAD
+
+
+    RSpec.configure do |c|
+      c.include self, :example_group => {
+        :file_path => /#{path_parts.join('\/')}/
+      }
+    end
+
+INSTEAD
       lambda do |c|
+        RSpec.deprecate('include_self_when_dir_matches', instead, 'rails-3.0')
         c.include self, :example_group => {
           :file_path => Regexp.compile(path_parts.join('[\\\/]'))
         }

data/lib/rspec/rails/tasks/rspec.rake

@@ -41,7 +41,7 @@ namespace :spec do
     ::CodeStatistics::TEST_TYPES << "Controller specs" if File.exist?('spec/controllers')
     ::CodeStatistics::TEST_TYPES << "Helper specs" if File.exist?('spec/helpers')
     ::CodeStatistics::TEST_TYPES << "Library specs" if File.exist?('spec/lib')
-    ::CodeStatistics::TEST_TYPES << "Mailer specs" if File.exist?('spec/mailer')
+    ::CodeStatistics::TEST_TYPES << "Mailer specs" if File.exist?('spec/mailers')
     ::CodeStatistics::TEST_TYPES << "Routing specs" if File.exist?('spec/routing')
     ::CodeStatistics::TEST_TYPES << "Request specs" if File.exist?('spec/requests')
   end