1 files changed, 56 insertions, 45 deletions
diff --git a/activesupport/test/dependencies_test.rb b/activesupport/test/dependencies_test.rb
index 68b6cc6e8c..4ca63b3417 100644
--- a/activesupport/test/dependencies_test.rb
+++ b/activesupport/test/dependencies_test.rb
@@ -35,6 +35,17 @@ class DependenciesTest < ActiveSupport::TestCase
     assert_equal expected.path, e.path
   end
 
+  def test_require_dependency_accepts_an_object_which_implements_to_path
+    o = Object.new
+    def o.to_path; 'dependencies/service_one'; end
+    assert_nothing_raised {
+      require_dependency o
+    }
+    assert defined?(ServiceOne)
+  ensure
+    remove_constants(:ServiceOne)
+  end
+
   def test_tracking_loaded_files
     require_dependency 'dependencies/service_one'
     require_dependency 'dependencies/service_two'
@@ -62,12 +73,11 @@ class DependenciesTest < ActiveSupport::TestCase
       $raises_exception_load_count = 0
 
       5.times do |count|
-        begin
+        e = assert_raise Exception, 'should have loaded dependencies/raises_exception which raises an exception' do
           require_dependency filename
-          flunk 'should have loaded dependencies/raises_exception which raises an exception'
-        rescue Exception => e
-          assert_equal 'Loading me failed, so do not add to loaded or history.', e.message
         end
+
+        assert_equal 'Loading me failed, so do not add to loaded or history.', e.message
         assert_equal count + 1, $raises_exception_load_count
 
         assert !ActiveSupport::Dependencies.loaded.include?(filename)
@@ -355,26 +365,19 @@ class DependenciesTest < ActiveSupport::TestCase
 
   def test_non_existing_const_raises_name_error_with_fully_qualified_name
     with_autoloading_fixtures do
-      begin
-        A::DoesNotExist.nil?
-        flunk "No raise!!"
-      rescue NameError => e
-        assert_equal "uninitialized constant A::DoesNotExist", e.message
-      end
-      begin
-        A::B::DoesNotExist.nil?
-        flunk "No raise!!"
-      rescue NameError => e
-        assert_equal "uninitialized constant A::B::DoesNotExist", e.message
-      end
+      e = assert_raise(NameError) { A::DoesNotExist.nil? }
+      assert_equal "uninitialized constant A::DoesNotExist", e.message
+
+      e = assert_raise(NameError) { A::B::DoesNotExist.nil? }
+      assert_equal "uninitialized constant A::B::DoesNotExist", e.message
     end
   end
 
   def test_smart_name_error_strings
-    Object.module_eval "ImaginaryObject"
-    flunk "No raise!!"
-  rescue NameError => e
-    assert e.message.include?("uninitialized constant ImaginaryObject")
+    e = assert_raise NameError do
+      Object.module_eval "ImaginaryObject"
+    end
+    assert_includes "uninitialized constant ImaginaryObject", e.message
   end
 
   def test_loadable_constants_for_path_should_handle_empty_autoloads
@@ -519,29 +522,21 @@ class DependenciesTest < ActiveSupport::TestCase
     end
   end
 
-  def test_const_missing_should_not_double_load
-    $counting_loaded_times = 0
+  def test_const_missing_in_anonymous_modules_loads_top_level_constants
     with_autoloading_fixtures do
-      require_dependency '././counting_loader'
-      assert_equal 1, $counting_loaded_times
-      assert_raise(NameError) { ActiveSupport::Dependencies.load_missing_constant Object, :CountingLoader }
-      assert_equal 1, $counting_loaded_times
+      # class_eval STRING pushes the class to the nesting of the eval'ed code.
+      klass = Class.new.class_eval "E"
+      assert_equal E, klass
     end
   end
 
-  def test_const_missing_within_anonymous_module
-    $counting_loaded_times = 0
-    m = Module.new
-    m.module_eval "def a() CountingLoader; end"
-    extend m
+  def test_const_missing_in_anonymous_modules_raises_if_the_constant_belongs_to_Object
     with_autoloading_fixtures do
-      kls = nil
-      assert_nothing_raised { kls = a }
-      assert_equal "CountingLoader", kls.name
-      assert_equal 1, $counting_loaded_times
+      require_dependency 'e'
 
-      assert_nothing_raised { kls = a }
-      assert_equal 1, $counting_loaded_times
+      mod = Module.new
+      e = assert_raise(NameError) { mod::E }
+      assert_equal 'E cannot be autoloaded from an anonymous class or module', e.message
     end
   end
 
@@ -550,12 +545,10 @@ class DependenciesTest < ActiveSupport::TestCase
       c = ServiceOne
       ActiveSupport::Dependencies.clear
       assert ! defined?(ServiceOne)
-      begin
+      e = assert_raise ArgumentError do
         ActiveSupport::Dependencies.load_missing_constant(c, :FakeMissing)
-        flunk "Expected exception"
-      rescue ArgumentError => e
-        assert_match %r{ServiceOne has been removed from the module tree}i, e.message
       end
+      assert_match %r{ServiceOne has been removed from the module tree}i, e.message
     end
   end
 
@@ -647,6 +640,14 @@ class DependenciesTest < ActiveSupport::TestCase
     Object.class_eval { remove_const :E }
   end
 
+  def test_constants_in_capitalized_nesting_marked_as_autoloaded
+    with_autoloading_fixtures do
+      ActiveSupport::Dependencies.load_missing_constant(HTML, "SomeClass")
+
+      assert ActiveSupport::Dependencies.autoloaded?("HTML::SomeClass")
+    end
+  end
+
   def test_unloadable
     with_autoloading_fixtures do
       Object.const_set :M, Module.new
@@ -886,12 +887,10 @@ class DependenciesTest < ActiveSupport::TestCase
     with_autoloading_fixtures do
       Object.send(:remove_const, :RaisesNameError) if defined?(::RaisesNameError)
       2.times do
-        begin
+        e = assert_raise NameError do
           ::RaisesNameError::FooBarBaz.object_id
-          flunk 'should have raised NameError when autoloaded file referenced FooBarBaz'
-        rescue NameError => e
-          assert_equal 'uninitialized constant RaisesNameError::FooBarBaz', e.message
         end
+        assert_equal 'uninitialized constant RaisesNameError::FooBarBaz', e.message
         assert !defined?(::RaisesNameError), "::RaisesNameError is defined but it should have failed!"
       end
 
@@ -949,6 +948,18 @@ class DependenciesTest < ActiveSupport::TestCase
     Object.class_eval { remove_const :A if const_defined?(:A) }
   end
 
+  def test_access_unloaded_constants_for_reload
+    with_autoloading_fixtures do
+      assert_kind_of Module, A
+      assert_kind_of Class, A::B # Necessary to load A::B for the test
+      ActiveSupport::Dependencies.mark_for_unload(A::B)
+      ActiveSupport::Dependencies.remove_unloadable_constants!
+       
+      A::B # Make sure no circular dependency error
+    end
+  end
+
+
   def test_autoload_once_paths_should_behave_when_recursively_loading
     with_loading 'dependencies', 'autoloading_fixtures' do
       ActiveSupport::Dependencies.autoload_once_paths = [ActiveSupport::Dependencies.autoload_paths.last]