Merge remote branch 'mainstream/master'

6 files changed, 405 insertions, 191 deletions

diff --git a/railties/test/application/configuration_test.rb b/railties/test/application/configuration_test.rb
index a3e1916494..79dfacdcdb 100644
--- a/railties/test/application/configuration_test.rb
+++ b/railties/test/application/configuration_test.rb
@@ -4,9 +4,19 @@ module ApplicationTests
   class InitializerTest < Test::Unit::TestCase
     include ActiveSupport::Testing::Isolation
 
+    def new_app
+      File.expand_path("#{app_path}/../new_app")
+    end
+
+    def copy_app
+      FileUtils.cp_r(app_path, new_app)
+    end
+
     def setup
+      FileUtils.rm_rf(new_app) if File.directory?(new_app)
       build_app
       boot_rails
+      FileUtils.rm_rf("#{app_path}/config/environments")
     end
 
     test "the application root is set correctly" do
@@ -14,35 +24,103 @@ module ApplicationTests
       assert_equal Pathname.new(app_path), Rails.application.root
     end
 
+    test "the application root can be seen from the application singleton" do
+      require "#{app_path}/config/environment"
+      assert_equal Pathname.new(app_path), AppTemplate::Application.root
+    end
+
     test "the application root can be set" do
-      FileUtils.mkdir_p("#{app_path}/hello")
+      copy_app
       add_to_config <<-RUBY
-        config.frameworks = []
-        config.root = '#{app_path}/hello'
+        config.root = '#{new_app}'
       RUBY
+
+      use_frameworks []
+
+      require "#{app_path}/config/environment"
+      assert_equal Pathname.new(new_app), Rails.application.root
+    end
+
+    test "the application root is Dir.pwd if there is no config.ru" do
+      File.delete("#{app_path}/config.ru")
+
+      use_frameworks []
+
+      Dir.chdir("#{app_path}") do
+        require "#{app_path}/config/environment"
+        assert_equal Pathname.new("#{app_path}"), Rails.application.root
+      end
+    end
+
+    test "if there's no config.active_support.bare, all of ActiveSupport is required" do
+      use_frameworks []
       require "#{app_path}/config/environment"
-      assert_equal Pathname.new("#{app_path}/hello"), Rails.application.root
+      assert_nothing_raised { [1,2,3].rand }
     end
 
-    test "the application root is detected as where config.ru is located" do
+    test "config.active_support.bare does not require all of ActiveSupport" do
+      add_to_config "config.active_support.bare = true"
+
+      use_frameworks []
+
+      Dir.chdir("#{app_path}/app") do
+        require "#{app_path}/config/environment"
+        assert_raises(NoMethodError) { [1,2,3].rand }
+      end
+    end
+
+    test "marking the application as threadsafe sets the correct config variables" do
       add_to_config <<-RUBY
-        config.frameworks = []
+        config.threadsafe!
       RUBY
-      FileUtils.mv "#{app_path}/config.ru", "#{app_path}/config/config.ru"
+
+      require "#{app_path}/config/application"
+      assert AppTemplate::Application.config.action_controller.allow_concurrency
+    end
+
+    test "the application can be marked as threadsafe when there are no frameworks" do
+      FileUtils.rm_rf("#{app_path}/config/environments")
+      add_to_config <<-RUBY
+        config.threadsafe!
+      RUBY
+
+      use_frameworks []
+
+      assert_nothing_raised do
+        require "#{app_path}/config/application"
+      end
+    end
+
+    test "Frameworks are not preloaded by default" do
       require "#{app_path}/config/environment"
-      assert_equal Pathname.new("#{app_path}/config"), Rails.application.root
+
+      assert ActionController.autoload?(:RecordIdentifier)
     end
 
-    test "the application root is Dir.pwd if there is no config.ru" do
-      File.delete("#{app_path}/config.ru")
+    test "frameworks are preloaded with config.preload_frameworks is set" do
       add_to_config <<-RUBY
