actionpack 1.13.6 → 2.0.0

data/lib/action_controller/helpers.rb

@@ -1,5 +1,7 @@
 module ActionController #:nodoc:
   module Helpers #:nodoc:
+    HELPERS_DIR = (defined?(RAILS_ROOT) ? "#{RAILS_ROOT}/app/helpers" : "app/helpers")
+
     def self.included(base)
       # Initialize the base module to aggregate its helpers.
       base.class_inheritable_accessor :master_helper_module
@@ -16,64 +18,120 @@ module ActionController #:nodoc:
       end
     end
 
-    # The template helpers serve to relieve the templates from including the same inline code again and again. It's a
-    # set of standardized methods for working with forms (FormHelper), dates (DateHelper), texts (TextHelper), and 
-    # Active Records (ActiveRecordHelper) that's available to all templates by default.
+    # The Rails framework provides a large number of helpers for working with +assets+, +dates+, +forms+, 
+    # +numbers+ and +ActiveRecord+ objects, to name a few. These helpers are available to all templates
+    # by default.
     #
-    # It's also really easy to make your own helpers and it's much encouraged to keep the template files free
-    # from complicated logic. It's even encouraged to bundle common compositions of methods from other helpers 
-    # (often the common helpers) as they're used by the specific application.
+    # In addition to using the standard template helpers provided in the Rails framework, creating custom helpers to
+    # extract complicated logic or reusable functionality is strongly encouraged.  By default, the controller will 
+    # include a helper whose name matches that of the controller, e.g., <tt>MyController</tt> will automatically
+    # include <tt>MyHelper</tt>.
     # 
-    #   module MyHelper
-    #     def hello_world() "hello world" end
+    # Additional helpers can be specified using the +helper+ class method in <tt>ActionController::Base</tt> or any
+    # controller which inherits from it.
+    #
+    # ==== Examples
+    # The +to_s+ method from the +Time+ class can be wrapped in a helper method to display a custom message if 
+    # the Time object is blank:
+    #
+    #   module FormattedTimeHelper
+    #     def format_time(time, format=:long, blank_message="&nbsp;")
+    #       time.blank? ? blank_message : time.to_s(format)
+    #     end
     #   end
-    # 
-    # MyHelper can now be included in a controller, like this:
-    # 
-    #   class MyController < ActionController::Base
-    #     helper :my_helper
+    #
+    # +FormattedTimeHelper+ can now be included in a controller, using the +helper+ class method:
+    #
+    #   class EventsController < ActionController::Base
+    #     helper FormattedTimeHelper
+    #     def index
+    #       @events = Event.find(:all)
+    #     end
     #   end
-    # 
-    # ...and, same as above, used in any template rendered from MyController, like this:
-    # 
-    # Let's hear what the helper has to say: <tt><%= hello_world %></tt>
+    #
+    # Then, in any view rendered by <tt>EventController</tt>, the <tt>format_time</tt> method can be called:
+    #
+    #   <% @events.each do |event| -%>
+    #     <p>
+    #       <% format_time(event.time, :short, "N/A") %> | <%= event.name %> 
+    #     </p>
+    #   <% end -%>
+    #
+    # Finally, assuming we have two event instances, one which has a time and one which does not, 
+    # the output might look like this:
+    #
+    #   23 Aug 11:30 | Carolina Railhawks Soccer Match 
+    #   N/A | Carolina Railhaws Training Workshop
+    #
     module ClassMethods
       # Makes all the (instance) methods in the helper module available to templates rendered through this controller.
-      # See ActionView::Helpers (link:classes/ActionView/Helpers.html) for more about making your own helper modules 
+      # See ActionView::Helpers (link:classes/ActionView/Helpers.html) for more about making your own helper modules
       # available to the templates.
       def add_template_helper(helper_module) #:nodoc:
-        master_helper_module.send(:include, helper_module)
+        master_helper_module.module_eval { include helper_module }
       end
 
