Finish porting over the initializers to the app object and fix all the tests

13 files changed, 476 insertions, 834 deletions

diff --git a/railties/lib/rails/application.rb b/railties/lib/rails/application.rb
index 5c1c69d5e0..d54120f850 100644
--- a/railties/lib/rails/application.rb
+++ b/railties/lib/rails/application.rb
@@ -277,5 +277,211 @@ module Rails
         end
       end
     end
+
+    # Initializes framework-specific settings for each of the loaded frameworks
+    # (Configuration#frameworks). The available settings map to the accessors
+    # on each of the corresponding Base classes.
+    initializer :initialize_framework_settings do
+      config.frameworks.each do |framework|
+        base_class = framework.to_s.camelize.constantize.const_get("Base")
+
+        config.send(framework).each do |setting, value|
+          base_class.send("#{setting}=", value)
+        end
+      end
+      config.active_support.each do |setting, value|
+        ActiveSupport.send("#{setting}=", value)
+      end
+    end
+
+    # Sets +ActionController::Base#view_paths+ and +ActionMailer::Base#template_root+
+    # (but only for those frameworks that are to be loaded). If the framework's
+    # paths have already been set, it is not changed, otherwise it is
+    # set to use Configuration#view_path.
+    initializer :initialize_framework_views do
+      if config.frameworks.include?(:action_view)
+        view_path = ActionView::PathSet.type_cast(config.view_path, config.cache_classes)
+        ActionMailer::Base.template_root  = view_path if config.frameworks.include?(:action_mailer) && ActionMailer::Base.view_paths.blank?
+        ActionController::Base.view_paths = view_path if config.frameworks.include?(:action_controller) && ActionController::Base.view_paths.blank?
+      end
+    end
+
+    initializer :initialize_metal do
+      # TODO: Make Rails and metal work without ActionController
+      if config.frameworks.include?(:action_controller)
+        Rails::Rack::Metal.requested_metals = config.metals
+        Rails::Rack::Metal.metal_paths += plugin_loader.engine_metal_paths
+
+        config.middleware.insert_before(
+          :"ActionDispatch::ParamsParser",
+          Rails::Rack::Metal, :if => Rails::Rack::Metal.metals.any?)
+      end
+    end
+
+    initializer :check_for_unbuilt_gems do
+      unbuilt_gems = config.gems.select {|gem| gem.frozen? && !gem.built? }
+      if unbuilt_gems.size > 0
+        # don't print if the gems:build rake tasks are being run
+        unless $gems_build_rake_task
+          abort <<-end_error
+  The following gems have native components that need to be built
+  #{unbuilt_gems.map { |gemm| "#{gemm.name}  #{gemm.requirement}" } * "\n  "}
+
+  You're running:
+  ruby #{Gem.ruby_version} at #{Gem.ruby}
+  rubygems #{Gem::RubyGemsVersion} at #{Gem.path * ', '}
+
+  Run `rake gems:build` to build the unbuilt gems.
+          end_error
+        end
+      end
+    end
+
+    initializer :load_gems do
+      unless $gems_rake_task
+        config.gems.each { |gem| gem.load }
+      end
+    end
+
+    # Loads all plugins in <tt>config.plugin_paths</tt>.  <tt>plugin_paths</tt>
+    # defaults to <tt>vendor/plugins</tt> but may also be set to a list of
+    # paths, such as
+    #   config.plugin_paths = ["#{RAILS_ROOT}/lib/plugins", "#{RAILS_ROOT}/vendor/plugins"]
+    #
+    # In the default implementation, as each plugin discovered in <tt>plugin_paths</tt> is initialized:
+    # * its +lib+ directory, if present, is added to the load path (immediately after the applications lib directory)
+    # * <tt>init.rb</tt> is evaluated, if present
+    #
+    # After all plugins are loaded, duplicates are removed from the load path.
+    # If an array of plugin names is specified in config.plugins, only those plugins will be loaded
+    # and they plugins will be loaded in that order. Otherwise, plugins are loaded in alphabetical
+    # order.
+    #
+    # if config.plugins ends contains :all then the named plugins will be loaded in the given order and all other
+    # plugins will be loaded in alphabetical order
+    initializer :load_plugins do
+      plugin_loader.load_plugins
+    end
+
+    # TODO: Figure out if this needs to run a second time
+    # load_gems
+
+    initializer :check_gem_dependencies do
+      unloaded_gems = config.gems.reject { |g| g.loaded? }
+      if unloaded_gems.size > 0
+        configuration.gems_dependencies_loaded = false
+        # don't print if the gems rake tasks are being run
+        unless $gems_rake_task
+          abort <<-end_error
+  Missing these required gems:
+  #{unloaded_gems.map { |gemm| "#{gemm.name}  #{gemm.requirement}" } * "\n  "}
+
+  You're running:
+  ruby #{Gem.ruby_version} at #{Gem.ruby}
+  rubygems #{Gem::RubyGemsVersion} at #{Gem.path * ', '}
+
+  Run `rake gems:install` to install the missing gems.
+          end_error
+        end
+      else
+        configuration.gems_dependencies_loaded = true
+      end
+    end
+
+    # # bail out if gems are missing - note that check_gem_dependencies will have
+    # # already called abort() unless $gems_rake_task is set
+    # return unless gems_dependencies_loaded
+
+    initializer :load_application_initializers do
+      if config.gems_dependencies_loaded
+        Dir["#{configuration.root_path}/config/initializers/**/*.rb"].sort.each do |initializer|
+          load(initializer)
+        end
+      end
+    end
+
+    # Fires the user-supplied after_initialize block (Configuration#after_initialize)
+    initializer :after_initialize do
+      if config.gems_dependencies_loaded
+        configuration.after_initialize_blocks.each do |block|
+          block.call
+        end
+      end
+    end
+
+    # # Setup database middleware after initializers have run
+    initializer :initialize_database_middleware do
+      if configuration.frameworks.include?(:active_record)
+        if configuration.frameworks.include?(:action_controller) && ActionController::Base.session_store &&
+            ActionController::Base.session_store.name == 'ActiveRecord::SessionStore'
+          configuration.middleware.insert_before :"ActiveRecord::SessionStore", ActiveRecord::ConnectionAdapters::ConnectionManagement
+          configuration.middleware.insert_before :"ActiveRecord::SessionStore", ActiveRecord::QueryCache
+        else
+          configuration.middleware.use ActiveRecord::ConnectionAdapters::ConnectionManagement
+          configuration.middleware.use ActiveRecord::QueryCache
+        end
+      end
+    end
+
+    # TODO: Make a DSL way to limit an initializer to a particular framework
+
+    # # Prepare dispatcher callbacks and run 'prepare' callbacks
+    initializer :prepare_dispatcher do
+      next unless configuration.frameworks.include?(:action_controller)
+      require 'rails/dispatcher' unless defined?(::Dispatcher)
+      Dispatcher.define_dispatcher_callbacks(configuration.cache_classes)
+    end
+
+    # Routing must be initialized after plugins to allow the former to extend the routes
+    # ---
+    # If Action Controller is not one of the loaded frameworks (Configuration#frameworks)
+    # this does nothing. Otherwise, it loads the routing definitions and sets up
+    # loading module used to lazily load controllers (Configuration#controller_paths).
+    initializer :initialize_routing do
+      next unless configuration.frameworks.include?(:action_controller)
+
+      ActionController::Routing.controller_paths += configuration.controller_paths
+      ActionController::Routing::Routes.add_configuration_file(configuration.routes_configuration_file)
+      ActionController::Routing::Routes.reload!
+    end
+    #
+    # # Observers are loaded after plugins in case Observers or observed models are modified by plugins.
+    initializer :load_observers do
+      if config.gems_dependencies_loaded && configuration.frameworks.include?(:active_record)
+        ActiveRecord::Base.instantiate_observers
+      end
+    end
+
+    # Eager load application classes
+    initializer :load_application_classes do
+      next if $rails_rake_task
+
+      if configuration.cache_classes
+        configuration.eager_load_paths.each do |load_path|
+          matcher = /\A#{Regexp.escape(load_path)}(.*)\.rb\Z/
+          Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
+            require_dependency file.sub(matcher, '\1')
+          end
+        end
+      end
+    end
+
+    # Disable dependency loading during request cycle
+    initializer :disable_dependency_loading do
+      if configuration.cache_classes && !configuration.dependency_loading
+        ActiveSupport::Dependencies.unhook!
+      end
+    end
+
+    # Configure generators if they were already loaded
+    # ===
+    # TODO: Does this need to be an initializer here?
+    initializer :initialize_generators do
+      if defined?(Rails::Generators)
+        Rails::Generators.no_color! unless config.generators.colorize_logging
+        Rails::Generators.aliases.deep_merge! config.generators.aliases
+        Rails::Generators.options.deep_merge! config.generators.options
+      end
+    end
   end
 end