-        config.frameworks = []
+        config.preload_frameworks = true
       RUBY
 
-      Dir.chdir("#{app_path}/app") do
+      require "#{app_path}/config/environment"
+
+      assert !ActionController.autoload?(:RecordIdentifier)
+    end
+
+    test "runtime error is raised if config.frameworks= is used" do
+      add_to_config "config.frameworks = []"
+
+      assert_raises RuntimeError do
+        require "#{app_path}/config/environment"
+      end
+    end
+
+    test "runtime error is raised if config.frameworks is used" do
+      add_to_config "config.frameworks -= []"
+
+      assert_raises RuntimeError do
         require "#{app_path}/config/environment"
-        assert_equal Pathname.new("#{app_path}/app"), Rails.application.root
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/railties/test/application/generators_test.rb b/railties/test/application/generators_test.rb
index ccbcd84176..0c858d6394 100644
--- a/railties/test/application/generators_test.rb
+++ b/railties/test/application/generators_test.rb
@@ -7,12 +7,20 @@ module ApplicationTests
     def setup
       build_app
       boot_rails
-      require "rails"
+    end
+
+    def app_const
+      @app_const ||= Class.new(Rails::Application)
+    end
+
+    def with_config
+      require "rails/all"
       require "rails/generators"
+      yield app_const.config
     end
 
     test "generators default values" do
-      Rails::Initializer.run do |c|
+      with_config do |c|
         assert_equal(true, c.generators.colorize_logging)
         assert_equal({}, c.generators.aliases)
         assert_equal({}, c.generators.options)
@@ -20,7 +28,7 @@ module ApplicationTests
     end
 
     test "generators set rails options" do
-      Rails::Initializer.run do |c|
+      with_config do |c|
         c.generators.orm            = :datamapper
         c.generators.test_framework = :rspec
         c.generators.helper         = false
@@ -30,7 +38,7 @@ module ApplicationTests
     end
 
     test "generators set rails aliases" do
-      Rails::Initializer.run do |c|
+      with_config do |c|
         c.generators.aliases = { :rails => { :test_framework => "-w" } }
         expected = { :rails => { :test_framework => "-w" } }
         assert_equal expected, c.generators.aliases
@@ -38,14 +46,15 @@ module ApplicationTests
     end
 
     test "generators aliases and options on initialization" do
-      Rails::Initializer.run do |c|
-        c.frameworks = []
-        c.generators.rails :aliases => { :test_framework => "-w" }
-        c.generators.orm :datamapper
-        c.generators.test_framework :rspec
-      end
+      add_to_config <<-RUBY
+        config.generators.rails :aliases => { :test_framework => "-w" }
+        config.generators.orm :datamapper
+        config.generators.test_framework :rspec
+      RUBY
+
+      require "#{app_path}/config/environment"
       # Initialize the application
-      Rails.initialize!
+      require "rails/generators"
       Rails::Generators.configure!
 
       assert_equal :rspec, Rails::Generators.options[:rails][:test_framework]
@@ -53,19 +62,20 @@ module ApplicationTests
     end
 
     test "generators no color on initialization" do
-      Rails::Initializer.run do |c|
-        c.frameworks = []
-        c.generators.colorize_logging = false
-      end
+      add_to_config <<-RUBY
+        config.generators.colorize_logging = false
+      RUBY
+
       # Initialize the application
-      Rails.initialize!
+      require "#{app_path}/config/environment"
+      require "rails/generators"
       Rails::Generators.configure!
 
       assert_equal Thor::Base.shell, Thor::Shell::Basic
     end
 
     test "generators with hashes for options and aliases" do
-      Rails::Initializer.run do |c|
+      with_config do |c|
         c.generators do |g|
           g.orm    :datamapper, :migration => false
           g.plugin :aliases => { :generator => "-g" },
@@ -84,7 +94,7 @@ module ApplicationTests
     end
 
     test "generators with hashes are deep merged" do
