diff options
Diffstat (limited to 'railties/test')
21 files changed, 571 insertions, 341 deletions
diff --git a/railties/test/application/configuration_test.rb b/railties/test/application/configuration_test.rb index 7403d16cf4..b8d0854286 100644 --- a/railties/test/application/configuration_test.rb +++ b/railties/test/application/configuration_test.rb @@ -42,7 +42,7 @@ module ApplicationTests test "Rails::Application responds to paths" do require "#{app_path}/config/environment" assert_respond_to AppTemplate::Application, :paths - assert_equal AppTemplate::Application.paths.app.views.to_a, ["#{app_path}/app/views"] + assert_equal AppTemplate::Application.paths["app/views"].expanded, ["#{app_path}/app/views"] end test "the application root is set correctly" do @@ -180,7 +180,7 @@ module ApplicationTests test "config.paths.public sets Rails.public_path" do add_to_config <<-RUBY - config.paths.public = "somewhere" + config.paths["public"] = "somewhere" RUBY require "#{app_path}/config/application" diff --git a/railties/test/application/console_test.rb b/railties/test/application/console_test.rb index 25b4a21902..d4159dd0fd 100644 --- a/railties/test/application/console_test.rb +++ b/railties/test/application/console_test.rb @@ -1,7 +1,7 @@ require 'isolation/abstract_unit' class ConsoleTest < Test::Unit::TestCase - include ActiveSupport::Testing::Isolation + include ActiveSupport::Testing::Isolation def setup build_app @@ -14,16 +14,15 @@ class ConsoleTest < Test::Unit::TestCase end def test_app_method_should_return_integration_session + TestHelpers::Rack.send :remove_method, :app load_environment console_session = app - assert_not_nil console_session assert_instance_of ActionDispatch::Integration::Session, console_session end def test_new_session_should_return_integration_session load_environment session = new_session - assert_not_nil session assert_instance_of ActionDispatch::Integration::Session, session end diff --git a/railties/test/application/generators_test.rb b/railties/test/application/generators_test.rb index d258625f42..551e966c85 100644 --- a/railties/test/application/generators_test.rb +++ b/railties/test/application/generators_test.rb @@ -69,7 +69,7 @@ module ApplicationTests assert_equal :rspec, Rails::Generators.options[:rails][:test_framework] assert_equal "-w", Rails::Generators.aliases[:rails][:test_framework] assert_equal Hash[:shoulda => :test_unit], Rails::Generators.fallbacks - assert_equal ["#{app_path}/lib/templates", "some/where"], Rails::Generators.templates_path + assert_equal ["some/where"], Rails::Generators.templates_path end test "generators no color on initialization" do diff --git a/railties/test/application/middleware/best_practices_test.rb b/railties/test/application/middleware/best_practices_test.rb new file mode 100644 index 0000000000..5b722e7510 --- /dev/null +++ b/railties/test/application/middleware/best_practices_test.rb @@ -0,0 +1,26 @@ +require 'isolation/abstract_unit' + +module ApplicationTests + class BestPracticesTest < Test::Unit::TestCase + include ActiveSupport::Testing::Isolation + + def setup + build_app + boot_rails + require 'rack/test' + extend Rack::Test::Methods + simple_controller + end + + test "simple controller in production mode returns best standards" do + get '/foo' + assert_equal "IE=Edge,chrome=1", last_response.headers["X-UA-Compatible"] + end + + test "simple controller in development mode leaves out Chrome" do + app("development") + get "/foo" + assert_equal "IE=Edge", last_response.headers["X-UA-Compatible"] + end + end +end diff --git a/railties/test/application/middleware/cache_test.rb b/railties/test/application/middleware/cache_test.rb index 5675cebfd9..f582ed0e42 100644 --- a/railties/test/application/middleware/cache_test.rb +++ b/railties/test/application/middleware/cache_test.rb @@ -11,18 +11,6 @@ module ApplicationTests extend Rack::Test::Methods end - def app(env = "production") - old_env = ENV["RAILS_ENV"] - - @app ||= begin - ENV["RAILS_ENV"] = env - require "#{app_path}/config/environment" - Rails.application - end - ensure - ENV["RAILS_ENV"] = old_env - end - def simple_controller controller :expires, <<-RUBY class ExpiresController < ApplicationController diff --git a/railties/test/application/middleware/remote_ip_test.rb b/railties/test/application/middleware/remote_ip_test.rb new file mode 100644 index 0000000000..f28302d70a --- /dev/null +++ b/railties/test/application/middleware/remote_ip_test.rb @@ -0,0 +1,63 @@ +require 'isolation/abstract_unit' + +module ApplicationTests + class RemoteIpTest < Test::Unit::TestCase + include ActiveSupport::Testing::Isolation + + def setup + build_app + boot_rails + FileUtils.rm_rf "#{app_path}/config/environments" + end + + def app + @app ||= Rails.application + end + + def remote_ip(env = {}) + remote_ip = nil + env = Rack::MockRequest.env_for("/").merge(env).merge!( + 'action_dispatch.show_exceptions' => false, + 'action_dispatch.secret_token' => 'b3c631c314c0bbca50c1b2843150fe33' + ) + + endpoint = Proc.new do |e| + remote_ip = ActionDispatch::Request.new(e).remote_ip + [200, {}, ["Hello"]] + end + + Rails.application.middleware.build(endpoint).call(env) + remote_ip + end + + test "remote_ip works" do + make_basic_app + assert_equal "1.1.1.1", remote_ip("REMOTE_ADDR" => "1.1.1.1") + end + + test "checks IP spoofing by default" do + make_basic_app + assert_raises(ActionDispatch::RemoteIp::IpSpoofAttackError) do + remote_ip("HTTP_X_FORWARDED_FOR" => "1.1.1.1", "HTTP_CLIENT_IP" => "1.1.1.2") + end + end + + test "can disable IP spoofing check" do + make_basic_app do |app| + app.config.action_dispatch.ip_spoofing_check = false + end + + assert_nothing_raised(ActionDispatch::RemoteIp::IpSpoofAttackError) do + assert_equal "1.1.1.2", remote_ip("HTTP_X_FORWARDED_FOR" => "1.1.1.1", "HTTP_CLIENT_IP" => "1.1.1.2") + end + end + + test "the user can set trusted proxies" do + make_basic_app do |app| + app.config.action_dispatch.trusted_proxies = /^4\.2\.42\.42$/ + end + + assert_equal "1.1.1.1", remote_ip("REMOTE_ADDR" => "4.2.42.42,1.1.1.1") + end + end +end diff --git a/railties/test/application/middleware/sendfile_test.rb b/railties/test/application/middleware/sendfile_test.rb new file mode 100644 index 0000000000..0128261cd4 --- /dev/null +++ b/railties/test/application/middleware/sendfile_test.rb @@ -0,0 +1,56 @@ +require 'isolation/abstract_unit' + +module ApplicationTests + class SendfileTest < Test::Unit::TestCase + include ActiveSupport::Testing::Isolation + + def setup + build_app + boot_rails + FileUtils.rm_rf "#{app_path}/config/environments" + end + + def app + @app ||= Rails.application + end + + define_method :simple_controller do + class ::OmgController < ActionController::Base + def index + send_file __FILE__ + end + end + end + + # x_sendfile_header middleware + test "config.action_dispatch.x_sendfile_header defaults to ''" do + make_basic_app + simple_controller + + get "/" + assert_equal File.read(__FILE__), last_response.body + end + + test "config.action_dispatch.x_sendfile_header can be set" do + make_basic_app do |app| + app.config.action_dispatch.x_sendfile_header = "X-Sendfile" + end + + simple_controller + + get "/" + assert_equal File.expand_path(__FILE__), last_response.headers["X-Sendfile"] + end + + test "config.action_dispatch.x_sendfile_header is sent to Rack::Sendfile" do + make_basic_app do |app| + app.config.action_dispatch.x_sendfile_header = 'X-Lighttpd-Send-File' + end + + simple_controller + + get "/" + assert_equal File.expand_path(__FILE__), last_response.headers["X-Lighttpd-Send-File"] + end + end +end diff --git a/railties/test/application/middleware_test.rb b/railties/test/application/middleware_test.rb index f9b594eb33..173ac40b12 100644 --- a/railties/test/application/middleware_test.rb +++ b/railties/test/application/middleware_test.rb @@ -36,6 +36,8 @@ module ApplicationTests "ActionDispatch::ParamsParser", "Rack::MethodOverride", "ActionDispatch::Head", + "Rack::ConditionalGet", + "Rack::ETag", "ActionDispatch::BestStandardsSupport" ], middleware end @@ -45,27 +47,7 @@ module ApplicationTests boot! - assert_equal [ - "Rack::Cache", - "ActionDispatch::Static", - "Rack::Lock", - "ActiveSupport::Cache::Strategy::LocalCache", - "Rack::Runtime", - "Rails::Rack::Logger", - "ActionDispatch::ShowExceptions", - "ActionDispatch::RemoteIp", - "Rack::Sendfile", - "ActionDispatch::Callbacks", - "ActiveRecord::ConnectionAdapters::ConnectionManagement", - "ActiveRecord::QueryCache", - "ActionDispatch::Cookies", - "ActionDispatch::Session::CookieStore", - "ActionDispatch::Flash", - "ActionDispatch::ParamsParser", - "Rack::MethodOverride", - "ActionDispatch::Head", - "ActionDispatch::BestStandardsSupport" - ], middleware + assert_equal "Rack::Cache", middleware.first end test "removing Active Record omits its middleware" do @@ -129,81 +111,46 @@ module ApplicationTests assert_equal "Rack::Config", middleware.first end - # x_sendfile_header middleware - test "config.action_dispatch.x_sendfile_header defaults to ''" do + # ConditionalGet + Etag + test "conditional get + etag middlewares handle http caching based on body" do make_basic_app class ::OmgController < ActionController::Base def index - send_file __FILE__ - end - end - - get "/" - assert_equal File.read(__FILE__), last_response.body - end - - test "config.action_dispatch.x_sendfile_header can be set" do - make_basic_app do |app| - app.config.action_dispatch.x_sendfile_header = "X-Sendfile" - end - - class ::OmgController < ActionController::Base - def index - send_file __FILE__ + if params[:nothing] + render :text => "" + else + render :text => "OMG" + end end end - get "/" - assert_equal File.expand_path(__FILE__), last_response.headers["X-Sendfile"] - end - - test "config.action_dispatch.x_sendfile_header is sent to Rack::Sendfile" do - make_basic_app do |app| - app.config.action_dispatch.x_sendfile_header = 'X-Lighttpd-Send-File' - end - - class ::OmgController < ActionController::Base - def index - send_file __FILE__ - end - end + etag = "5af83e3196bf99f440f31f2e1a6c9afe".inspect get "/" - assert_equal File.expand_path(__FILE__), last_response.headers["X-Lighttpd-Send-File"] - end - - # remote_ip tests - test "remote_ip works" do - make_basic_app - assert_equal "1.1.1.1", remote_ip("REMOTE_ADDR" => "1.1.1.1") - end - - test "checks IP spoofing by default" do - make_basic_app - assert_raises(ActionDispatch::RemoteIp::IpSpoofAttackError) do - remote_ip("HTTP_X_FORWARDED_FOR" => "1.1.1.1", "HTTP_CLIENT_IP" => "1.1.1.2") - end - end - - test "can disable IP spoofing check" do - make_basic_app do |app| - app.config.action_dispatch.ip_spoofing_check = false - end - - assert_nothing_raised(ActionDispatch::RemoteIp::IpSpoofAttackError) do - assert_equal "1.1.1.2", remote_ip("HTTP_X_FORWARDED_FOR" => "1.1.1.1", "HTTP_CLIENT_IP" => "1.1.1.2") - end - end - - test "the user can set trusted proxies" do - make_basic_app do |app| - app.config.action_dispatch.trusted_proxies = /^4\.2\.42\.42$/ - end - - assert_equal "1.1.1.1", remote_ip("REMOTE_ADDR" => "4.2.42.42,1.1.1.1") - end - + assert_equal 200, last_response.status + assert_equal "OMG", last_response.body + assert_equal "text/html; charset=utf-8", last_response.headers["Content-Type"] + assert_equal "max-age=0, private, must-revalidate", last_response.headers["Cache-Control"] + assert_equal etag, last_response.headers["Etag"] + + get "/", {}, "HTTP_IF_NONE_MATCH" => etag + assert_equal 304, last_response.status + assert_equal "", last_response.body + assert_equal nil, last_response.headers["Content-Type"] + assert_equal "max-age=0, private, must-revalidate", last_response.headers["Cache-Control"] + assert_equal etag, last_response.headers["Etag"] + + get "/?nothing=true" + puts last_response.body + assert_equal 200, last_response.status + assert_equal "", last_response.body + assert_equal "text/html; charset=utf-8", last_response.headers["Content-Type"] + assert_equal "no-cache", last_response.headers["Cache-Control"] + assert_equal nil, last_response.headers["Etag"] + end + + # Show exceptions middleware test "show exceptions middleware filter backtrace before logging" do my_middleware = Struct.new(:app) do def call(env) @@ -232,21 +179,5 @@ module ApplicationTests def middleware AppTemplate::Application.middleware.map(&:klass).map(&:name) end - - def remote_ip(env = {}) - remote_ip = nil - env = Rack::MockRequest.env_for("/").merge(env).merge!( - 'action_dispatch.show_exceptions' => false, - 'action_dispatch.secret_token' => 'b3c631c314c0bbca50c1b2843150fe33' - ) - - endpoint = Proc.new do |e| - remote_ip = ActionDispatch::Request.new(e).remote_ip - [200, {}, ["Hello"]] - end - - Rails.application.middleware.build(endpoint).call(env) - remote_ip - end end end diff --git a/railties/test/application/paths_test.rb b/railties/test/application/paths_test.rb index c98b11556b..b1ff6e9cb1 100644 --- a/railties/test/application/paths_test.rb +++ b/railties/test/application/paths_test.rb @@ -25,7 +25,7 @@ module ApplicationTests end def assert_path(paths, *dir) - assert_equal [root(*dir)], paths.paths + assert_equal [root(*dir)], paths.expanded end def assert_in_load_path(*path) @@ -37,20 +37,20 @@ module ApplicationTests end test "booting up Rails yields a valid paths object" do - assert_path @paths.app.models, "app", "models" - assert_path @paths.app.helpers, "app", "helpers" - assert_path @paths.app.views, "app", "views" - assert_path @paths.lib, "lib" - assert_path @paths.vendor, "vendor" - assert_path @paths.vendor.plugins, "vendor", "plugins" - assert_path @paths.tmp, "tmp" - assert_path @paths.tmp.cache, "tmp", "cache" - assert_path @paths.config, "config" - assert_path @paths.config.locales, "config", "locales", "en.yml" - assert_path @paths.config.environment, "config", "environment.rb" - assert_path @paths.config.environments, "config", "environments", "development.rb" + assert_path @paths["app/models"], "app/models" + assert_path @paths["app/helpers"], "app/helpers" + assert_path @paths["app/views"], "app/views" + assert_path @paths["lib"], "lib" + assert_path @paths["vendor"], "vendor" + assert_path @paths["vendor/plugins"], "vendor/plugins" + assert_path @paths["tmp"], "tmp" + assert_path @paths["tmp/cache"], "tmp/cache" + assert_path @paths["config"], "config" + assert_path @paths["config/locales"], "config/locales/en.yml" + assert_path @paths["config/environment"], "config/environment.rb" + assert_path @paths["config/environments"], "config/environments/development.rb" - assert_equal root("app", "controllers"), @paths.app.controllers.to_a.first + assert_equal root("app", "controllers"), @paths["app/controllers"].expanded.first end test "booting up Rails yields a list of paths that are eager" do diff --git a/railties/test/application/routing_test.rb b/railties/test/application/routing_test.rb index 416a5de5b0..62589c998d 100644 --- a/railties/test/application/routing_test.rb +++ b/railties/test/application/routing_test.rb @@ -11,34 +11,6 @@ module ApplicationTests extend Rack::Test::Methods end - def app(env = "production") - old_env = ENV["RAILS_ENV"] - - @app ||= begin - ENV["RAILS_ENV"] = env - require "#{app_path}/config/environment" - Rails.application - end - ensure - ENV["RAILS_ENV"] = old_env - end - - def simple_controller - controller :foo, <<-RUBY - class FooController < ApplicationController - def index - render :text => "foo" - end - end - RUBY - - app_file 'config/routes.rb', <<-RUBY - AppTemplate::Application.routes.draw do - match ':controller(/:action)' - end - RUBY - end - test "rails/info/properties in development" do app("development") get "/rails/info/properties" @@ -58,21 +30,6 @@ module ApplicationTests assert_equal 'foo', last_response.body end - test "simple controller in production mode returns best standards" do - simple_controller - - get '/foo' - assert_equal "IE=Edge,chrome=1", last_response.headers["X-UA-Compatible"] - end - - test "simple controller in development mode leaves out Chrome" do - simple_controller - app("development") - - get "/foo" - assert_equal "IE=Edge", last_response.headers["X-UA-Compatible"] - end - test "simple controller with helper" do controller :foo, <<-RUBY class FooController < ApplicationController @@ -177,7 +134,7 @@ module ApplicationTests assert_equal 'admin::foo', last_response.body end - def test_reloads_appended_route_blocks + test "routes appending blocks" do app_file 'config/routes.rb', <<-RUBY AppTemplate::Application.routes.draw do match ':controller#:action' @@ -246,9 +203,12 @@ module ApplicationTests test 'routes are loaded just after initialization' do require "#{app_path}/config/application" - app_file 'config/routes.rb', <<-RUBY - InitializeRackApp = lambda { |env| [200, {}, ["InitializeRackApp"]] } + # Create the rack app just inside after initialize callback + ActiveSupport.on_load(:after_initialize) do + ::InitializeRackApp = lambda { |env| [200, {}, ["InitializeRackApp"]] } + end + app_file 'config/routes.rb', <<-RUBY AppTemplate::Application.routes.draw do match 'foo', :to => ::InitializeRackApp end @@ -258,7 +218,14 @@ module ApplicationTests assert_equal "InitializeRackApp", last_response.body end - test 'resource routing with irrigular inflection' do + test 'reload_routes! is part of Rails.application API' do + app("development") + assert_nothing_raised do + Rails.application.reload_routes! + end + end + + test 'resource routing with irregular inflection' do app_file 'config/initializers/inflection.rb', <<-RUBY ActiveSupport::Inflector.inflections do |inflect| inflect.irregular 'yazi', 'yazilar' diff --git a/railties/test/generators/app_generator_test.rb b/railties/test/generators/app_generator_test.rb index 3653b067c8..51277b805b 100644 --- a/railties/test/generators/app_generator_test.rb +++ b/railties/test/generators/app_generator_test.rb @@ -165,9 +165,13 @@ class AppGeneratorTest < Rails::Generators::TestCase assert_file "Gemfile", /^gem\s+["']mysql2["']$/ end - def test_config_database_is_not_added_if_skip_active_record_is_given + def test_generator_if_skip_active_record_is_given run_generator [destination_root, "--skip-active-record"] assert_no_file "config/database.yml" + assert_file "test/test_helper.rb" do |helper_content| + assert_no_match /fixtures :all/, helper_content + end + assert_file "test/performance/browsing_test.rb" end def test_active_record_is_removed_from_frameworks_if_skip_active_record_is_given diff --git a/railties/test/generators/generated_attribute_test.rb b/railties/test/generators/generated_attribute_test.rb index 272e179fe3..064546a3f3 100644 --- a/railties/test/generators/generated_attribute_test.rb +++ b/railties/test/generators/generated_attribute_test.rb @@ -117,7 +117,7 @@ class GeneratedAttributeTest < Rails::Generators::TestCase def test_missing_type_raises_exception assert_raise Thor::Error do - create_generated_attribute(:'', 'title') + create_generated_attribute('', 'title') end end end diff --git a/railties/test/generators/mailer_generator_test.rb b/railties/test/generators/mailer_generator_test.rb index 450dec7716..f4fdc46328 100644 --- a/railties/test/generators/mailer_generator_test.rb +++ b/railties/test/generators/mailer_generator_test.rb @@ -59,6 +59,15 @@ class MailerGeneratorTest < Rails::Generators::TestCase assert_match /haml \[not found\]/, content end + def test_mailer_with_namedspaced_mailer + run_generator ["Farm::Animal", "moos"] + assert_file "app/mailers/farm/animal.rb" do |mailer| + assert_match /class Farm::Animal < ActionMailer::Base/, mailer + assert_match /en\.farm\.animal\.moos\.subject/, mailer + end + assert_file "app/views/farm/animal/moos.text.erb" + end + def test_actions_are_turned_into_methods run_generator diff --git a/railties/test/generators/namespaced_generators_test.rb b/railties/test/generators/namespaced_generators_test.rb index 38b95a49ac..d1190fd17d 100644 --- a/railties/test/generators/namespaced_generators_test.rb +++ b/railties/test/generators/namespaced_generators_test.rb @@ -6,14 +6,14 @@ require 'rails/generators/mailer/mailer_generator' class NamespacedGeneratorTestCase < Rails::Generators::TestCase def setup - TestApp::Application.namespace(TestApp) + TestApp::Application.isolate_namespace(TestApp) end def teardown if TestApp.respond_to?(:_railtie) TestApp.singleton_class.send(:undef_method, :_railtie) TestApp.singleton_class.send(:undef_method, :table_name_prefix) - TestApp::Application.namespaced = false + TestApp::Application.isolated = false end end end diff --git a/railties/test/isolation/abstract_unit.rb b/railties/test/isolation/abstract_unit.rb index 79c7735019..3b03e4eb3d 100644 --- a/railties/test/isolation/abstract_unit.rb +++ b/railties/test/isolation/abstract_unit.rb @@ -45,6 +45,17 @@ module TestHelpers end module Rack + def app(env = "production") + old_env = ENV["RAILS_ENV"] + @app ||= begin + ENV["RAILS_ENV"] = env + require "#{app_path}/config/environment" + Rails.application + end + ensure + ENV["RAILS_ENV"] = old_env + end + def extract_body(response) "".tap do |body| response[2].each {|chunk| body << chunk } @@ -124,6 +135,22 @@ module TestHelpers extend ::Rack::Test::Methods end + def simple_controller + controller :foo, <<-RUBY + class FooController < ApplicationController + def index + render :text => "foo" + end + end + RUBY + + app_file 'config/routes.rb', <<-RUBY + AppTemplate::Application.routes.draw do + match ':controller(/:action)' + end + RUBY + end + class Bukkit attr_reader :path diff --git a/railties/test/paths_test.rb b/railties/test/paths_test.rb index 80fae8c543..6e4e3446b3 100644 --- a/railties/test/paths_test.rb +++ b/railties/test/paths_test.rb @@ -20,234 +20,264 @@ class PathsTest < ActiveSupport::TestCase test "a paths object initialized with nil can be updated" do root = Rails::Paths::Root.new(nil) - root.app = "app" + root.add "app" root.path = "/root" - assert_equal ["/root/app"], root.app.to_a + assert_equal ["app"], root["app"] + assert_equal ["/root/app"], root["app"].to_a end test "creating a root level path" do - @root.app = "/foo/bar" - assert_equal ["/foo/bar"], @root.app.to_a + @root.add "app" + assert_equal ["/foo/bar/app"], @root["app"].to_a + end + + test "creating a root level path with options" do + @root.add "app", :with => "/foo/bar" + assert_equal ["/foo/bar"], @root["app"].to_a end test "raises exception if root path never set" do root = Rails::Paths::Root.new(nil) - root.app = "app" + root.add "app" assert_raises RuntimeError do - root.app.to_a + root["app"].to_a end end - test "creating a root level path without assignment" do - @root.app "/foo/bar" - assert_equal ["/foo/bar"], @root.app.to_a - end - - test "trying to access a path that does not exist raises NoMethodError" do - assert_raises(NoMethodError) { @root.app } - end - - test "relative paths are relative to the paths root" do - @root.app = "app" - assert_equal ["/foo/bar/app"], @root.app.to_a - end - - test "relative paths are relative to the paths root without assignment" do - @root.app "app" - assert_equal ["/foo/bar/app"], @root.app.to_a - end - test "creating a child level path" do - @root.app = "/foo/bar" - @root.app.models = "/foo/bar/baz" - assert_equal ["/foo/bar/baz"], @root.app.models.to_a + @root.add "app" + @root.add "app/models" + assert_equal ["/foo/bar/app/models"], @root["app/models"].to_a end - test "creating a child level path without assignment" do - @root.app = "/foo/bar" - @root.app.models "/foo/bar/baz" - assert_equal ["/foo/bar/baz"], @root.app.models.to_a + test "creating a child level path with option" do + @root.add "app" + @root.add "app/models", :with => "/foo/bar/baz" + assert_equal ["/foo/bar/baz"], @root["app/models"].to_a end test "child level paths are relative from the root" do - @root.app = "/app" - @root.app.models = "baz" - - assert_equal ["/foo/bar/baz"], @root.app.models.to_a + @root.add "app" + @root.add "app/models", :with => "baz" + assert_equal ["/foo/bar/baz"], @root["app/models"].to_a end test "adding multiple physical paths as an array" do - @root.app = ["/app", "/app2"] - assert_equal ["/app", "/app2"], @root.app.to_a - end - - test "adding multiple physical paths as an array without assignment" do - @root.app "/app", "/app2" - assert_equal ["/app", "/app2"], @root.app.to_a + @root.add "app", :with => ["/app", "/app2"] + assert_equal ["/app", "/app2"], @root["app"].to_a end test "adding multiple physical paths using #push" do - @root.app = "/app" - @root.app.push "/app2" - assert_equal ["/app", "/app2"], @root.app.to_a + @root.add "app" + @root["app"].push "app2" + assert_equal ["/foo/bar/app", "/foo/bar/app2"], @root["app"].to_a end test "adding multiple physical paths using <<" do - @root.app = "/app" - @root.app << "/app2" - assert_equal ["/app", "/app2"], @root.app.to_a + @root.add "app" + @root["app"] << "app2" + assert_equal ["/foo/bar/app", "/foo/bar/app2"], @root["app"].to_a end test "adding multiple physical paths using concat" do - @root.app = "/app" - @root.app.concat ["/app2", "/app3"] - assert_equal ["/app", "/app2", "/app3"], @root.app.to_a + @root.add "app" + @root["app"].concat ["app2", "/app3"] + assert_equal ["/foo/bar/app", "/foo/bar/app2", "/app3"], @root["app"].to_a end test "adding multiple physical paths using #unshift" do - @root.app = "/app" - @root.app.unshift "/app2" - assert_equal ["/app2", "/app"], @root.app.to_a + @root.add "app" + @root["app"].unshift "app2" + assert_equal ["/foo/bar/app2", "/foo/bar/app"], @root["app"].to_a end test "the root can only have one physical path" do assert_raise(RuntimeError) { Rails::Paths::Root.new(["/fiz", "/biz"]) } - assert_raise(RuntimeError) { @root.push "/biz" } - assert_raise(RuntimeError) { @root.unshift "/biz" } - assert_raise(RuntimeError) { @root.concat ["/biz"]} - assert_raise(RuntimeError) { @root << "/biz" } end test "it is possible to add a path that should be autoloaded only once" do - @root.app = "/app" - @root.app.autoload_once! - assert @root.app.autoload_once? - assert @root.autoload_once.include?(@root.app.paths.first) + @root.add "app", :with => "/app" + @root["app"].autoload_once! + assert @root["app"].autoload_once? + assert @root.autoload_once.include?(@root["app"].expanded.first) end test "it is possible to remove a path that should be autoloaded only once" do - @root.app = "/app" - @root.app.autoload_once! - assert @root.app.autoload_once? + @root["app"] = "/app" + @root["app"].autoload_once! + assert @root["app"].autoload_once? - @root.app.skip_autoload_once! - assert !@root.app.autoload_once? - assert !@root.autoload_once.include?(@root.app.paths.first) + @root["app"].skip_autoload_once! + assert !@root["app"].autoload_once? + assert !@root.autoload_once.include?(@root["app"].expanded.first) end test "it is possible to add a path without assignment and specify it should be loaded only once" do - @root.app "/app", :autoload_once => true - assert @root.app.autoload_once? + @root.add "app", :with => "/app", :autoload_once => true + assert @root["app"].autoload_once? assert @root.autoload_once.include?("/app") end test "it is possible to add multiple paths without assignment and specify it should be loaded only once" do - @root.app "/app", "/app2", :autoload_once => true - assert @root.app.autoload_once? + @root.add "app", :with => ["/app", "/app2"], :autoload_once => true + assert @root["app"].autoload_once? assert @root.autoload_once.include?("/app") assert @root.autoload_once.include?("/app2") end test "making a path autoload_once more than once only includes it once in @root.load_once" do - @root.app = "/app" - @root.app.autoload_once! - @root.app.autoload_once! - assert_equal 1, @root.autoload_once.select {|p| p == @root.app.paths.first }.size + @root["app"] = "/app" + @root["app"].autoload_once! + @root["app"].autoload_once! + assert_equal 1, @root.autoload_once.select {|p| p == @root["app"].expanded.first }.size end test "paths added to a load_once path should be added to the autoload_once collection" do - @root.app = "/app" - @root.app.autoload_once! - @root.app << "/app2" + @root["app"] = "/app" + @root["app"].autoload_once! + @root["app"] << "/app2" assert_equal 2, @root.autoload_once.size end test "it is possible to mark a path as eager loaded" do - @root.app = "/app" - @root.app.eager_load! - assert @root.app.eager_load? - assert @root.eager_load.include?(@root.app.paths.first) + @root["app"] = "/app" + @root["app"].eager_load! + assert @root["app"].eager_load? + assert @root.eager_load.include?(@root["app"].to_a.first) end test "it is possible to skip a path from eager loading" do - @root.app = "/app" - @root.app.eager_load! - assert @root.app.eager_load? + @root["app"] = "/app" + @root["app"].eager_load! + assert @root["app"].eager_load? - @root.app.skip_eager_load! - assert !@root.app.eager_load? - assert !@root.eager_load.include?(@root.app.paths.first) + @root["app"].skip_eager_load! + assert !@root["app"].eager_load? + assert !@root.eager_load.include?(@root["app"].to_a.first) end test "it is possible to add a path without assignment and mark it as eager" do - @root.app "/app", :eager_load => true - assert @root.app.eager_load? + @root.add "app", :with => "/app", :eager_load => true + assert @root["app"].eager_load? assert @root.eager_load.include?("/app") end test "it is possible to add multiple paths without assignment and mark them as eager" do - @root.app "/app", "/app2", :eager_load => true - assert @root.app.eager_load? + @root.add "app", :with => ["/app", "/app2"], :eager_load => true + assert @root["app"].eager_load? assert @root.eager_load.include?("/app") assert @root.eager_load.include?("/app2") end test "it is possible to create a path without assignment and mark it both as eager and load once" do - @root.app "/app", :eager_load => true, :autoload_once => true - assert @root.app.eager_load? - assert @root.app.autoload_once? + @root.add "app", :with => "/app", :eager_load => true, :autoload_once => true + assert @root["app"].eager_load? + assert @root["app"].autoload_once? assert @root.eager_load.include?("/app") assert @root.autoload_once.include?("/app") end test "making a path eager more than once only includes it once in @root.eager_paths" do - @root.app = "/app" - @root.app.eager_load! - @root.app.eager_load! - assert_equal 1, @root.eager_load.select {|p| p == @root.app.paths.first }.size + @root["app"] = "/app" + @root["app"].eager_load! + @root["app"].eager_load! + assert_equal 1, @root.eager_load.select {|p| p == @root["app"].expanded.first }.size end test "paths added to a eager_load path should be added to the eager_load collection" do - @root.app = "/app" - @root.app.eager_load! - @root.app << "/app2" + @root["app"] = "/app" + @root["app"].eager_load! + @root["app"] << "/app2" assert_equal 2, @root.eager_load.size end test "it should be possible to add a path's default glob" do - @root.app = "/app" - @root.app.glob = "*.rb" - assert_equal "*.rb", @root.app.glob + @root["app"] = "/app" + @root["app"].glob = "*.rb" + assert_equal "*.rb", @root["app"].glob end test "it should be possible to override a path's default glob without assignment" do - @root.app "/app", :glob => "*.rb" - assert_equal "*.rb", @root.app.glob + @root.add "app", :with => "/app", :glob => "*.rb" + assert_equal "*.rb", @root["app"].glob end test "a path can be added to the load path" do - @root.app = "app" - @root.app.load_path! - @root.app.models = "app/models" + @root["app"] = "app" + @root["app"].load_path! + @root["app/models"] = "app/models" assert_equal ["/foo/bar/app"], @root.load_paths end test "a path can be added to the load path on creation" do - @root.app "/app", :load_path => true - assert @root.app.load_path? + @root.add "app", :with => "/app", :load_path => true + assert @root["app"].load_path? assert_equal ["/app"], @root.load_paths end test "a path can be marked as autoload path" do - @root.app = "app" - @root.app.autoload! - @root.app.models = "app/models" + @root["app"] = "app" + @root["app"].autoload! + @root["app/models"] = "app/models" assert_equal ["/foo/bar/app"], @root.autoload_paths end test "a path can be marked as autoload on creation" do - @root.app "/app", :autoload => true - assert @root.app.autoload? + @root.add "app", :with => "/app", :autoload => true + assert @root["app"].autoload? assert_equal ["/app"], @root.autoload_paths end + + # Deprecated API tests + + test "reading a root level path with assignment" do + @root.add "app" + assert_deprecated do + assert_equal ["/foo/bar/app"], @root.app.to_a + end + end + + test "creating a root level path with assignment" do + assert_deprecated do + @root.app = "/foo/bar" + end + assert_equal ["/foo/bar"], @root["app"].to_a + end + + test "creating a root level path without assignment" do + assert_deprecated do + @root.app "/foo/bar" + end + assert_equal ["/foo/bar"], @root["app"].to_a + end + + test "reading a nested level path with assignment" do + @root.add "app" + @root.add "app/model" + assert_deprecated do + assert_equal ["/foo/bar/app/model"], @root.app.model.to_a + end + end + + test "creating a nested level path with assignment" do + @root.add "app" + assert_deprecated do + @root.app.model = "/foo/bar" + end + assert_equal ["/foo/bar"], @root["app/model"].to_a + end + + test "creating a nested level path without assignment" do + @root.add "app" + assert_deprecated do + @root.app.model "/foo/bar" + end + assert_equal ["/foo/bar"], @root["app/model"].to_a + end + + test "trying to access a path that does not exist raises NoMethodError" do + assert_deprecated do + assert_raises(NoMethodError) { @root.app } + end + end end diff --git a/railties/test/railties/engine_test.rb b/railties/test/railties/engine_test.rb index a9dd7d4c1b..db74e41472 100644 --- a/railties/test/railties/engine_test.rb +++ b/railties/test/railties/engine_test.rb @@ -62,17 +62,18 @@ module RailtiesTest def call(env) response = @app.call(env) - response[2].upcase! + response[2].each { |b| b.upcase! } response end end test "engine is a rack app and can have his own middleware stack" do + add_to_config("config.action_dispatch.show_exceptions = false") + @plugin.write "lib/bukkits.rb", <<-RUBY class Bukkits class Engine < ::Rails::Engine - endpoint lambda { |env| [200, {'Content-Type' => 'text/html'}, 'Hello World'] } - + endpoint lambda { |env| [200, {'Content-Type' => 'text/html'}, ['Hello World']] } config.middleware.use ::RailtiesTest::EngineTest::Upcaser end end @@ -89,7 +90,7 @@ module RailtiesTest env = Rack::MockRequest.env_for("/bukkits") response = Rails.application.call(env) - assert_equal "HELLO WORLD", response[2] + assert_equal ["HELLO WORLD"], response[2] end test "it provides routes as default endpoint" do @@ -102,7 +103,7 @@ module RailtiesTest @plugin.write "config/routes.rb", <<-RUBY Bukkits::Engine.routes.draw do - match "/foo" => lambda { |env| [200, {'Content-Type' => 'text/html'}, 'foo'] } + match "/foo" => lambda { |env| [200, {'Content-Type' => 'text/html'}, ['foo']] } end RUBY @@ -116,8 +117,7 @@ module RailtiesTest env = Rack::MockRequest.env_for("/bukkits/foo") response = Rails.application.call(env) - - assert_equal "foo", response[2] + assert_equal ["foo"], response[2] end test "engine can load its own plugins" do @@ -379,22 +379,22 @@ module RailtiesTest env = Rack::MockRequest.env_for("/foo") response = Rails.application.call(env) - assert_equal "Something... Something... Something...", response[2].body + assert_equal ["Something... Something... Something..."], response[2] env = Rack::MockRequest.env_for("/foo/show") response = Rails.application.call(env) - assert_equal "/foo", response[2].body + assert_equal ["/foo"], response[2] env = Rack::MockRequest.env_for("/foo/bar") response = Rails.application.call(env) - assert_equal "It's a bar.", response[2].body + assert_equal ["It's a bar."], response[2] end test "isolated engine should include only its own routes and helpers" do @plugin.write "lib/bukkits.rb", <<-RUBY module Bukkits class Engine < ::Rails::Engine - namespace Bukkits + isolate_namespace Bukkits end end RUBY @@ -488,30 +488,30 @@ module RailtiesTest env = Rack::MockRequest.env_for("/bukkits/from_app") response = AppTemplate::Application.call(env) - assert_equal "false", response[2].body + assert_equal ["false"], response[2] env = Rack::MockRequest.env_for("/bukkits/foo/show") response = AppTemplate::Application.call(env) - assert_equal "/bukkits/foo", response[2].body + assert_equal ["/bukkits/foo"], response[2] env = Rack::MockRequest.env_for("/bukkits/foo") response = AppTemplate::Application.call(env) - assert_equal "Helped.", response[2].body + assert_equal ["Helped."], response[2] env = Rack::MockRequest.env_for("/bukkits/routes_helpers_in_view") response = AppTemplate::Application.call(env) - assert_equal "/bukkits/foo, /bar", response[2].body + assert_equal ["/bukkits/foo, /bar"], response[2] env = Rack::MockRequest.env_for("/bukkits/polymorphic_path_without_namespace") response = AppTemplate::Application.call(env) - assert_equal "/bukkits/posts/1", response[2].body + assert_equal ["/bukkits/posts/1"], response[2] end test "isolated engine should avoid namespace in names if that's possible" do @plugin.write "lib/bukkits.rb", <<-RUBY module Bukkits class Engine < ::Rails::Engine - namespace Bukkits + isolate_namespace Bukkits end end RUBY @@ -553,11 +553,11 @@ module RailtiesTest end RUBY - @plugin.write "app/views/bukkits/posts/new.html.erb", <<-RUBY + @plugin.write "app/views/bukkits/posts/new.html.erb", <<-ERB <%= form_for(Bukkits::Post.new) do |f| %> <%= f.text_field :title %> <% end %> - RUBY + ERB add_to_config("config.action_dispatch.show_exceptions = false") @@ -572,7 +572,7 @@ module RailtiesTest @plugin.write "lib/bukkits.rb", <<-RUBY module Bukkits class Engine < ::Rails::Engine - namespace(Bukkits) + isolate_namespace(Bukkits) end end RUBY @@ -593,8 +593,8 @@ module RailtiesTest @plugin.write "lib/bukkits.rb", <<-RUBY module Bukkits class Engine < ::Rails::Engine - namespace(Bukkits) - config.paths.public = "#{File.join(@plugin.path, "alternate_public")}" + isolate_namespace(Bukkits) + paths["public"] = "#{File.join(@plugin.path, "alternate_public")}" end end RUBY @@ -611,8 +611,8 @@ module RailtiesTest @plugin.write "lib/bukkits.rb", <<-RUBY module Bukkits class Engine < ::Rails::Engine - namespace(Bukkits) - config.paths.public = "#{File.join(@plugin.path, "not_existing")}" + isolate_namespace(Bukkits) + paths["public"] = "#{File.join(@plugin.path, "not_existing")}" end end RUBY @@ -643,5 +643,104 @@ module RailtiesTest Bukkits::Engine.load_seed assert Bukkits::Engine.config.bukkits_seeds_loaded end + + test "using namespace more than once on one module should not overwrite _railtie method" do + @plugin.write "lib/bukkits.rb", <<-RUBY + module AppTemplate + class Engine < ::Rails::Engine + isolate_namespace(AppTemplate) + end + end + RUBY + + add_to_config "isolate_namespace AppTemplate" + + app_file "config/routes.rb", <<-RUBY + AppTemplate::Application.routes.draw do end + RUBY + + boot_rails + + assert_equal AppTemplate._railtie, AppTemplate::Engine + end + + test "properly reload routes" do + # when routes are inside application class definition + # they should not be reloaded when engine's routes + # file has changed + add_to_config <<-RUBY + routes do + mount lambda{|env| [200, {}, ["foo"]]} => "/foo" + mount Bukkits::Engine => "/bukkits" + end + RUBY + + FileUtils.rm(File.join(app_path, "config/routes.rb")) + + @plugin.write "config/routes.rb", <<-RUBY + Bukkits::Engine.routes.draw do + mount lambda{|env| [200, {}, ["bar"]]} => "/bar" + end + RUBY + + @plugin.write "lib/bukkits.rb", <<-RUBY + module Bukkits + class Engine < ::Rails::Engine + isolate_namespace(Bukkits) + end + end + RUBY + + require 'rack/test' + extend Rack::Test::Methods + + boot_rails + + require "#{rails_root}/config/environment" + get "/foo" + assert_equal "foo", last_response.body + + get "/bukkits/bar" + assert_equal "bar", last_response.body + end + + test "setting generators for engine and overriding app generator's" do + @plugin.write "lib/bukkits.rb", <<-RUBY + module Bukkits + class Engine < ::Rails::Engine + config.generators do |g| + g.orm :datamapper + g.template_engine :haml + g.test_framework :rspec + end + + config.app_generators do |g| + g.orm :mongoid + g.template_engine :liquid + g.test_framework :shoulda + end + end + end + RUBY + + add_to_config <<-RUBY + config.generators do |g| + g.test_framework :test_unit + end + RUBY + + boot_rails + require "#{rails_root}/config/environment" + + app_generators = Rails.application.config.generators.options[:rails] + assert_equal :mongoid , app_generators[:orm] + assert_equal :liquid , app_generators[:template_engine] + assert_equal :test_unit, app_generators[:test_framework] + + generators = Bukkits::Engine.config.generators.options[:rails] + assert_equal :datamapper, generators[:orm] + assert_equal :haml , generators[:template_engine] + assert_equal :rspec , generators[:test_framework] + end end end diff --git a/railties/test/railties/mounted_engine_test.rb b/railties/test/railties/mounted_engine_test.rb index b52ced92ec..47a4753e78 100644 --- a/railties/test/railties/mounted_engine_test.rb +++ b/railties/test/railties/mounted_engine_test.rb @@ -49,7 +49,7 @@ module ApplicationTests @plugin.write "lib/blog.rb", <<-RUBY module Blog class Engine < ::Rails::Engine - namespace(Blog) + isolate_namespace(Blog) end end RUBY diff --git a/railties/test/railties/plugin_test.rb b/railties/test/railties/plugin_test.rb index bae05d6978..c15ac05103 100644 --- a/railties/test/railties/plugin_test.rb +++ b/railties/test/railties/plugin_test.rb @@ -110,7 +110,7 @@ module RailtiesTest boot_rails rescue Exception => e rescued = true - assert_equal '"bukkits" is a Railtie/Engine and cannot be installed as plugin', e.message + assert_equal '"bukkits" is a Railtie/Engine and cannot be installed as a plugin', e.message end assert rescued, "Expected boot rails to fail" diff --git a/railties/test/railties/railtie_test.rb b/railties/test/railties/railtie_test.rb index 406d5d764f..6d194eecba 100644 --- a/railties/test/railties/railtie_test.rb +++ b/railties/test/railties/railtie_test.rb @@ -103,6 +103,30 @@ module RailtiesTest assert $ran_block end + test "rake_tasks block defined in superclass of railtie is also executed" do + $ran_block = [] + + class Rails::Railtie + rake_tasks do + $ran_block << railtie_name + end + end + + class MyTie < Rails::Railtie + railtie_name "my_tie" + end + + require "#{app_path}/config/environment" + + assert_equal [], $ran_block + require 'rake' + require 'rake/testtask' + require 'rake/rdoctask' + + AppTemplate::Application.load_tasks + assert $ran_block.include?("my_tie") + end + test "generators block is executed when MyApp.load_generators is called" do $ran_block = false diff --git a/railties/test/railties/shared_tests.rb b/railties/test/railties/shared_tests.rb index 9b62f88fd7..b1d7580dff 100644 --- a/railties/test/railties/shared_tests.rb +++ b/railties/test/railties/shared_tests.rb @@ -21,6 +21,11 @@ module RailtiesTest end RUBY + @plugin.write "db/migrate/3_create_sessions.rb", <<-RUBY + class CreateSessions < ActiveRecord::Migration + end + RUBY + app_file "db/migrate/1_create_sessions.rb", <<-RUBY class CreateSessions < ActiveRecord::Migration end @@ -38,24 +43,26 @@ module RailtiesTest add_to_config "ActiveRecord::Base.timestamped_migrations = false" Dir.chdir(app_path) do - output = `rake railties:copy_migrations FROM=bukkits` + output = `rake bukkits:install:migrations 2>&1` - assert File.exists?("#{app_path}/db/migrate/2_create_users.bukkits.rb") - assert File.exists?("#{app_path}/db/migrate/3_add_last_name_to_users.bukkits.rb") - assert_match /2_create_users/, output - assert_match /3_add_last_name_to_users/, output + assert File.exists?("#{app_path}/db/migrate/2_create_users.rb") + assert File.exists?("#{app_path}/db/migrate/3_add_last_name_to_users.rb") + assert_match /Copied migration 2_create_users.rb from bukkits/, output + assert_match /Copied migration 3_add_last_name_to_users.rb from bukkits/, output + assert_match /WARNING: Migration 3_create_sessions.rb from bukkits has been skipped/, output assert_equal 3, Dir["#{app_path}/db/migrate/*.rb"].length - output = `rake railties:copy_migrations` + output = `rake railties:install:migrations 2>&1` - assert File.exists?("#{app_path}/db/migrate/4_create_yaffles.acts_as_yaffle.rb") - assert_match /4_create_yaffles/, output + assert File.exists?("#{app_path}/db/migrate/4_create_yaffles.rb") + assert_match /WARNING: Migration 3_create_sessions.rb from bukkits has been skipped/, output + assert_match /Copied migration 4_create_yaffles.rb from acts_as_yaffle/, output + assert_no_match /2_create_users/, output migrations_count = Dir["#{app_path}/db/migrate/*.rb"].length - output = `rake railties:copy_migrations` + output = `rake railties:install:migrations 2>&1` assert_equal migrations_count, Dir["#{app_path}/db/migrate/*.rb"].length - assert_match /No migrations were copied/, output end end |