-      # Declare a helper:
-      #   helper :foo
-      # requires 'foo_helper' and includes FooHelper in the template class.
-      #   helper FooHelper
-      # includes FooHelper in the template class.
-      #   helper { def foo() "#{bar} is the very best" end }
-      # evaluates the block in the template class, adding method #foo.
+      # The +helper+ class method can take a series of helper module names, a block, or both.
+      #
+      # * <tt>*args</tt>: One or more +Modules+, +Strings+ or +Symbols+, or the special symbol <tt>:all</tt>.
+      # * <tt>&block</tt>: A block defining helper methods.
+      # 
+      # ==== Examples
+      # When the argument is a +String+ or +Symbol+, the method will provide the "_helper" suffix, require the file 
+      # and include the module in the template class.  The second form illustrates how to include custom helpers 
+      # when working with namespaced controllers, or other cases where the file containing the helper definition is not
+      # in one of Rails' standard load paths:
+      #   helper :foo             # => requires 'foo_helper' and includes FooHelper
+      #   helper 'resources/foo'  # => requires 'resources/foo_helper' and includes Resources::FooHelper
+      #
+      # When the argument is a +Module+, it will be included directly in the template class.
+      #   helper FooHelper # => includes FooHelper
+      #
+      # When the argument is the symbol <tt>:all</tt>, the controller will include all helpers from 
+      # <tt>app/helpers/**/*.rb</tt> under +RAILS_ROOT+.
+      #   helper :all
+      #
+      # Additionally, the +helper+ class method can receive and evaluate a block, making the methods defined available 
+      # to the template.
+      #   # One line
+      #   helper { def hello() "Hello, world!" end }
+      #   # Multi-line
+      #   helper do
+      #     def foo(bar) 
+      #       "#{bar} is the very best" 
+      #     end
+      #   end
+      # 
+      # Finally, all the above styles can be mixed together, and the +helper+ method can be invoked with a mix of
+      # +symbols+, +strings+, +modules+ and blocks.
       #   helper(:three, BlindHelper) { def mice() 'mice' end }
-      # does all three.
+      #
       def helper(*args, &block)
         args.flatten.each do |arg|
           case arg
             when Module
               add_template_helper(arg)
+            when :all
+              helper(all_application_helpers)
             when String, Symbol
               file_name  = arg.to_s.underscore + '_helper'
               class_name = file_name.camelize
-                
+
               begin
                 require_dependency(file_name)
               rescue LoadError => load_error
                 requiree = / -- (.*?)(\.rb)?$/.match(load_error).to_a[1]
-                msg = (requiree == file_name) ? "Missing helper file helpers/#{file_name}.rb" : "Can't load file: #{requiree}"
-                raise LoadError.new(msg).copy_blame!(load_error)
+                if requiree == file_name
+                  msg = "Missing helper file helpers/#{file_name}.rb"
+                  raise LoadError.new(msg).copy_blame!(load_error)
+                else
+                  raise
+                end
               end
 
               add_template_helper(class_name.constantize)
             else
-              raise ArgumentError, 'helper expects String, Symbol, or Module argument'
+              raise ArgumentError, "helper expects String, Symbol, or Module argument (was: #{args.inspect})"
           end
         end
 
@@ -81,10 +139,14 @@ module ActionController #:nodoc:
         master_helper_module.module_eval(&block) if block_given?
       end
 
-      # Declare a controller method as a helper.  For example,
-      #   helper_method :link_to
-      #   def link_to(name, options) ... end
-      # makes the link_to controller method available in the view.
+      # Declare a controller method as a helper. For example, the following
+      # makes the +current_user+ controller method available to the view:
+      #   class ApplicationController < ActionController::Base
+      #     helper_method :current_user
+      #     def current_user
+      #       @current_user ||= User.find(session[:user])
+      #     end
+      #   end
       def helper_method(*methods)
         methods.flatten.each do |method|
           master_helper_module.module_eval <<-end_eval
@@ -95,37 +157,49 @@ module ActionController #:nodoc:
         end
       end
 
-      # Declare a controller attribute as a helper.  For example,
+      # Declares helper accessors for controller attributes. For example, the
+      # following adds new +name+ and <tt>name=</tt> instance methods to a
+      # controller and makes them available to the view:
       #   helper_attr :name
       #   attr_accessor :name
-      # makes the name and name= controller methods available in the view.
-      # The is a convenience wrapper for helper_method.
       def helper_attr(*attrs)
         attrs.flatten.each { |attr| helper_method(attr, "#{attr}=") }
       end
 
-      private 
+
+      private
         def default_helper_module!
-          module_name = name.sub(/Controller$|$/, 'Helper')
-          module_path = module_name.split('::').map { |m| m.underscore }.join('/')
-          require_dependency module_path
-          helper module_name.constantize
-        rescue LoadError
+          unless name.blank?
+            module_name = name.sub(/Controller$|$/, 'Helper')
+            module_path = module_name.split('::').map { |m| m.underscore }.join('/')
+            require_dependency module_path
+            helper module_name.constantize
+          end
+        rescue MissingSourceFile => e
+          raise unless e.is_missing? module_path
           logger.debug("#{name}: missing default helper path #{module_path}") if logger