-      Rails::Initializer.run do |c|
+      with_config do |c|
         c.generators do |g|
           g.orm    :datamapper, :migration => false
           g.plugin :aliases => { :generator => "-g" },
diff --git a/railties/test/application/initializer_test.rb b/railties/test/application/initializer_test.rb
index 719520bf68..3fd0b0e5df 100644
--- a/railties/test/application/initializer_test.rb
+++ b/railties/test/application/initializer_test.rb
@@ -7,45 +7,18 @@ module ApplicationTests
     def setup
       build_app
       boot_rails
-      require "rails"
-    end
-
-    test "initializing an application initializes rails" do
-      Rails::Initializer.run do |config|
-        config.root = app_path
-      end
-
-      if RUBY_VERSION < '1.9'
-        $KCODE = ''
-        Rails.initialize!
-        assert_equal 'UTF8', $KCODE
-      else
-        Encoding.default_external = Encoding::US_ASCII
-        Rails.initialize!
-        assert_equal Encoding::UTF_8, Encoding.default_external
-      end
+      FileUtils.rm_rf "#{app_path}/config/environments"
     end
 
     test "initializing an application adds the application paths to the load path" do
-      Rails::Initializer.run do |config|
-        config.root = app_path
-      end
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+      RUBY
 
-      Rails.initialize!
+      require "#{app_path}/config/environment"
       assert $:.include?("#{app_path}/app/models")
     end
 
-    test "adding an unknown framework raises an error" do
-      Rails::Initializer.run do |config|
-        config.root = app_path
-        config.frameworks << :action_foo
-      end
-
-      assert_raises RuntimeError do
-        Rails.initialize!
-      end
-    end
-
     test "eager loading loads parent classes before children" do
       app_file "lib/zoo.rb", <<-ZOO
         class Zoo ; include ReptileHouse ; end
@@ -54,12 +27,12 @@ module ApplicationTests
         module Zoo::ReptileHouse ; end
       ZOO
 
-      Rails::Initializer.run do |config|
-        config.root = app_path
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
         config.eager_load_paths = "#{app_path}/lib"
-      end
+      RUBY
 
-      Rails.initialize!
+      require "#{app_path}/config/environment"
 
       assert Zoo
     end
@@ -67,41 +40,44 @@ module ApplicationTests
     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 { |config| config.root = app_path }
-      Rails.initialize!
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+      RUBY
+      require "#{app_path}/config/environment"
       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.root = app_path
-          config.frameworks = []
-        end
-        Rails.initialize!
+        add_to_config <<-RUBY
+          config.root = "#{app_path}"
+        RUBY
+
+        use_frameworks []
+        require "#{app_path}/config/environment"
       end
     end
 
     test "after_initialize block works correctly" do
-      Rails::Initializer.run do |config|
-        config.root = app_path
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
         config.after_initialize { $test_after_initialize_block1 = "success" }
         config.after_initialize { $test_after_initialize_block2 = "congratulations" }
-      end
-      Rails.initialize!
+      RUBY
+      require "#{app_path}/config/environment"
 
       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.root = app_path
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
         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
-      Rails.initialize!
+      RUBY
+      require "#{app_path}/config/environment"
 
       assert_equal "success", $test_after_initialize_block1
       assert_equal "congratulations", $test_after_initialize_block2
@@ -109,35 +85,40 @@ module ApplicationTests
 
     # i18n
     test "setting another default locale" do
-      Rails::Initializer.run do |config|
-        config.root = app_path
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
         config.i18n.default_locale = :de
-      end
-      Rails.initialize!
+      RUBY
+      require "#{app_path}/config/environment"
 
       assert_equal :de, I18n.default_locale
     end
 
     test "no config locales dir present should return empty load path" do
       FileUtils.rm_rf "#{app_path}/config/locales"
-      Rails::Initializer.run do |c|
-        c.root = app_path
-        assert_equal [], c.i18n.load_path
-      end
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+      RUBY
+      require "#{app_path}/config/environment"
+
+      assert_equal [], Rails.application.config.i18n.load_path
     end
 
     test "config locales dir present should be added to load path" do
