rspec-rails 1.3.4 → 2.0.0.a2

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
-            HelperObject.new.tap 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
-          @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,16 +0,0 @@
-module Spec
-  module Rails
-    module Example
-
-      class RoutingExampleGroup < ActionController::TestCase
-        class RoutingController < ActionController::Base
-        end
-        
-        tests RoutingController
-        
-        Spec::Example::ExampleGroupFactory.register(:routing, self)
-      end
-
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-require 'rack/utils'
-
-module Spec
-  module Rails
-    module Example
-      module RoutingHelpers
-        
-        class RouteFor
-          def initialize(example, options)
-            @example, @options = example, options
-          end
-
-          def ==(expected)
-            if Hash === expected
-              path, querystring = expected[:path].split('?')
-              path_string = path
-              path = expected.merge(:path => path)
-            else
-              path, querystring = expected.split('?')
-              path_string = path
-              path = { :path => path, :method => :get }
-            end
-            params = querystring.blank? ? {} : Rack::Utils.parse_query(querystring).symbolize_keys!
-            begin
-              @example.assert_routing(path, @options, {}, params)
-              true
-            rescue ActionController::RoutingError, ::Test::Unit::AssertionFailedError => e
-              raise e.class, "#{e}\nIf you're expecting this failure, we suggest {:#{path[:method]}=>\"#{path[:path]}\"}.should_not be_routable"
-            end
-          end
-        end
-        # Uses ActionController::Routing::Routes to generate
-        # the correct route for a given set of options.
-        # == Examples
-        #   route_for(:controller => 'registrations', :action => 'edit', :id => '1')
-        #     => '/registrations/1/edit'
-        #   route_for(:controller => 'registrations', :action => 'create')
-        #     => {:path => "/registrations", :method => :post}
-        def route_for(options)
-          RouteFor.new(self, options)
-        end
-
-        # Uses ActionController::Routing::Routes to parse
-        # an incoming path so the parameters it generates can be checked
-        #
-        # Note that this method is obsoleted by the route_to matcher.
-        # == Example
-        #   params_from(:get, '/registrations/1/edit')
-        #     => :controller => 'registrations', :action => 'edit', :id => '1'
-        def params_from(method, path)
-          ensure_that_routes_are_loaded
-          path, querystring = path.split('?')
-          params = ActionController::Routing::Routes.recognize_path(path, :method => method)
-          querystring.blank? ? params : params.merge(Rack::Utils.parse_query(querystring).symbolize_keys!)
-        end
-
-      private
-
-        def ensure_that_routes_are_loaded
-          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
-        end
-
-      end
-    end
-  end
-end