-        rescue NameError
+        rescue NameError => e
+          raise unless e.missing_name? module_name
           logger.debug("#{name}: missing default helper module #{module_name}") if logger
         end
 
         def inherited_with_helper(child)
           inherited_without_helper(child)
+
           begin
             child.master_helper_module = Module.new
-            child.master_helper_module.send :include, master_helper_module
-            child.send :default_helper_module!
+            child.master_helper_module.send! :include, master_helper_module
+            child.send! :default_helper_module!
           rescue MissingSourceFile => e
             raise unless e.is_missing?("helpers/#{child.controller_path}_helper")
           end
         end
+
+        # Extract helper names from files in app/helpers/**/*.rb
+        def all_application_helpers
+          extract = /^#{Regexp.quote(HELPERS_DIR)}\/?(.*)_helper.rb$/
+          Dir["#{HELPERS_DIR}/**/*_helper.rb"].map { |file| file.sub extract, '\1' }
+        end
     end
   end
 end

data/lib/action_controller/http_authentication.rb

@@ -0,0 +1,126 @@
+require 'base64'
+
+module ActionController
+  module HttpAuthentication
+    # Makes it dead easy to do HTTP Basic authentication.
+    # 
+    # Simple Basic example:
+    # 
+    #   class PostsController < ApplicationController
+    #     USER_NAME, PASSWORD = "dhh", "secret"
+    #   
+    #     before_filter :authenticate, :except => [ :index ]
+    #   
+    #     def index
+    #       render :text => "Everyone can see me!"
+    #     end
+    #   
+    #     def edit
+    #       render :text => "I'm only accessible if you know the password"
+    #     end
+    #   
+    #     private
+    #       def authenticate
+    #         authenticate_or_request_with_http_basic do |user_name, password| 
+    #           user_name == USER_NAME && password == PASSWORD
+    #         end
+    #       end
+    #   end
+    # 
+    # 
+    # Here is a more advanced Basic example where only Atom feeds and the XML API is protected by HTTP authentication, 
+    # the regular HTML interface is protected by a session approach:
+    # 
+    #   class ApplicationController < ActionController::Base
+    #     before_filter :set_account, :authenticate
+    #   
+    #     protected
+    #       def set_account
+    #         @account = Account.find_by_url_name(request.subdomains.first)
+    #       end
+    #   
+    #       def authenticate
+    #         case request.format
+    #         when Mime::XML, Mime::ATOM
+    #           if user = authenticate_with_http_basic { |u, p| @account.users.authenticate(u, p) }
+    #             @current_user = user
+    #           else
+    #             request_http_basic_authentication
+    #           end
+    #         else
+    #           if session_authenticated?
+    #             @current_user = @account.users.find(session[:authenticated][:user_id])
+    #           else
+    #             redirect_to(login_url) and return false
+    #           end
+    #         end
+    #       end
+    #   end
+    # 
+    # 
+    # In your integration tests, you can do something like this:
+    # 
+    #   def test_access_granted_from_xml
+    #     get(
+    #       "/notes/1.xml", nil, 
+    #       :authorization => ActionController::HttpAuthentication::Basic.encode_credentials(users(:dhh).name, users(:dhh).password)
+    #     )
+    # 
+    #     assert_equal 200, status
+    #   end
+    #  
+    #  
+    # On shared hosts, Apache sometimes doesn't pass authentication headers to
+    # FCGI instances. If your environment matches this description and you cannot
+    # authenticate, try this rule in public/.htaccess (replace the plain one):
+    # 
+    #   RewriteRule ^(.*)$ dispatch.fcgi [E=X-HTTP_AUTHORIZATION:%{HTTP:Authorization},QSA,L]
+    module Basic
+      extend self
+
+      module ControllerMethods
+        def authenticate_or_request_with_http_basic(realm = "Application", &login_procedure)
+          authenticate_with_http_basic(&login_procedure) || request_http_basic_authentication(realm)
+        end
+
+        def authenticate_with_http_basic(&login_procedure)
+          HttpAuthentication::Basic.authenticate(self, &login_procedure)
+        end
+
+        def request_http_basic_authentication(realm = "Application")
+          HttpAuthentication::Basic.authentication_request(self, realm)
+        end
+      end
+
+      def authenticate(controller, &login_procedure)
+        unless authorization(controller.request).blank?
+          login_procedure.call(*user_name_and_password(controller.request))
+        end
+      end
+
+      def user_name_and_password(request)
+        decode_credentials(request).split(/:/, 2)
+      end
+  
+      def authorization(request)
+        request.env['HTTP_AUTHORIZATION']   ||
+        request.env['X-HTTP_AUTHORIZATION'] ||
+        request.env['X_HTTP_AUTHORIZATION'] ||
+        request.env['REDIRECT_X_HTTP_AUTHORIZATION']
+      end
+    
+      def decode_credentials(request)
+        Base64.decode64(authorization(request).split.last || '')
+      end
+
+      def encode_credentials(user_name, password)
+        "Basic #{Base64.encode64("#{user_name}:#{password}")}"
+      end
+
+      def authentication_request(controller, realm)
+        controller.headers["WWW-Authenticate"] = %(Basic realm="#{realm.gsub(/"/, "")}")
+        controller.send! :render, :text => "HTTP Basic: Access denied.\n", :status => :unauthorized
+      end
+    end
+  end
+end