-      Rails::Initializer.run do |c|
-        c.root = app_path
-        assert_equal ["#{app_path}/config/locales/en.yml"], c.i18n.load_path
-      end
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+      RUBY
+
+      require "#{app_path}/config/environment"
+      assert_equal ["#{app_path}/config/locales/en.yml"],  Rails.application.config.i18n.load_path
     end
 
     test "config defaults should be added with config settings" do
-      Rails::Initializer.run do |c|
-        c.root = app_path
-        c.i18n.load_path << "my/other/locale.yml"
-      end
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+        config.i18n.load_path << "my/other/locale.yml"
+      RUBY
+      require "#{app_path}/config/environment"
 
       assert_equal [
         "#{app_path}/config/locales/en.yml", "my/other/locale.yml"
@@ -146,64 +127,48 @@ module ApplicationTests
 
     # DB middleware
     test "database middleware doesn't initialize when session store is not active_record" do
-      Rails::Initializer.run do |config|
-        config.root = app_path
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
         config.action_controller.session_store = :cookie_store
-      end
-      Rails.initialize!
+      RUBY
+      require "#{app_path}/config/environment"
 
       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.root = app_path
-        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.root = app_path
-        c.action_controller.session_store = :active_record_store
-      end
-      Rails.initialize!
+      add_to_config "config.action_controller.session_store = :active_record_store"
+
+      require "#{app_path}/config/environment"
 
       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.root = app_path
-        c.frameworks -= [:action_controller]
-        c.action_controller.session_store = :active_record_store
-      end
-      Rails.initialize!
-
-      assert !Rails.application.config.middleware.include?(ActiveRecord::SessionStore)
+    test "Rails.root should be a Pathname" do
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+      RUBY
+      require "#{app_path}/config/environment"
+      assert_instance_of Pathname, Rails.root
     end
+  end
 
-    # Pathview test
-    test "load view paths doesn't perform anything when action_view not in frameworks" do
-      Rails::Initializer.run do |c|
-        c.root = app_path
-        c.frameworks -= [:action_view]
-      end
-      Rails.initialize!
+  class InitializerCustomFrameworkExtensionsTest < Test::Unit::TestCase
+    include ActiveSupport::Testing::Isolation
 
-      assert_equal nil, ActionMailer::Base.template_root
-      assert_equal [], ActionController::Base.view_paths
+    def setup
+      build_app
+      boot_rails
+      FileUtils.rm_rf "#{app_path}/config/environments"
     end
 
-    test "Rails.root should be a Pathname" do
-      Rails::Initializer.run do |c|
-        c.root = app_path
-      end
-      Rails.initialize!
-      assert_instance_of Pathname, Rails.root
+    test "database middleware doesn't initialize when activerecord is not in frameworks" do
+      use_frameworks []
+      require "#{app_path}/config/environment"
+
+      assert_nil defined?(ActiveRecord)
     end
   end
-end
\ No newline at end of file
+end
diff --git a/railties/test/application/load_test.rb b/railties/test/application/load_test.rb
index 3da51c4355..1c5811b07a 100644
--- a/railties/test/application/load_test.rb
+++ b/railties/test/application/load_test.rb
@@ -1,27 +1,13 @@
 require "isolation/abstract_unit"
-# require "rails"
-# require 'action_dispatch'
 
 module ApplicationTests
   class LoadTest < Test::Unit::TestCase
     include ActiveSupport::Testing::Isolation
 
     def rackup
-      config = "#{app_path}/config.ru"
-      # Copied from ActionDispatch::Utils.parse_config
-      # ActionDispatch is not necessarily available at this point.
-      require 'rack'
-      if config =~ /\.ru$/
-        cfgfile = ::File.read(config)
-        if cfgfile[/^#\\(.*)/]
-          opts.parse! $1.split(/\s+/)
-        end
-        inner_app = eval "Rack::Builder.new {( " + cfgfile + "\n )}.to_app",
-                         nil, config
-      else
-        require config
-        inner_app = Object.const_get(::File.basename(config, '.rb').capitalize)
-      end
+      require "rack"
+      app, options = Rack::Builder.parse_file("#{app_path}/config.ru")
+      app
     end
 
     def setup
@@ -34,20 +20,22 @@ module ApplicationTests
     end
 
     test "config.ru can be racked up" do
-      @app = rackup
-      assert_welcome get("/")
+      Dir.chdir app_path do
+        @app = rackup
+        assert_welcome get("/")
+      end
     end
 
     test "Rails.application is available after config.ru has been racked up" do
       rackup
-      assert Rails.application < Rails::Application
+      assert Rails.application.is_a?(Rails::Application)
     end
 
     # Passenger still uses AC::Dispatcher, so we need to
     # keep it working for now
     test "deprecated ActionController::Dispatcher still works" do
       rackup
-      assert ActionController::Dispatcher.new < Rails::Application
+      assert ActionController::Dispatcher.new.is_a?(Rails::Application)
     end
 
     test "the config object is available on the application object" do
diff --git a/railties/test/application/notifications_test.rb b/railties/test/application/notifications_test.rb
index 62ed4f4ad4..b57e829cca 100644
--- a/railties/test/application/notifications_test.rb
+++ b/railties/test/application/notifications_test.rb
@@ -1,46 +1,39 @@
 require "isolation/abstract_unit"
 
 module ApplicationTests
-  class NotificationsTest < Test::Unit::TestCase
-    include ActiveSupport::Testing::Isolation
-
-    class MyQueue
-      attr_reader :events, :subscribers
-
-      def initialize
-        @events = []
-        @subscribers = []
-      end
-
-      def publish(name, *args)
-        @events << name
-      end
+  class MyQueue
+    def publish(name, *args)
+      raise name
+    end
 
-      def subscribe(pattern=nil, &block)
-        @subscribers << pattern
-      end
+    # Not a full queue implementation
+    def method_missing(name, *args, &blk)
+      self
     end
+  end
+
+  class NotificationsTest < Test::Unit::TestCase
+    include ActiveSupport::Testing::Isolation
 
     def setup
       build_app
       boot_rails
-      require "rails"
+      FileUtils.rm_rf("#{app_path}/config/environments")
       require "active_support/notifications"
-      Rails::Initializer.run do |c|
-        c.notifications.queue = MyQueue.new
-        c.notifications.subscribe(/listening/) do
-          puts "Cool"
-        end
-      end
+      @events = []
+
+      add_to_config <<-RUBY
+        config.notifications.notifier = ActiveSupport::Notifications::Notifier.new(ApplicationTests::MyQueue.new)
+      RUBY
     end
 
     test "new queue is set" do
-      ActiveSupport::Notifications.instrument(:foo)
-      assert_equal :foo, ActiveSupport::Notifications.queue.events.first
-    end
+      use_frameworks []
+      require "#{app_path}/config/environment"
 
-    test "configuration subscribers are loaded" do
-      assert_equal 1, ActiveSupport::Notifications.queue.subscribers.count { |s| s == /listening/ }
+      assert_raise RuntimeError do
+        ActiveSupport::Notifications.publish('foo')
+      end
     end
   end
 end
diff --git a/railties/test/application/routing_test.rb b/railties/test/application/routing_test.rb
new file mode 100644
index 0000000000..725dd06929
--- /dev/null
+++ b/railties/test/application/routing_test.rb
@@ -0,0 +1,180 @@
+require 'isolation/abstract_unit'
+
+module ApplicationTests
+  class RoutingTest < Test::Unit::TestCase
+    include ActiveSupport::Testing::Isolation
+
+    def setup
+      build_app
+      boot_rails
+      require 'rack/test'
+      extend Rack::Test::Methods
+    end
+
+    def app
+      @app ||= begin
+        require "#{app_path}/config/environment"
+
+        Rails.application
+      end
+    end
+
+    test "rails/info/properties" do
+      get "/rails/info/properties"
+      assert_equal 200, last_response.status
+    end
+
+    test "simple controller" do
+      controller :foo, <<-RUBY
+        class FooController < ActionController::Base
+          def index
+            render :text => "foo"
+          end
+        end
+      RUBY
+
+      app_file 'config/routes.rb', <<-RUBY
+        AppTemplate::Application.routes.draw do |map|
+          match ':controller(/:action)'
+        end
+      RUBY
+
+      get '/foo'
+      assert_equal 'foo', last_response.body
+    end
+
+    test "multiple controllers" do
+      controller :foo, <<-RUBY
+        class FooController < ActionController::Base
+          def index
+            render :text => "foo"
+          end
+        end
+      RUBY
+
+      controller :bar, <<-RUBY
+        class BarController < ActionController::Base
+          def index
+            render :text => "bar"
+          end
+        end
+      RUBY
+
+      app_file 'config/routes.rb', <<-RUBY
+        AppTemplate::Application.routes.draw do |map|
+          match ':controller(/:action)'
+        end
+      RUBY
+
+      get '/foo'
+      assert_equal 'foo', last_response.body
+
+      get '/bar'
+      assert_equal 'bar', last_response.body
+    end
+
+    test "nested controller" do
+      controller 'foo', <<-RUBY
+        class FooController < ActionController::Base
+          def index
+            render :text => "foo"
+          end
+        end
+      RUBY
+
+      controller 'admin/foo', <<-RUBY
+        module Admin
+          class FooController < ActionController::Base
+            def index
+              render :text => "admin::foo"
+            end
+          end
+        end
+      RUBY
+
+      app_file 'config/routes.rb', <<-RUBY
+        AppTemplate::Application.routes.draw do |map|
+          match ':controller(/:action)'
+        end
+      RUBY
+
+      get '/foo'
+      assert_equal 'foo', last_response.body
+
+      get '/admin/foo'
+      assert_equal 'admin::foo', last_response.body
+    end
+
+    test "merges with plugin routes" do
+      controller 'foo', <<-RUBY
+        class FooController < ActionController::Base
+          def index
+            render :text => "foo"
+          end
+        end
+      RUBY
+
+      app_file 'config/routes.rb', <<-RUBY
+        AppTemplate::Application.routes.draw do |map|
+          match 'foo', :to => 'foo#index'
+        end
+      RUBY
+
+      plugin 'bar', 'require File.dirname(__FILE__) + "/app/controllers/bar"' do |plugin|
+        plugin.write 'app/controllers/bar.rb', <<-RUBY
+          class BarController < ActionController::Base
+            def index
+              render :text => "bar"
+            end
+          end
+        RUBY
+
+        plugin.write 'config/routes.rb', <<-RUBY
+          AppTemplate::Application.routes.draw do |map|
+            match 'bar', :to => 'bar#index'
+          end
+        RUBY
+      end
+
+      get '/foo'
+      assert_equal 'foo', last_response.body
+
+      get '/bar'
+      assert_equal 'bar', last_response.body
+    end
+
+    test "reloads routes when configuration is changed" do
+      controller :foo, <<-RUBY
+        class FooController < ActionController::Base
+          def bar
+            render :text => "bar"
+          end
+
+          def baz
+            render :text => "baz"
+          end
+        end
+      RUBY
+
+      app_file 'config/routes.rb', <<-RUBY
+        AppTemplate::Application.routes.draw do |map|
+          match 'foo', :to => 'foo#bar'
+        end
+      RUBY
+
+      get '/foo'
+      assert_equal 'bar', last_response.body
+
+      app_file 'config/routes.rb', <<-RUBY
+        AppTemplate::Application.routes.draw do |map|
+          match 'foo', :to => 'foo#baz'
+        end
+      RUBY
+
+      sleep 0.1
+
+      get '/foo'
+      assert_equal 'baz', last_response.body
+    end
+  end
+end