diff --git a/railties/lib/rails/core.rb b/railties/lib/rails/core.rb
index 4be90de792..929c38bd22 100644
--- a/railties/lib/rails/core.rb
+++ b/railties/lib/rails/core.rb
@@ -15,11 +15,7 @@ module Rails
 
     # The Configuration instance used to configure the Rails environment
     def configuration
-      @@configuration
-    end
-
-    def configuration=(configuration)
-      @@configuration = configuration
+      application.configuration
     end
 
     def initialized?
diff --git a/railties/lib/rails/initializer.rb b/railties/lib/rails/initializer.rb
index eb24707ed9..f7c3774450 100644
--- a/railties/lib/rails/initializer.rb
+++ b/railties/lib/rails/initializer.rb
@@ -15,308 +15,14 @@ RAILS_ENV = (ENV['RAILS_ENV'] || 'development').dup unless defined?(RAILS_ENV)
 module Rails
   class Initializer
     class Error < StandardError ; end
-
-    class Base
-      class << self
-        def run(&blk)
-          define_method(:run, &blk)
-        end
-
-        def config=(config)
-          @@config = config
-        end
-
-        def config
-          @@config || Configuration.new
-        end
-        alias configuration config
-
-        def gems_dependencies_loaded
-          config.gems_dependencies_loaded
-        end
-
-        def plugin_loader
-          @plugin_loader ||= configuration.plugin_loader.new(self)
-        end
-      end
-
-      def gems_dependencies_loaded
-        self.class.gems_dependencies_loaded
-      end
-
-      def plugin_loader
-        self.class.plugin_loader
-      end
-    end
-
-    class Runner
-
-      attr_reader :names, :initializers
-      attr_accessor :config
-      alias configuration config
-
-      def initialize(parent = nil)
-        @names        = parent ? parent.names.dup        : {}
-        @initializers = parent ? parent.initializers.dup : []
-      end
-
-      def add(name, options = {}, &block)
-        # If :before or :after is specified, set the index to the right spot
-        if other = options[:before] || options[:after]
-          raise Error, "The #{other.inspect} initializer does not exist" unless @names[other]
-          index = @initializers.index(@names[other])
-          index += 1 if options[:after]
-        end
-
-        @initializers.insert(index || -1, block)
-        @names[name] = block
-      end
-
-      def delete(name)
-        @names[name].tap do |initializer|
-          @initializers.delete(initializer)
-          @names.delete(name)
-        end
-      end
-
-      def run_initializer(initializer)
-        init_block = initializer.is_a?(Proc) ? initializer : @names[initializer]
-        container = Class.new(Base, &init_block).new
-        container.run if container.respond_to?(:run)
-      end
-
-      def run(initializer = nil)
-        Rails.configuration = Base.config = @config
-
-        if initializer
-          run_initializer(initializer)
-        else
-          @initializers.each {|block| run_initializer(block) }
-        end
-      end
-    end
-
-    def self.default
-      @default ||= Runner.new
-    end
-
     def self.run(initializer = nil, config = nil)
-      # TODO: Clean this all up
       if initializer
-        default.config = config
-        default.run(initializer)
+        # Deprecated
       else
         Rails.application = Class.new(Application)
         yield Rails.application.config if block_given?
-        # Trigger the initializer
         Rails.application.new
-        default.config = Rails.application.config
-        default.run
-      end
-    end
-  end
-
-  # Initializes framework-specific settings for each of the loaded frameworks
-  # (Configuration#frameworks). The available settings map to the accessors
-  # on each of the corresponding Base classes.
-  Initializer.default.add :initialize_framework_settings do
-    configuration.frameworks.each do |framework|
-      base_class = framework.to_s.camelize.constantize.const_get("Base")
-
-      configuration.send(framework).each do |setting, value|
-        base_class.send("#{setting}=", value)
       end
     end