data/lib/action_controller/integration.rb

@@ -51,7 +51,10 @@ module ActionController
       # A reference to the response instance used by the last request.
       attr_reader :response
 
-      # Create an initialize a new Session instance.
+      # A running counter of the number of requests processed.
+      attr_accessor :request_count
+
+      # Create and initialize a new +Session+ instance.
       def initialize
         reset!
       end
@@ -67,19 +70,20 @@ module ActionController
         @https = false
         @cookies = {}
         @controller = @request = @response = nil
+        @request_count = 0
 
         self.host        = "www.example.com"
         self.remote_addr = "127.0.0.1"
         self.accept      = "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5"
 
-        unless @named_routes_configured
+        unless defined? @named_routes_configured
           # install the named routes in this session instance.
           klass = class<<self; self; end
-          Routing::Routes.named_routes.install(klass)
+          Routing::Routes.install_helpers(klass)
 
           # the helpers are made protected by default--we make them public for
           # easier access during testing and troubleshooting.
-          klass.send(:public, *Routing::Routes.named_routes.helpers)
+          klass.module_eval { public *Routing::Routes.named_routes.helpers }
           @named_routes_configured = true
         end
       end
@@ -120,17 +124,18 @@ module ActionController
       # Performs a GET request, following any subsequent redirect. Note that
       # the redirects are followed until the response is not a redirect--this
       # means you may run into an infinite loop if your redirect loops back to
-      # itself.
-      def get_via_redirect(path, args={})
-        get path, args
+      # itself. Headers are treated in the same way as #get.
+      def get_via_redirect(path, args={}, headers = {})
+        get path, args, headers
         follow_redirect! while redirect?
         status
       end
 
       # Performs a POST request, following any subsequent redirect. This is
-      # vulnerable to infinite loops, the same as #get_via_redirect.
-      def post_via_redirect(path, args={})
-        post path, args
+      # vulnerable to infinite loops, the same as #get_via_redirect. Headers are
+      # treated in the same way as #get.
+      def post_via_redirect(path, args={}, headers = {})
+        post path, args, headers
         follow_redirect! while redirect?
         status
       end
@@ -148,27 +153,27 @@ module ActionController
       #
       # You can also perform POST, PUT, DELETE, and HEAD requests with #post,
       # #put, #delete, and #head.
-      def get(path, parameters=nil, headers=nil)
+      def get(path, parameters = nil, headers = nil)
         process :get, path, parameters, headers
       end
 
       # Performs a POST request with the given parameters. See get() for more details.
-      def post(path, parameters=nil, headers=nil)
+      def post(path, parameters = nil, headers = nil)
         process :post, path, parameters, headers
       end
 
       # Performs a PUT request with the given parameters. See get() for more details.
-      def put(path, parameters=nil, headers=nil)
+      def put(path, parameters = nil, headers = nil)
         process :put, path, parameters, headers
       end
 
       # Performs a DELETE request with the given parameters. See get() for more details.
-      def delete(path, parameters=nil, headers=nil)
+      def delete(path, parameters = nil, headers = nil)
         process :delete, path, parameters, headers
       end
 
       # Performs a HEAD request with the given parameters. See get() for more details.
-      def head(path, parameters=nil, headers=nil)
+      def head(path, parameters = nil, headers = nil)
         process :head, path, parameters, headers
       end
 
