rspec-rails 1.3.2 → 6.1.2

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

@@ -1,285 +0,0 @@
-module Spec
-  module Rails
-    module Example
-      # Controller Examples live in $RAILS_ROOT/spec/controllers/.
-      #
-      # Controller Examples use Spec::Rails::Example::ControllerExampleGroup,
-      # which supports running specs for Controllers in two modes, which
-      # represent the tension between the more granular testing common in TDD
-      # and the more high level testing built into rails. BDD sits somewhere
-      # in between: we want to a balance between specs that are close enough
-      # to the code to enable quick fault isolation and far enough away from
-      # the code to enable refactoring with minimal changes to the existing
-      # specs.
-      #
-      # == Isolation mode (default)
-      #
-      # No dependencies on views because none are ever rendered. The benefit
-      # of this mode is that can spec the controller completely independent of
-      # the view, allowing that responsibility to be handled later, or by
-      # somebody else. Combined w/ separate view specs, this also provides
-      # better fault isolation.
-      #
-      # == Integration mode
-      #
-      # To run in this mode, include the +integrate_views+ declaration
-      # in your controller context:
-      #
-      #   describe ThingController do
-      #     integrate_views
-      #     ...
-      #
-      # In this mode, controller specs are run in the same way that rails
-      # functional tests run - one set of tests for both the controllers and
-      # the views. The benefit of this approach is that you get wider coverage
-      # from each spec. Experienced rails developers may find this an easier
-      # approach to begin with, however we encourage you to explore using the
-      # isolation mode and revel in its benefits.
-      #
-      # == Expecting Errors
-      #
-      # Rspec on Rails will raise errors that occur in controller actions and
-      # are not rescued or handeled with rescue_from.
-      #
-      class ControllerExampleGroup < FunctionalExampleGroup
-        class << self
-
-          # Use integrate_views to instruct RSpec to render views in
-          # your controller examples in Integration mode.
-          #
-          #   describe ThingController do
-          #     integrate_views
-          #     ...
-          #
-          # See Spec::Rails::Example::ControllerExampleGroup for more
-          # information about Integration and Isolation modes.
-          def integrate_views(integrate_views = true)
-            @integrate_views = integrate_views
-          end
-
-          def integrate_views? # :nodoc:
-            @integrate_views
-          end
-
-          def inherited(klass) # :nodoc:
-            klass.integrate_views(integrate_views?)
-            klass.subject { controller }
-            super
-          end
-
-          def set_description(*args) # :nodoc:
-            super
-            if described_class && described_class.ancestors.include?(ActionController::Base)
-              controller_klass = if superclass.controller_class.ancestors.include?(ActionController::Base)
-                superclass.controller_class
-              else
-                described_class
-              end
-              tests controller_klass
-            end
-          end
-
-          # When you don't pass a controller to describe, like this:
-          #
-          #   describe ThingsController do
-          #
-          # ... then you must provide a controller_name within the context of
-          # your controller specs:
-          #
-          #   describe "ThingController" do
-          #     controller_name :thing
-          #     ...
-          def controller_name(name)
-            tests "#{name}_controller".camelize.constantize
-          end
-        end
-
-        before(:each) do
-          # Some Rails apps explicitly disable ActionMailer in environment.rb
-          if defined?(ActionMailer)
-            @deliveries = []
-            ActionMailer::Base.deliveries = @deliveries
-          end
-
-          unless @controller.class.ancestors.include?(ActionController::Base)
-            Spec::Expectations.fail_with <<-MESSAGE
-Controller specs need to know what controller is being specified. You can
-indicate this by passing the controller to describe():
-
-  describe MyController do
-
-or by declaring the controller's name
-
-  describe "a MyController" do
-    controller_name :my #invokes the MyController
-end
-MESSAGE
-          end
-          @controller.extend ControllerInstanceMethods
-          @controller.integrate_views! if integrate_views?
-          @controller.session = session
-        end
-
-        attr_reader :response, :request, :controller
-
-        def integrate_views?
-          @integrate_views || self.class.integrate_views?
-        end
-
-        # Bypasses any error rescues defined with rescue_from. Useful
-        # in cases in which you want to specify errors coming out of
-        # actions that might be caught by a rescue_from clause that is
-        # specified separately.
-        #
-        # Note that this will override the effect of rescue_action_in_public
-        def bypass_rescue
-          if ::Rails::VERSION::STRING >= '2.2'
-            def controller.rescue_action(exception)
-              raise exception
-            end
-          else
-            def controller.rescue_action_with_handler(exception)
-              raise exception
-            end
-          end
-        end
-
-      protected
-
-        def _assigns_hash_proxy
-          @_assigns_hash_proxy ||= AssignsHashProxy.new(self) {@response.template}
-        end
-
-      private
-
-        module TemplateIsolationExtensions
-          def file_exists?(ignore); true; end
-
-          def render_file(*args)
-            @first_render ||= args[0] unless args[0] =~ /^layouts/
-          end
-
-          # Rails 2.2
-          def _pick_template(*args)
-            @_first_render ||= args[0] unless args[0] =~ /^layouts/
-            PickedTemplate.new
-          end
-
-          def __action_exists?(params)
-            controller.respond_to? params[:action]
-          end
-
-          def __template_exists?(args)
-            self.view_paths.respond_to?(:find_template) ?
-              self.view_paths.find_template(args[0][:file], template_format) :
-              false
-          end
-
-          def render(*args)
-            if ::Rails::VERSION::STRING >= "2.1"
-              return super unless __action_exists?(params) || __template_exists?(args)
-            end
-            if file = args.last[:file].instance_eval{@template_path}
-              record_render :file => file
-            elsif args.last[:inline]
-              super
-            elsif @_rendered
-              record_render(args[0])
-            else
-              super
-            end
-          end
-
-        private
-
-          def record_render(opts)
-            return unless @_rendered
-            @_rendered[:template] ||= opts[:file] if opts[:file]
-            @_rendered[:partials][opts[:partial]] += 1 if opts[:partial]
-          end
-
-          # Returned by _pick_template when running controller examples in isolation mode.
-          class PickedTemplate
-            # Do nothing when running controller examples in isolation mode.
-            def render_template(*ignore_args); end
-            # Do nothing when running controller examples in isolation mode.
-            def render_partial(*ignore_args);  end
-          end
-        end
-
-        module ControllerInstanceMethods # :nodoc:
-          include Spec::Rails::Example::RenderObserver
-
-          # === render(options = nil, extra_options={}, &block)
-          #
-          # This gets added to the controller's singleton meta class,
-          # allowing Controller Examples to run in two modes, freely switching
-          # from example group to example group.
-          def render(options=nil, extra_options={}, &block)
-            unless block_given?
-              unless integrate_views?
-                @template.extend TemplateIsolationExtensions
-              end
-            end
-
-            if matching_message_expectation_exists(options)
-              render_proxy.render(options, &block)
-              @performed_render = true
-            else
-              if matching_stub_exists(options)
-                @performed_render = true
-              else
-                if ::Rails::VERSION::STRING > '2.1'
-                  super(options, extra_options, &block)
-                else
-                  super(options, &block)
-                end
-              end
-            end
-          end
-
-          # Rails 2.3
-          def default_template(action_name = self.action_name)
-            if integrate_views?
-              super
-            else
-              begin
-                super
-              rescue ActionView::MissingTemplate
-                "#{self.class.name.sub(/Controller$/,'').underscore}/#{action_name}"
-              end
-            end
-          end
-
-          def response(&block)
-            # NOTE - we're setting @update for the assert_select_spec - kinda weird, huh?
-            @update = block
-            super
-          end
-
-          def integrate_views!
-            @integrate_views = true
-          end
-
-        private
-
-          def integrate_views?
-            @integrate_views
-          end
-
-          def matching_message_expectation_exists(options)
-            render_proxy.__send__(:__mock_proxy).__send__(:find_matching_expectation, :render, options)
-          end
-
-          def matching_stub_exists(options)
-            render_proxy.__send__(:__mock_proxy).__send__(:find_matching_method_stub, :render, options)
-          end
-
-        end
-
-        Spec::Example::ExampleGroupFactory.register(:controller, self)
-
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-require 'action_controller/cookies'
-
-module Spec
-  module Rails
-    module Example
-      class CookiesProxy
-        def initialize(example)
-          @example = example
-        end
-      
-        def[]=(name, value)
-          if ::Rails::VERSION::STRING >= '2.3'
-            @example.request.cookies[name.to_s] = value
-          else
-            @example.request.cookies[name.to_s] = CGI::Cookie.new(name.to_s, value)
-          end
-        end
-        
-        def [](name)
-          @example.response.cookies[name.to_s]
-        end
-      
-        def delete(name)
-          @example.response.cookies.delete(name.to_s)
-        end
-      end
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-require 'action_controller/test_case'
-
-module Spec
-  module Rails
-    module Example
-      class FunctionalExampleGroup < ActionController::TestCase
-        def setup
-          # no-op to override AC::TC's setup w/ conflicts with the before(:each) below
-        end
-
-        attr_reader :request, :response
-
-        # The params hash accessed within a view or helper. Use this before
-        # rendering a view or calling a helper to provide data used by the
-        # view or helper.
-        #
-        # == Examples
-        #   # in a view spec
-        #   params[:name] = "David"
-        #   render
-        #   response.should have_tag("div.name","David")
-        #    
-        #   # in a helper spec
-        #   params[:first_name] = "David"
-        #   params[:last_name] = "Chelimsky"
-        #   helper.full_name.should == "David Chelimsky"
-        def params
-          request.parameters
-        end
-
-        # Provides access to the flash hash. Use this after rendering a
-        # view, calling a helper or calling a controller action.
-        #
-        # == Examples
-        #   post :create
-        #   flash[:notice].should == "Success!"
-        def flash
-          @controller.__send__ :flash
-        end
-
-        # Provides access to the session hash. Use this before or after
-        # rendering a view, calling a helper or calling a controller action.
-        def session
-          request.session
-        end
-        
-        # Overrides the <tt>cookies()</tt> method in
-        # ActionController::TestResponseBehaviour, returning a proxy that
-        # accesses the requests cookies when setting a cookie and the
-        # responses cookies when reading one. This allows you to set and read
-        # cookies in examples using the same API with which you set and read
-        # them in controllers.
-        #
-        # == Examples (Rails 2.0 > 2.2)
-        #
-        #   cookies[:user_id] = {:value => '1234', :expires => 1.minute.ago}
-        #   get :index
-        #   response.should be_redirect
-        #
-        # == Examples (Rails 2.3)
-        #
-        # Rails 2.3 changes the way cookies are made available to functional
-        # tests (and therefore rspec controller specs), only making single
-        # values available with no access to other aspects of the cookie. This
-        # is backwards-incompatible, so you have to change your examples to
-        # look like this:
-        #
-        #   cookies[:foo] = 'bar'
-        #   get :index
-        #   cookies[:foo].should == 'bar'
-        def cookies
-          @cookies ||= Spec::Rails::Example::CookiesProxy.new(self)
-        end
-        
-        alias_method :orig_assigns, :assigns
-
-        # :call-seq:
-        #   assigns()
-        #
-        # Hash of instance variables to values that are made available to
-        # views. == Examples
-        #
-        #   #in thing_controller.rb
-        #   def new
-        #     @thing = Thing.new
-        #   end
-        #
-        #   #in thing_controller_spec
-        #   get 'new'
-        #   assigns[:registration].should == Thing.new
-        #--
-        # NOTE - Even though docs only use assigns[:key] format, this supports
-        # assigns(:key) for backwards compatibility.
-        #++
-        def assigns(key = nil)
-          if key.nil?
-            _assigns_hash_proxy
-          else
-            _assigns_hash_proxy[key]
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,153 +0,0 @@
-module Spec
-  module Rails
-    module Example
-      class HelperExampleGroupController < ApplicationController #:nodoc:
-        attr_accessor :request, :url
-      end
-
-      # Helper Specs live in $RAILS_ROOT/spec/helpers/.
-      #
-      # Helper Specs use Spec::Rails::Example::HelperExampleGroup, which allows you to
-      # include your Helper directly in the context and write specs directly
-      # against its methods.
-      #
-      # HelperExampleGroup also includes the standard lot of ActionView::Helpers in case your
-      # helpers rely on any of those.
-      #
-      # == Example
-      #
-      #   module ThingHelper
-      #     def number_of_things
-      #       Thing.count
-      #     end
-      #   end
-      #
-      #   describe "ThingHelper example_group" do
-      #     include ThingHelper
-      #     it "should tell you the number of things" do
-      #       Thing.should_receive(:count).and_return(37)
-      #       number_of_things.should == 37
-      #     end
-      #   end
-      class HelperExampleGroup < FunctionalExampleGroup
-        tests HelperExampleGroupController
-        attr_accessor :output_buffer
-        
-        class HelperObject < ActionView::Base
-          def initialize(*args)
-            @template = self
-            super
-          end
-          def protect_against_forgery?
-            false
-          end
-          
-          attr_writer :session, :request, :flash, :params, :controller
-          
-          private
-            attr_reader :session, :request, :flash, :params, :controller
-        end
-        
-        class << self
-          # The helper name....
-          def helper_name(name=nil)
-            @helper_being_described = "#{name}_helper".camelize.constantize
-            send :include, @helper_being_described
-          end
-          
-          def helper
-            @helper_object ||= returning HelperObject.new do |helper_object|
-              if @helper_being_described.nil?
-                if described_type.class == Module
-                  helper_object.extend described_type
-                end
-              else
-                helper_object.extend @helper_being_described
-              end
-            end
-          end
-        end
-        
-        # Returns an instance of ActionView::Base with the helper being spec'd
-        # included.
-        #
-        # == Example
-        #
-        #   describe PersonHelper do
-        #     it "should write a link to person with the name" do
-        #       assigns[:person] = mock_model(Person, :full_name => "Full Name", :id => 37, :new_record? => false)
-        #       helper.link_to_person.should == %{<a href="/people/37">Full Name</a>}
-        #     end
-        #   end
-        #
-        #   module PersonHelper
-        #     def link_to_person
-        #       link_to person.full_name, url_for(person)
-        #     end
-        #   end
-        #
-        def helper
-          self.class.helper
-        end
-        
-        def orig_assigns
-          helper.assigns
-        end
-        
-        # Reverse the load order so that custom helpers which are defined last
-        # are also loaded last.
-        ActionView::Base.included_modules.reverse.each do |mod|
-          include mod if mod.parents.include?(ActionView::Helpers)
-        end
-        
-        before(:each) do
-          @controller.request = @request
-          @controller.url = ActionController::UrlRewriter.new @request, {} # url_for
-
-          @flash = ActionController::Flash::FlashHash.new
-          session['flash'] = @flash
-          
-          @output_buffer = ""
-          @template = helper
-          ActionView::Helpers::AssetTagHelper::reset_javascript_include_default
-          
-          helper.session = session
-          helper.request = @request
-          helper.flash = flash
-          helper.params = params
-          helper.controller = @controller
-        end
-
-        def flash
-          @flash
-        end
-
-        def eval_erb(text)
-          erb_args = [text]
-          if helper.respond_to?(:output_buffer)
-            erb_args += [nil, nil, '@output_buffer']
-          end
-          
-          helper.instance_eval do
-            ERB.new(*erb_args).result(binding)
-          end
-        end
-
-        # TODO: BT - Helper Examples should proxy method_missing to a Rails View instance.
-        # When that is done, remove this method
-        def protect_against_forgery?
-          false
-        end
-
-        Spec::Example::ExampleGroupFactory.register(:helper, self)
-
-      protected
-
-        def _assigns_hash_proxy
-          @_assigns_hash_proxy ||= AssignsHashProxy.new(self) {helper}
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-class ActionController::IntegrationTest
-  alias_method :orig_initialize, :initialize
-  def initialize(*args)
-    super
-  end
-end
-
-module Spec
-  module Rails
-    module Example
-      class IntegrationExampleGroup < ActionController::IntegrationTest
-        Spec::Example::ExampleGroupFactory.register(:integration, self)
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Spec
-  module Rails
-    module Example
-      # Model examples live in $RAILS_ROOT/spec/models/.
-      #
-      # Model examples use Spec::Rails::Example::ModelExampleGroup, which
-      # provides support for fixtures and some custom expectations via extensions
-      # to ActiveRecord::Base.
-      base = defined?(ActiveRecord::TestCase) ? ActiveRecord::TestCase : ActiveSupport::TestCase
-      class ModelExampleGroup < base
-        Spec::Example::ExampleGroupFactory.register(:model, self)
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-require 'spec/mocks/framework'
-
-module Spec
-  module Rails
-    module Example
-      # Extends the #should_receive, #should_not_receive and #stub! methods in rspec's
-      # mocking framework to handle #render calls to controller in controller examples
-      # and template and view examples
-      module RenderObserver
-
-        def verify_rendered # :nodoc:
-          render_proxy.rspec_verify
-        end
-  
-        def unregister_verify_after_each #:nodoc:
-          proc = verify_rendered_proc
-          Spec::Example::ExampleGroup.remove_after(:each, &proc)
-        end
-
-        def should_receive(*args)
-          if args[0] == :render
-            register_verify_after_each
-            render_proxy.should_receive(:render, :expected_from => caller(1)[0])
-          else
-            super
-          end
-        end
-        
-        def should_not_receive(*args)
-          if args[0] == :render
-            register_verify_after_each
-            render_proxy.should_not_receive(:render)
-          else
-            super
-          end
-        end
-        
-        def stub(*args)
-          if args[0] == :render
-            register_verify_after_each
-            render_proxy.stub(args.first, :expected_from => caller(1)[0])
-          else
-            super
-          end
-        end
-        
-        # FIXME - for some reason, neither alias nor alias_method are working
-        # as expected in the else branch, so this is a duplicate of stub()
-        # above. Could delegate, but then we'd run into craziness handling
-        # :expected_from. This will have to do for the moment.
-        def stub!(*args)
-          if args[0] == :render
-            register_verify_after_each
-            render_proxy.stub!(args.first, :expected_from => caller(1)[0])
-          else
-            super
-          end
-        end
-        
-        def verify_rendered_proc #:nodoc:
-          template = self
-          @verify_rendered_proc ||= Proc.new do
-            template.verify_rendered
-            template.unregister_verify_after_each
-          end
-        end
-
-        def register_verify_after_each #:nodoc:
-          proc = verify_rendered_proc
-          Spec::Example::ExampleGroup.after(:each, &proc)
-        end
-  
-        def render_proxy #:nodoc:
-          @render_proxy ||= Spec::Mocks::Mock.new("render_proxy")
-        end
-  
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module Spec
-  module Rails
-    module Example
-
-      class RoutingExampleGroup < ActionController::TestCase
-        tests Class.new(ActionController::Base)
-        
-        Spec::Example::ExampleGroupFactory.register(:routing, self)
-      end
-
-    end
-  end
-end