-    configuration.active_support.each do |setting, value|
-      ActiveSupport.send("#{setting}=", value)
-    end
-  end
-
-  # Sets +ActionController::Base#view_paths+ and +ActionMailer::Base#template_root+
-  # (but only for those frameworks that are to be loaded). If the framework's
-  # paths have already been set, it is not changed, otherwise it is
-  # set to use Configuration#view_path.
-  Initializer.default.add :initialize_framework_views do
-    if configuration.frameworks.include?(:action_view)
-      view_path = ActionView::PathSet.type_cast(configuration.view_path)
-      ActionMailer::Base.template_root  = view_path if configuration.frameworks.include?(:action_mailer) && ActionMailer::Base.view_paths.blank?
-      ActionController::Base.view_paths = view_path if configuration.frameworks.include?(:action_controller) && ActionController::Base.view_paths.blank?
-    end
-  end
-
-  Initializer.default.add :initialize_metal do
-    # TODO: Make Rails and metal work without ActionController
-    if configuration.frameworks.include?(:action_controller)
-      Rails::Rack::Metal.requested_metals = configuration.metals
-      Rails::Rack::Metal.metal_paths += plugin_loader.engine_metal_paths
-
-      configuration.middleware.insert_before(
-        :"ActionDispatch::ParamsParser",
-        Rails::Rack::Metal, :if => Rails::Rack::Metal.metals.any?)
-    end
-  end
-
-  Initializer.default.add :check_for_unbuilt_gems do
-    unbuilt_gems = config.gems.select {|gem| gem.frozen? && !gem.built? }
-    if unbuilt_gems.size > 0
-      # don't print if the gems:build rake tasks are being run
-      unless $gems_build_rake_task
-        abort <<-end_error
-The following gems have native components that need to be built
-#{unbuilt_gems.map { |gemm| "#{gemm.name}  #{gemm.requirement}" } * "\n  "}
-
-You're running:
-ruby #{Gem.ruby_version} at #{Gem.ruby}
-rubygems #{Gem::RubyGemsVersion} at #{Gem.path * ', '}
-
-Run `rake gems:build` to build the unbuilt gems.
-        end_error
-      end
-    end
-  end
-
-  Initializer.default.add :load_gems do
-    unless $gems_rake_task
-      config.gems.each { |gem| gem.load }
-    end
-  end
-
-  # Loads all plugins in <tt>config.plugin_paths</tt>.  <tt>plugin_paths</tt>
-  # defaults to <tt>vendor/plugins</tt> but may also be set to a list of
-  # paths, such as
-  #   config.plugin_paths = ["#{RAILS_ROOT}/lib/plugins", "#{RAILS_ROOT}/vendor/plugins"]
-  #
-  # In the default implementation, as each plugin discovered in <tt>plugin_paths</tt> is initialized:
-  # * its +lib+ directory, if present, is added to the load path (immediately after the applications lib directory)
-  # * <tt>init.rb</tt> is evaluated, if present
-  #
-  # After all plugins are loaded, duplicates are removed from the load path.
-  # If an array of plugin names is specified in config.plugins, only those plugins will be loaded
-  # and they plugins will be loaded in that order. Otherwise, plugins are loaded in alphabetical
-  # order.
-  #
-  # if config.plugins ends contains :all then the named plugins will be loaded in the given order and all other
-  # plugins will be loaded in alphabetical order
-  Initializer.default.add :load_plugins do
-    plugin_loader.load_plugins
-  end
-
-  # TODO: Figure out if this needs to run a second time
-  # load_gems
-
-  Initializer.default.add :check_gem_dependencies do
-    unloaded_gems = config.gems.reject { |g| g.loaded? }
-    if unloaded_gems.size > 0
-      configuration.gems_dependencies_loaded = false
-      # don't print if the gems rake tasks are being run
-      unless $gems_rake_task
-        abort <<-end_error
-Missing these required gems:
-#{unloaded_gems.map { |gemm| "#{gemm.name}  #{gemm.requirement}" } * "\n  "}
-
-You're running:
-ruby #{Gem.ruby_version} at #{Gem.ruby}
-rubygems #{Gem::RubyGemsVersion} at #{Gem.path * ', '}
-
-Run `rake gems:install` to install the missing gems.
-        end_error
-      end
-    else
-      configuration.gems_dependencies_loaded = true
-    end
-  end
-
-  # # bail out if gems are missing - note that check_gem_dependencies will have
-  # # already called abort() unless $gems_rake_task is set
-  # return unless gems_dependencies_loaded
-
-  Initializer.default.add :load_application_initializers do
-    if gems_dependencies_loaded
-      Dir["#{configuration.root_path}/config/initializers/**/*.rb"].sort.each do |initializer|
-        load(initializer)
-      end
-    end
-  end
-
-  # Fires the user-supplied after_initialize block (Configuration#after_initialize)
-  Initializer.default.add :after_initialize do
-    if gems_dependencies_loaded
-      configuration.after_initialize_blocks.each do |block|
-        block.call
-      end
-    end
-  end
-
-  # # Setup database middleware after initializers have run
-  Initializer.default.add :initialize_database_middleware do
-    if configuration.frameworks.include?(:active_record)
-      if configuration.frameworks.include?(:action_controller) && ActionController::Base.session_store &&
-          ActionController::Base.session_store.name == 'ActiveRecord::SessionStore'
-        configuration.middleware.insert_before :"ActiveRecord::SessionStore", ActiveRecord::ConnectionAdapters::ConnectionManagement
-        configuration.middleware.insert_before :"ActiveRecord::SessionStore", ActiveRecord::QueryCache
-      else
-        configuration.middleware.use ActiveRecord::ConnectionAdapters::ConnectionManagement
-        configuration.middleware.use ActiveRecord::QueryCache
-      end
-    end
-  end
-
-  # TODO: Make a DSL way to limit an initializer to a particular framework
-
-  # # Prepare dispatcher callbacks and run 'prepare' callbacks
-  Initializer.default.add :prepare_dispatcher do
-    next unless configuration.frameworks.include?(:action_controller)
-    require 'rails/dispatcher' unless defined?(::Dispatcher)
-    Dispatcher.define_dispatcher_callbacks(configuration.cache_classes)
-  end
-
-  # Routing must be initialized after plugins to allow the former to extend the routes
-  # ---
-  # If Action Controller is not one of the loaded frameworks (Configuration#frameworks)
-  # this does nothing. Otherwise, it loads the routing definitions and sets up
-  # loading module used to lazily load controllers (Configuration#controller_paths).
-  Initializer.default.add :initialize_routing do
-    next unless configuration.frameworks.include?(:action_controller)
-
-    ActionController::Routing.controller_paths += configuration.controller_paths
-    ActionController::Routing::Routes.add_configuration_file(configuration.routes_configuration_file)
-    ActionController::Routing::Routes.reload!
-  end
-  #
-  # # Observers are loaded after plugins in case Observers or observed models are modified by plugins.
-  Initializer.default.add :load_observers do
-    if gems_dependencies_loaded && configuration.frameworks.include?(:active_record)
-      ActiveRecord::Base.instantiate_observers
-    end
-  end
-
-  # Eager load application classes
-  Initializer.default.add :load_application_classes do
-    next if $rails_rake_task
-
-    if configuration.cache_classes
-      configuration.eager_load_paths.each do |load_path|
-        matcher = /\A#{Regexp.escape(load_path)}(.*)\.rb\Z/
-        Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
-          require_dependency file.sub(matcher, '\1')
-        end
-      end
-    end
-  end
-
-  # Disable dependency loading during request cycle
-  Initializer.default.add :disable_dependency_loading do
-    if configuration.cache_classes && !configuration.dependency_loading
-      ActiveSupport::Dependencies.unhook!
-    end
-  end
-
-  # Configure generators if they were already loaded
-  Initializer.default.add :initialize_generators do
-    if defined?(Rails::Generators)
-      Rails::Generators.no_color! unless config.generators.colorize_logging
-      Rails::Generators.aliases.deep_merge! config.generators.aliases
-      Rails::Generators.options.deep_merge! config.generators.options
-    end
   end
 end