@@ -179,16 +184,7 @@ module ActionController
       # parameters are +nil+, a hash, or a url-encoded or multipart string;
       # the headers are a hash.  Keys are automatically upcased and prefixed
       # with 'HTTP_' if not already.
-      #
-      # This method used to omit the request_method parameter, assuming it
-      # was :post. This was deprecated in Rails 1.2.4. Always pass the request
-      # method as the first argument.
       def xml_http_request(request_method, path, parameters = nil, headers = nil)
-        unless request_method.is_a?(Symbol)
-          ActiveSupport::Deprecation.warn 'xml_http_request now takes the request_method (:get, :post, etc.) as the first argument. It used to assume :post, so add the :post argument to your existing method calls to silence this warning.'
-          request_method, path, parameters, headers = :post, request_method, path, parameters
-        end
-
         headers ||= {}
         headers['X-Requested-With'] = 'XMLHttpRequest'
         headers['Accept'] = 'text/javascript, text/html, application/xml, text/xml, */*'
@@ -204,15 +200,16 @@ module ActionController
       end
 
       private
-        class MockCGI < CGI #:nodoc:
+        class StubCGI < CGI #:nodoc:
           attr_accessor :stdinput, :stdoutput, :env_table
 
-          def initialize(env, input=nil)
+          def initialize(env, stdinput = nil)
             self.env_table = env
-            self.stdinput = StringIO.new(input || "")
             self.stdoutput = StringIO.new
 
-            super()
+            super
+
+            @stdinput = stdinput.is_a?(IO) ? stdinput : StringIO.new(stdinput || '')
           end
         end
 
@@ -226,7 +223,7 @@ module ActionController
         end
 
         # Performs the actual request.
