railties/test/application/generators_test.rb @@ -16,7 +16,7 @@ module ActionController #:nodoc: self.session_store = ActiveRecord::SessionStore else @@session_store = store.is_a?(Symbol) ? - Session.const_get(store.to_s.camelize) : + ActionDispatch::Session.const_get(store.to_s.camelize) : store end end actionpack/lib/action_controller/metal/session_management.rb @@ -1,8 +1,11 @@ module ActionView #:nodoc: class PathSet < Array #:nodoc: - def self.type_cast(obj) + def self.type_cast(obj, cache = nil) + # TODO: Clean this up if obj.is_a?(String) - cache = !defined?(Rails) || !Rails.respond_to?(:configuration) || Rails.configuration.cache_classes + if cache.nil? + cache = !defined?(Rails) || Rails.application.config.cache_classes + end FileSystemResolverWithFallback.new(obj, :cache => cache) else obj actionpack/lib/action_view/paths.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 railties/lib/rails/application.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? railties/lib/rails/core.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 railties/lib/rails/initializer.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 railties/test/application/initializer_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] railties/test/application/plugins_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) railties/test/initializer/path_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 railties/test/initializer_test.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 railties/test/isolation/abstract_unit.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') railties/test/plugin_loader_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') railties/test/plugin_locator_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') railties/test/plugin_test.rb railties/test/new_initializer_test.rb 5c42157cd83b022d05738c6759e38536f74fc572 Carl Lerche carllerche carllerche@mac.com http://github.com/rails/rails/commit/992c2db76cd6cd6aa9a6ba3711a6ea1ad8910062 992c2db76cd6cd6aa9a6ba3711a6ea1ad8910062 2009-10-08T18:12:28-07:00 2009-10-08T18:12:28-07:00 Finish porting over the initializers to the app object and fix all the tests 83cde462f67aa72eff043e392756ded1ebdf424c Carl Lerche carllerche carllerche@mac.com