diff --git a/railties/test/application/generators_test.rb b/railties/test/application/generators_test.rb
new file mode 100644
index 0000000000..0d6eb4147a
--- /dev/null
+++ b/railties/test/application/generators_test.rb
@@ -0,0 +1,89 @@
+require "isolation/abstract_unit"
+
+module ApplicationTests
+  class GeneratorsTest < Test::Unit::TestCase
+    include ActiveSupport::Testing::Isolation
+
+    def setup
+      require "rails/generators"
+      build_app
+      boot_rails
+    end
+
+    test "generators default values" do
+      Rails::Initializer.run do |c|
+        assert_equal(true, c.generators.colorize_logging)
+        assert_equal({}, c.generators.aliases)
+        assert_equal({}, c.generators.options)
+      end
+    end
+
+    test "generators set rails options" do
+      Rails::Initializer.run do |c|
+        c.generators.orm            = :datamapper
+        c.generators.test_framework = :rspec
+        expected = { :rails => { :orm => :datamapper, :test_framework => :rspec } }
+        assert_equal(expected, c.generators.options)
+      end
+    end
+
+    test "generators set rails aliases" do
+      Rails::Initializer.run do |c|
+        c.generators.aliases = { :rails => { :test_framework => "-w" } }
+        expected = { :rails => { :test_framework => "-w" } }
+        assert_equal expected, c.generators.aliases
+      end
+    end
+
+    test "generators aliases and options on initialization" do
+      Rails::Initializer.run do |c|
+        c.generators.rails :aliases => { :test_framework => "-w" }
+        c.generators.orm :datamapper
+        c.generators.test_framework :rspec
+      end
+
+      assert_equal :rspec, Rails::Generators.options[:rails][:test_framework]
+      assert_equal "-w", Rails::Generators.aliases[:rails][:test_framework]
+    end
+
+    test "generators no color on initialization" do
+      Rails::Initializer.run do |c|
+        c.generators.colorize_logging = false
+      end
+
+      assert_equal Thor::Base.shell, Thor::Shell::Basic
+    end
+
+    test "generators with hashes for options and aliases" do
+      Rails::Initializer.run do |c|
+        c.generators do |g|
+          g.orm    :datamapper, :migration => false
+          g.plugin :aliases => { :generator => "-g" },
+                   :generator => true
+        end
+
+        expected = {
+          :rails => { :orm => :datamapper },
+          :plugin => { :generator => true },
+          :datamapper => { :migration => false }
+        }
+
+        assert_equal expected, c.generators.options
+        assert_equal({ :plugin => { :generator => "-g" } }, c.generators.aliases)
+      end
+    end
+
+    test "generators with hashes are deep merged" do
+      Rails::Initializer.run do |c|
+        c.generators do |g|
+          g.orm    :datamapper, :migration => false
+          g.plugin :aliases => { :generator => "-g" },
+                   :generator => true
+        end
+      end
+
+      assert Rails::Generators.aliases.size >= 1
+      assert Rails::Generators.options.size >= 1
+    end
+  end
+end
\ No newline at end of file
diff --git a/railties/test/application/initializer_test.rb b/railties/test/application/initializer_test.rb
index c57ed08fdc..f46bf2b656 100644
--- a/railties/test/application/initializer_test.rb
+++ b/railties/test/application/initializer_test.rb
@@ -55,6 +55,59 @@ module ApplicationTests
       assert Zoo
     end
 
+    test "load environment with global" do
+      app_file "config/environments/development.rb", "$initialize_test_set_from_env = 'success'"
+      assert_nil $initialize_test_set_from_env
+      Rails::Initializer.run { }
+      assert_equal "success", $initialize_test_set_from_env
+    end
+
+    test "action_controller load paths set only if action controller in use" do
+      assert_nothing_raised NameError do
+        Rails::Initializer.run do |config|
+          config.frameworks = []
+        end
+      end
+    end
+
+    test "action_pack is added to the load path if action_controller is required" do
+      Rails::Initializer.run do |config|
+        config.frameworks = [:action_controller]
+      end
+
+      assert $:.include?("#{framework_path}/actionpack/lib")
+    end
+
+    test "action_pack is added to the load path if action_view is required" do
+      Rails::Initializer.run do |config|
+        config.frameworks = [:action_view]
+      end
+
+      assert $:.include?("#{framework_path}/actionpack/lib")
+    end
+
+    test "after_initialize block works correctly" do
+      Rails::Initializer.run do |config|
+        config.after_initialize { $test_after_initialize_block1 = "success" }
+        config.after_initialize { $test_after_initialize_block2 = "congratulations" }
+      end
+
+      assert_equal "success", $test_after_initialize_block1
+      assert_equal "congratulations", $test_after_initialize_block2
+    end
+
+    test "after_initialize block works correctly when no block is passed" do
+      Rails::Initializer.run do |config|
+        config.after_initialize { $test_after_initialize_block1 = "success" }
+        config.after_initialize # don't pass a block, this is what we're testing!
+        config.after_initialize { $test_after_initialize_block2 = "congratulations" }
+      end
+
+      assert_equal "success", $test_after_initialize_block1
+      assert_equal "congratulations", $test_after_initialize_block2
+    end
+
+    # i18n
     test "setting another default locale" do
       Rails::Initializer.run do |config|
         config.i18n.default_locale = :de