-        def process(method, path, parameters=nil, headers=nil)
+        def process(method, path, parameters = nil, headers = nil)
           data = requestify(parameters)
           path = interpret_uri(path) if path =~ %r{://}
           path = "/#{path}" unless path[0] == ?/
@@ -258,14 +255,15 @@ module ActionController
           end
 
           unless ActionController::Base.respond_to?(:clear_last_instantiation!)
-            ActionController::Base.send(:include, ControllerCapture)
+            ActionController::Base.module_eval { include ControllerCapture }
           end
 
           ActionController::Base.clear_last_instantiation!
 
-          cgi = MockCGI.new(env, data)
+          cgi = StubCGI.new(env, data)
           Dispatcher.dispatch(cgi, ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, cgi.stdoutput)
           @result = cgi.stdoutput.string
+          @request_count += 1
 
           @controller = ActionController::Base.last_instantiation
           @request = @controller.request
@@ -294,7 +292,7 @@ module ActionController
           end
 
           (@headers['set-cookie'] || [] ).each do |string|
-            name, value = string.match(/^(.*?)=(.*?);/)[1,2]
+            name, value = string.match(/^([^=]*)=([^;]*);/)[1,2]
             @cookies[name] = value
           end
 
@@ -310,14 +308,14 @@ module ActionController
           end
         end
 
-        # Get a temporarly URL writer object
+        # Get a temporary URL writer object
         def generic_url_rewriter
-          cgi = MockCGI.new('REQUEST_METHOD' => "GET",
+          cgi = StubCGI.new('REQUEST_METHOD' => "GET",
                             'QUERY_STRING'   => "",
                             "REQUEST_URI"    => "/",
                             "HTTP_HOST"      => host,
                             "SERVER_PORT"    => https? ? "443" : "80",
-                            "HTTPS"          => https? ? "on" : "off")                          
+                            "HTTPS"          => https? ? "on" : "off")
           ActionController::UrlRewriter.new(ActionController::CgiRequest.new(cgi), {})
         end
 
@@ -339,7 +337,6 @@ module ActionController
             "#{CGI.escape(prefix)}=#{CGI.escape(parameters.to_s)}"
           end
         end
-
     end
 
     # A module used to extend ActionController::Base, so that integration tests
@@ -368,6 +365,76 @@ module ActionController
         end
       end
     end
+
+    module Runner
+      # Reset the current session. This is useful for testing multiple sessions
+      # in a single test case.
+      def reset!
+        @integration_session = open_session
+      end
+
+      %w(get post put head delete cookies assigns
+         xml_http_request get_via_redirect post_via_redirect).each do |method|
+        define_method(method) do |*args|
+          reset! unless @integration_session
+          # reset the html_document variable, but only for new get/post calls
+          @html_document = nil unless %w(cookies assigns).include?(method)
+          returning @integration_session.send!(method, *args) do
+            copy_session_variables!
+          end
+        end
+      end
+
+      # Open a new session instance. If a block is given, the new session is
+      # yielded to the block before being returned.
+      #
+      #   session = open_session do |sess|
+      #     sess.extend(CustomAssertions)
+      #   end
+      #
+      # By default, a single session is automatically created for you, but you
+      # can use this method to open multiple sessions that ought to be tested
+      # simultaneously.
+      def open_session
+        session = Integration::Session.new
+
+        # delegate the fixture accessors back to the test instance
+        extras = Module.new { attr_accessor :delegate, :test_result }
+        if self.class.respond_to?(:fixture_table_names)
+          self.class.fixture_table_names.each do |table_name|
+            name = table_name.tr(".", "_")
+            next unless respond_to?(name)
+            extras.send!(:define_method, name) { |*args| delegate.send(name, *args) }
+          end
+        end
+
+        # delegate add_assertion to the test case
+        extras.send!(:define_method, :add_assertion) { test_result.add_assertion }
+        session.extend(extras)
+        session.delegate = self
+        session.test_result = @_result
+
+        yield session if block_given?
+        session
+      end
+
+      # Copy the instance variables from the current session instance into the
+      # test instance.
+      def copy_session_variables! #:nodoc:
+        return unless @integration_session
+        %w(controller response request).each do |var|
+          instance_variable_set("@#{var}", @integration_session.send!(var))
+        end
+      end
+
+      # Delegate unhandled messages to the current session instance.
+      def method_missing(sym, *args, &block)
+        reset! unless @integration_session
+        returning @integration_session.send!(sym, *args, &block) do
+          copy_session_variables!
+        end
+      end
+    end
   end
 
   # An IntegrationTest is one that spans multiple controllers and actions,
@@ -446,6 +513,8 @@ module ActionController
   #       end
   #   end
   class IntegrationTest < Test::Unit::TestCase
+    include Integration::Runner
+
     # Work around a bug in test/unit caused by the default test being named
     # as a symbol (:default_test), which causes regex test filters
     # (like "ruby test.rb -n /foo/") to fail because =~ doesn't work on
@@ -493,70 +562,5 @@ module ActionController
           superclass.use_instantiated_fixtures
       end
     end
-
-    # Reset the current session. This is useful for testing multiple sessions
-    # in a single test case.
-    def reset!
-      @integration_session = open_session
-    end
-
-    %w(get post put head delete cookies assigns xml_http_request).each do |method|
-      define_method(method) do |*args|
-        reset! unless @integration_session
-        # reset the html_document variable, but only for new get/post calls
-        @html_document = nil unless %w(cookies assigns).include?(method)
-        returning @integration_session.send(method, *args) do
-          copy_session_variables!
-        end
-      end
-    end
-
-    # Open a new session instance. If a block is given, the new session is
-    # yielded to the block before being returned.
-    #
-    #   session = open_session do |sess|
-    #     sess.extend(CustomAssertions)
-    #   end
-    #
-    # By default, a single session is automatically created for you, but you
-    # can use this method to open multiple sessions that ought to be tested
-    # simultaneously.
-    def open_session
-      session = Integration::Session.new
-
-      # delegate the fixture accessors back to the test instance
-      extras = Module.new { attr_accessor :delegate, :test_result }
-      self.class.fixture_table_names.each do |table_name|
-        name = table_name.tr(".", "_")
-        next unless respond_to?(name)
-        extras.send(:define_method, name) { |*args| delegate.send(name, *args) }
-      end
-
-      # delegate add_assertion to the test case
-      extras.send(:define_method, :add_assertion) { test_result.add_assertion }
-      session.extend(extras)
-      session.delegate = self
-      session.test_result = @_result
-
-      yield session if block_given?
-      session
-    end
-
-    # Copy the instance variables from the current session instance into the
-    # test instance.
-    def copy_session_variables! #:nodoc:
-      return unless @integration_session
-      %w(controller response request).each do |var|
-        instance_variable_set("@#{var}", @integration_session.send(var))
-      end
-    end
-
-    # Delegate unhandled messages to the current session instance.
-    def method_missing(sym, *args, &block)
-      reset! unless @integration_session
-      returning @integration_session.send(sym, *args, &block) do
-        copy_session_variables!
-      end
-    end
   end
 end