@@ -62,11 +115,80 @@ module ApplicationTests
       assert_equal :de, I18n.default_locale
     end
 
-    test "load environment with global" do
-      app_file "config/environments/development.rb", "$initialize_test_set_from_env = 'success'"
-      assert_nil $initialize_test_set_from_env
-      Rails::Initializer.run { }
-      assert_equal "success", $initialize_test_set_from_env
+    test "no config locales dir present should return empty load path" do
+      FileUtils.rm_rf "#{app_path}/config/locales"
+      Rails::Initializer.run do |c|
+        assert_equal [], c.i18n.load_path
+      end
+    end
+
+    test "config locales dir present should be added to load path" do
+      Rails::Initializer.run do |c|
+        assert_equal ["#{app_path}/config/locales/en.yml"], c.i18n.load_path
+      end
+    end
+
+    test "config defaults should be added with config settings" do
+      Rails::Initializer.run do |c|
+        c.i18n.load_path << "my/other/locale.yml"
+      end
+
+      assert_equal [
+        "#{app_path}/config/locales/en.yml", "my/other/locale.yml"
+      ], Rails.application.config.i18n.load_path
+    end
+
+    # DB middleware
+    test "database middleware doesn't initialize when session store is not active_record" do
+      Rails::Initializer.run do |config|
+        config.action_controller.session_store = :cookie_store
+      end
+
+      assert !Rails.application.config.middleware.include?(ActiveRecord::SessionStore)
+    end
+
+    test "database middleware doesn't initialize when activerecord is not in frameworks" do
+      Rails::Initializer.run do |c|
+        c.frameworks = []
+      end
+      assert_equal [], Rails.application.config.middleware
+    end
+
+    test "database middleware initializes when session store is active record" do
+      Rails::Initializer.run do |c|
+        c.action_controller.session_store = :active_record_store
+      end
+
+      expects = [ActiveRecord::ConnectionAdapters::ConnectionManagement, ActiveRecord::QueryCache, ActiveRecord::SessionStore]
+      middleware = Rails.application.config.middleware.map { |m| m.klass }
+      assert_equal expects, middleware & expects
+    end
+
+    test "ensure database middleware doesn't use action_controller on initializing" do
+      Rails::Initializer.run do |c|
+        c.frameworks -= [:action_controller]
+        c.action_controller.session_store = :active_record_store
+      end
+
+      assert !Rails.application.config.middleware.include?(ActiveRecord::SessionStore)
+    end
+
+    # Pathview test
+    test "load view paths doesn't perform anything when action_view not in frameworks" do
+      Rails::Initializer.run do |c|
+        c.frameworks -= [:action_view]
+      end
+      assert_equal nil, ActionMailer::Base.template_root
+      assert_equal [], ActionController::Base.view_paths
+    end
+
+    # Rails root test
+    test "Rails.root == RAILS_ROOT" do
+      assert_equal RAILS_ROOT, Rails.root.to_s
+    end
+
+    test "Rails.root should be a Pathname" do
+      assert_instance_of Pathname, Rails.root
     end
   end
 end
\ No newline at end of file
diff --git a/railties/test/application/plugins_test.rb b/railties/test/application/plugins_test.rb
index 2a433ea016..81e7f4d88c 100644
--- a/railties/test/application/plugins_test.rb
+++ b/railties/test/application/plugins_test.rb
@@ -23,6 +23,17 @@ module ApplicationTests
       ], Rails.application.config.loaded_plugins, @failure_tip
     end
 
+    test "no plugins are loaded if the configuration has an empty plugin list" do
+      Rails::Initializer.run { |c| c.plugins = [] }
+      assert_plugins [], Rails.application.config.loaded_plugins
+    end
+
+    test "only the specified plugins are located in the order listed" do
+      plugin_names = [:plugin_with_no_lib_dir, :acts_as_chunky_bacon]
+      Rails::Initializer.run { |c| c.plugins = plugin_names }
+      assert_plugins plugin_names, Rails.application.config.loaded_plugins
+    end
+
     test "all plugins loaded after all" do
       Rails::Initializer.run do |config|
         config.plugins = [:stubby, :all, :acts_as_chunky_bacon]
diff --git a/railties/test/initializer/path_test.rb b/railties/test/initializer/path_test.rb
index a4264bc31c..72ff8d88e0 100644
--- a/railties/test/initializer/path_test.rb
+++ b/railties/test/initializer/path_test.rb
@@ -12,7 +12,7 @@ class PathsTest < Test::Unit::TestCase
         ActionController::Base.session_store = nil
       end
     end
-    @paths = Rails::Initializer.default.config.paths
+    @paths = Rails.application.config.paths
   end
 
   def root(*path)
diff --git a/railties/test/initializer_test.rb b/railties/test/initializer_test.rb
index e1c497c8a8..80e774b7b7 100644
--- a/railties/test/initializer_test.rb
+++ b/railties/test/initializer_test.rb
@@ -6,359 +6,8 @@ require 'action_view'
 require 'action_mailer'
 require 'active_record'
 
-# Mocks out the configuration
-module Rails
-  def self.configuration
-    Rails::Configuration.new
-  end
-
-  module Generators
-    def self.clear_aliases!
-      @aliases = nil
-    end
-
-    def self.clear_options!
-      @@options = nil
-    end
-  end
-end
-
-
-class ConfigurationMock < Rails::Configuration
-  attr_reader :environment_path
-
-  def initialize(envpath)
-    super()
-    @environment_path = envpath
-  end
-end
-
-class Initializer_after_initialize_with_blocks_environment_Test < Test::Unit::TestCase
-  def setup
-    config = ConfigurationMock.new("")
-    config.after_initialize do
-      $test_after_initialize_block1 = "success"
-    end
-    config.after_initialize do
-      $test_after_initialize_block2 = "congratulations"
-    end
-    assert_nil $test_after_initialize_block1
-    assert_nil $test_after_initialize_block2
-
-    config.expects(:gems_dependencies_loaded).returns(true)
-    Rails::Initializer.run(:after_initialize, config)
-  end
-
-  def teardown
-    $test_after_initialize_block1 = nil
-    $test_after_initialize_block2 = nil
-  end
-
-  def test_should_have_called_the_first_after_initialize_block
-    assert_equal "success", $test_after_initialize_block1
-  end
-
-  def test_should_have_called_the_second_after_initialize_block
-    assert_equal "congratulations", $test_after_initialize_block2
-  end
-end
-
-class Initializer_after_initialize_with_no_block_environment_Test < Test::Unit::TestCase
-  def setup
-    config = ConfigurationMock.new("")
-    config.after_initialize do
-      $test_after_initialize_block1 = "success"
-    end
-    config.after_initialize # don't pass a block, this is what we're testing!
-    config.after_initialize do
-      $test_after_initialize_block2 = "congratulations"
-    end
-    assert_nil $test_after_initialize_block1
-
-    config.expects(:gems_dependencies_loaded).returns(true)
-    Rails::Initializer.run(:after_initialize, config)
-  end
-
-  def teardown
-    $test_after_initialize_block1 = nil
-    $test_after_initialize_block2 = nil
-  end
-
-  def test_should_have_called_the_first_after_initialize_block
-    assert_equal "success", $test_after_initialize_block1, "should still get set"
-  end
-
-  def test_should_have_called_the_second_after_initialize_block
-    assert_equal "congratulations", $test_after_initialize_block2
-  end
-end
-
-class ConfigurationFrameworkPathsTests < Test::Unit::TestCase
-  def setup
-    @config = Rails::Configuration.new
-    @config.frameworks.clear
-    @initializer = Rails::Initializer.default
-    @initializer.config = @config
-
-    File.stubs(:directory?).returns(true)
-    Rails::Initializer.run(:set_root_path, @config)
-  end
-
-  def test_minimal
-    expected = %w(railties railties/lib activesupport/lib)
-    assert_equal expected.map {|e| "#{@config.framework_root_path}/#{e}"}, @config.framework_paths
-  end
-
-  def test_actioncontroller_or_actionview_add_actionpack
-    @config.frameworks << :action_controller
-    assert_framework_path "actionpack/lib"
-
-    @config.frameworks = [:action_view]
-    assert_framework_path 'actionpack/lib'
-  end
-
-  def test_paths_for_ar_ares_and_mailer
-    [:active_record, :action_mailer, :active_resource, :action_web_service].each do |framework|
-      @config.frameworks = [framework]
-      assert_framework_path "#{framework.to_s.gsub('_', '')}/lib"
-    end
-  end
-
-  def test_action_mailer_load_paths_set_only_if_action_mailer_in_use
-    @config.frameworks = [:action_controller]
-    @initializer.config = @config
-    @initializer.run :require_frameworks
-
-    assert_nothing_raised NameError do
-      @initializer.run :load_view_paths
-    end
-  end
-
-  def test_action_controller_load_paths_set_only_if_action_controller_in_use
-    @config.frameworks = []
-    @initializer.run :require_frameworks
-
-    assert_nothing_raised NameError do
-      @initializer.run :load_view_paths
-    end
-  end
-
-  protected
-    def assert_framework_path(path)
-      assert @config.framework_paths.include?("#{@config.framework_root_path}/#{path}"),
-        "<#{path.inspect}> not found among <#{@config.framework_paths.inspect}>"
-    end
-end
-
 require 'plugin_test_helper'
 
-class InitializerPluginLoadingTests < Test::Unit::TestCase
-  def setup
-    @configuration     = Rails::Configuration.new
-    @configuration.frameworks -= [:action_mailer]
-    @configuration.plugin_paths << plugin_fixture_root_path
-    @initializer       = Rails::Initializer.default
-    @initializer.config = @configuration
-    @valid_plugin_path = plugin_fixture_path('default/stubby')
-    @empty_plugin_path = plugin_fixture_path('default/empty')
-  end
-
-  def test_no_plugins_are_loaded_if_the_configuration_has_an_empty_plugin_list
-    only_load_the_following_plugins! []
-    @initializer.run :load_plugins
-    assert_equal [], @configuration.loaded_plugins
-  end
-
-  def test_only_the_specified_plugins_are_located_in_the_order_listed
-    plugin_names = [:plugin_with_no_lib_dir, :acts_as_chunky_bacon]
-    only_load_the_following_plugins! plugin_names
-    load_plugins!
-    assert_plugins plugin_names, @configuration.loaded_plugins
-  end
-
-  private
-
-    def load_plugins!
-      @initializer.run(:add_plugin_load_paths)
-      @initializer.run(:load_plugins)
-    end
-end
-
-class InitializerGeneratorsTests < Test::Unit::TestCase
-
-  def setup
-    @configuration = Rails::Configuration.new
-    @initializer   = Rails::Initializer.default
-    @initializer.config = @configuration
-  end
-
-  def test_generators_default_values
-    assert_equal(true, @configuration.generators.colorize_logging)
-    assert_equal({}, @configuration.generators.aliases)
-    assert_equal({}, @configuration.generators.options)
-  end
-
-  def test_generators_set_rails_options
-    @configuration.generators.orm = :datamapper
-    @configuration.generators.test_framework = :rspec
-    expected = { :rails => { :orm => :datamapper, :test_framework => :rspec } }
-    assert_equal expected, @configuration.generators.options
-  end
-
-  def test_generators_set_rails_aliases
-    @configuration.generators.aliases = { :rails => { :test_framework => "-w" } }
-    expected = { :rails => { :test_framework => "-w" } }
-    assert_equal expected, @configuration.generators.aliases
-  end
-
-  def test_generators_aliases_and_options_on_initialization
-    @configuration.generators.rails :aliases => { :test_framework => "-w" }
-    @configuration.generators.orm :datamapper
-    @configuration.generators.test_framework :rspec
-
-    @initializer.run(:initialize_generators)
-
-    assert_equal :rspec, Rails::Generators.options[:rails][:test_framework]
-    assert_equal "-w", Rails::Generators.aliases[:rails][:test_framework]
-  end
-
-  def test_generators_no_color_on_initialization
-    @configuration.generators.colorize_logging = false
-    @initializer.run(:initialize_generators)
-    assert_equal Thor::Base.shell, Thor::Shell::Basic
-  end
-
-  def test_generators_with_hashes_for_options_and_aliases
-    @configuration.generators do |g|
-      g.orm    :datamapper, :migration => false
-      g.plugin :aliases => { :generator => "-g" },
-               :generator => true
-    end
-
-    expected = {
-      :rails => { :orm => :datamapper },
-      :plugin => { :generator => true },
-      :datamapper => { :migration => false }
-    }
-
-    assert_equal expected, @configuration.generators.options
-    assert_equal({ :plugin => { :generator => "-g" } }, @configuration.generators.aliases)
-  end
-
-  def test_generators_with_hashes_are_deep_merged
-    @configuration.generators do |g|
-      g.orm    :datamapper, :migration => false
-      g.plugin :aliases => { :generator => "-g" },
-               :generator => true
-    end
-    @initializer.run(:initialize_generators)
-
-    assert Rails::Generators.aliases.size >= 1
-    assert Rails::Generators.options.size >= 1
-  end
-
-  protected
-
-    def teardown
-      Rails::Generators.clear_aliases!
-      Rails::Generators.clear_options!
-    end
-end
-
-class InitializerSetupI18nTests < Test::Unit::TestCase
-  def test_no_config_locales_dir_present_should_return_empty_load_path
-    File.stubs(:exist?).returns(false)
-    assert_equal [], Rails::Configuration.new.i18n.load_path
-  end
-
-  def test_config_locales_dir_present_should_be_added_to_load_path
-    File.stubs(:exist?).returns(true)
-    Dir.stubs(:[]).returns([ "my/test/locale.yml" ])
-    assert_equal [ "my/test/locale.yml" ], Rails::Configuration.new.i18n.load_path
-  end
-
-  def test_config_defaults_should_be_added_with_config_settings
-    File.stubs(:exist?).returns(true)
-    Dir.stubs(:[]).returns([ "my/test/locale.yml" ])
-
-    config = Rails::Configuration.new
-    config.i18n.load_path << "my/other/locale.yml"
-
-    assert_equal [ "my/test/locale.yml", "my/other/locale.yml" ], config.i18n.load_path
-  end
-end
-
-class InitializerDatabaseMiddlewareTest < Test::Unit::TestCase
-  def setup
-    @config = Rails::Configuration.new
-    @config.frameworks = [:active_record, :action_controller, :action_view]
-  end
-
-  def test_initialize_database_middleware_doesnt_perform_anything_when_active_record_not_in_frameworks
-    @config.frameworks.clear
-    @config.expects(:middleware).never
-    Rails::Initializer.run(:initialize_database_middleware, @config)
-  end
-
-  def test_database_middleware_initializes_when_session_store_is_active_record
-    store = ActionController::Base.session_store
-    ActionController::Base.session_store = ActiveRecord::SessionStore
-
-    @config.middleware.expects(:insert_before).with(:"ActiveRecord::SessionStore", ActiveRecord::ConnectionAdapters::ConnectionManagement)
-    @config.middleware.expects(:insert_before).with(:"ActiveRecord::SessionStore", ActiveRecord::QueryCache)
-
-    Rails::Initializer.run(:initialize_database_middleware, @config)
-  ensure
-    ActionController::Base.session_store = store
-  end
-
-  def test_database_middleware_doesnt_initialize_when_session_store_is_not_active_record
-    store = ActionController::Base.session_store
-    ActionController::Base.session_store = ActionDispatch::Session::CookieStore
-
-    # Define the class, so we don't have to actually make it load
-    eval("class ActiveRecord::ConnectionAdapters::ConnectionManagement; end")
-
-    @config.middleware.expects(:use).with(ActiveRecord::ConnectionAdapters::ConnectionManagement)
-    @config.middleware.expects(:use).with(ActiveRecord::QueryCache)
-
-    Rails::Initializer.run(:initialize_database_middleware, @config)
-  ensure
-    ActionController::Base.session_store = store
-  end
-
-  def test_ensure_database_middleware_doesnt_use_action_controller_on_initializing
-    @config.frameworks -= [:action_controller]
-    store = ActionController::Base.session_store
-    ActionController::Base.session_store = ActiveRecord::SessionStore
-
-    @config.middleware.expects(:use).with(ActiveRecord::ConnectionAdapters::ConnectionManagement)
-    @config.middleware.expects(:use).with(ActiveRecord::QueryCache)
-
-    Rails::Initializer.run(:initialize_database_middleware, @config)
-  ensure
-    ActionController::Base.session_store = store
-    @config.frameworks += [:action_controller]
-  end
-end
-
-class InitializerViewPathsTest  < Test::Unit::TestCase
-  def setup
-    @config = Rails::Configuration.new
-    @config.frameworks = [:action_view, :action_controller, :action_mailer]
-
-    ActionController::Base.stubs(:view_paths).returns(stub)
-    ActionMailer::Base.stubs(:view_paths).returns(stub)
-  end
-
-  def test_load_view_paths_doesnt_perform_anything_when_action_view_not_in_frameworks
-    @config.frameworks -= [:action_view]
-    ActionController::Base.view_paths.expects(:load!).never
-    ActionMailer::Base.view_paths.expects(:load!).never
-    Rails::Initializer.run(:load_view_paths, @config)
-  end
-end
-
 class RailsRootTest < Test::Unit::TestCase
   def test_rails_dot_root_equals_rails_root
     assert_equal RAILS_ROOT, Rails.root.to_s
diff --git a/railties/test/isolation/abstract_unit.rb b/railties/test/isolation/abstract_unit.rb
index c452adaa52..261e8d09dc 100644
--- a/railties/test/isolation/abstract_unit.rb
+++ b/railties/test/isolation/abstract_unit.rb
@@ -31,6 +31,10 @@ module TestHelpers
       tmp_path(*%w[app] + args)
     end
 
+    def framework_path
+      RAILS_FRAMEWORK_ROOT
+    end
+
     def rails_root
       app_path
     end
diff --git a/railties/test/new_initializer_test.rb b/railties/test/new_initializer_test.rb
deleted file mode 100644
index 67b66fb088..0000000000
--- a/railties/test/new_initializer_test.rb
+++ /dev/null
@@ -1,165 +0,0 @@
-require 'abstract_unit'
-require 'active_support/ruby/shim'
-require 'rails/initializer'
-
-class InitializerRunnerTest < ActiveSupport::TestCase
-
-  def setup
-    @runner = Rails::Initializer::Runner.new
-  end
-
-  test "A new runner can be created" do
-    assert @runner
-  end
-
-  test "The initializers actually get run when the runner is run" do
-    state = nil
-
-    @runner.add :foo do
-      run { state = true }
-    end
-
-    @runner.run
-    assert state
-  end
-
-  test "By default, initializers get run in the order that they are added" do
-    state = []
-
-    @runner.add :first do
-      run { state << :first }
-    end
-
-    @runner.add :second do
-      run { state << :second }
-    end
-
-    @runner.run
-    assert_equal [:first, :second], state
-  end
-
-  test "Raises an exception if :before or :after are specified, but don't exist" do
-    assert_raise(Rails::Initializer::Error) do
-      @runner.add(:fail, :before => :whale) { 1 }
-    end
-
-    assert_raise(Rails::Initializer::Error) do
-      @runner.add(:fail, :after => :whale) { 1 }
-    end
-  end
-
-  test "When adding an initializer, specifying :after allows you to move an initializer after another" do
-    state = []
-
-    @runner.add :first do
-      run { state << :first }
-    end
-
-    @runner.add :second do
-      run { state << :second }
-    end
-
-    @runner.add :third, :after => :first do
-      run { state << :third }
-    end
-
-    @runner.run
-    assert_equal [:first, :third, :second], state
-  end
-
-  test "An initializer can be deleted" do
-    state = []
-
-    @runner.add :first do
-      run { state << :first }
-    end
-
-    @runner.add :second do
-      run { state << :second }
-    end
-
-    @runner.delete(:second)
-
-    @runner.run
-    assert_equal [:first], state
-  end
-
-  test "A runner can be initialized with an existing runner, which it copies" do
-    state = []
-
-    @runner.add :first do
-      run { state << :first }
-    end
-
-    @runner.add :second do
-      run { state << :second }
-    end
-
-    Rails::Initializer::Runner.new(@runner).run
-    assert_equal [:first, :second], state
-  end
-
-  test "A child runner can be still be modified without modifying the parent" do
-    state = []
-
-    @runner.add :first do
-      run { state << :first }
-    end
-
-    @runner.add :second do
-      run { state << :second }
-    end
-
-    new_runner = Rails::Initializer::Runner.new(@runner)
-    new_runner.add :trois do
-      run { state << :trois }
-    end
-    new_runner.delete(:second)
-
-    new_runner.run
-    assert_equal [:first, :trois], state
-    state.clear
-    @runner.run
-    assert_equal [:first, :second], state
-  end
-
-  test "A child runner that is modified does not modify any other children of the same parent" do
-    state = []
-
-    @runner.add :first do
-      run { state << :first }
-    end
-
-    @runner.add :second do
-      run { state << :second }
-    end
-
-    child_one = Rails::Initializer::Runner.new(@runner)
-    child_two = Rails::Initializer::Runner.new(@runner)
-
-    child_one.delete(:second)
-    child_two.run
-
-    assert_equal [:first, :second], state
-  end
-
-  test "It does not run the initializer block immediately" do
-    state = []
-    @runner.add :first do
-      state << :first
-    end
-
-    assert_equal [], state
-  end
-
-  test "It runs the block when the runner is run" do
-    state = []
-    @runner.add :first do
-      state << :first
-    end
-
-    @runner.run
-    assert_equal [:first], state
-  end
-
-end
\ No newline at end of file
diff --git a/railties/test/plugin_loader_test.rb b/railties/test/plugin_loader_test.rb
index 99301347b6..0b43c49bb2 100644
--- a/railties/test/plugin_loader_test.rb
+++ b/railties/test/plugin_loader_test.rb
@@ -5,10 +5,13 @@ $:.unshift File.dirname(__FILE__) + "/../../actionmailer/lib"
 require 'action_controller'
 require 'action_mailer'
 
-# Mocks out the configuration
-module Rails
-  def self.configuration
-    Rails::Configuration.new
+# TODO: Rewrite all these tests
+class FakeInitializerSlashApplication
+  attr_reader :config
+  alias configuration config
+
+  def initialize
+    @config = Rails::Configuration.new
   end
 end
 
@@ -18,10 +21,10 @@ class TestPluginLoader < Test::Unit::TestCase
   def setup
     reset_load_path!
 
-    @configuration     = Rails::Configuration.new
+    @initializer      = FakeInitializerSlashApplication.new
+    @configuration    = @initializer.config
+    Rails.application = @initializer
     @configuration.plugin_paths << plugin_fixture_root_path
-    @initializer       = Rails::Initializer.default
-    @initializer.config = @configuration
     @valid_plugin_path = plugin_fixture_path('default/stubby')
     @empty_plugin_path = plugin_fixture_path('default/empty')
 
diff --git a/railties/test/plugin_locator_test.rb b/railties/test/plugin_locator_test.rb
index da1548dee1..ef57e7ed4c 100644
--- a/railties/test/plugin_locator_test.rb
+++ b/railties/test/plugin_locator_test.rb
@@ -1,5 +1,15 @@
 require 'plugin_test_helper'
 
+# TODO: Rewrite all these tests
+class FakeInitializerSlashApplication
+  attr_reader :config
+  alias configuration config
+
+  def initialize
+    @config = Rails::Configuration.new
+  end
+end
+
 class PluginLocatorTest < Test::Unit::TestCase
   def test_should_require_subclasses_to_implement_the_plugins_method
     assert_raise(RuntimeError) do
@@ -23,12 +33,12 @@ end
 
 class PluginFileSystemLocatorTest < Test::Unit::TestCase
   def setup
-    @configuration = Rails::Configuration.new
+    @initializer      = FakeInitializerSlashApplication.new
+    @configuration    = @initializer.config
+    Rails.application = @initializer
     # We need to add our testing plugin directory to the plugin paths so
     # the locator knows where to look for our plugins
     @configuration.plugin_paths << plugin_fixture_root_path
-    @initializer       = Rails::Initializer.default
-    @initializer.config = @configuration
     @locator           = Rails::Plugin::FileSystemLocator.new(@initializer)
     @valid_plugin_path = plugin_fixture_path('default/stubby')
     @empty_plugin_path = plugin_fixture_path('default/empty')
diff --git a/railties/test/plugin_test.rb b/railties/test/plugin_test.rb
index ae03ea4662..199adcfe39 100644
--- a/railties/test/plugin_test.rb
+++ b/railties/test/plugin_test.rb
@@ -1,9 +1,20 @@
 require 'plugin_test_helper'
 
+# TODO: Rewrite all these tests
+class FakeInitializerSlashApplication
+  attr_reader :config
+  alias configuration config
+
+  def initialize
+    @config = Rails::Configuration.new
+  end
+end
+
 class PluginTest < Test::Unit::TestCase
   def setup
-    @initializer         = Rails::Initializer.default
-    @initializer.config  = Rails::Configuration.new
+    @initializer      = FakeInitializerSlashApplication.new
+    @configuration    = @initializer.config
+    Rails.application = @initializer
     @valid_plugin_path   = plugin_fixture_path('default/stubby')
     @empty_plugin_path   = plugin_fixture_path('default/empty')
     @gemlike_plugin_path = plugin_fixture_path('default/gemlike')