Merge pull request #27035 from rails/remove-active-support-deprecations

Remove Active Support deprecations

9 files changed, 0 insertions, 457 deletions

diff --git a/activesupport/test/caching_test.rb b/activesupport/test/caching_test.rb
index f489ded1be..551235e9e8 100644
--- a/activesupport/test/caching_test.rb
+++ b/activesupport/test/caching_test.rb
@@ -566,12 +566,6 @@ module CacheStoreBehavior
   ensure
     ActiveSupport::Notifications.unsubscribe "cache_read.active_support"
   end
-
-  def test_can_call_deprecated_namesaced_key
-    assert_deprecated "`namespaced_key` is deprecated" do
-      @cache.send(:namespaced_key, 111, {})
-    end
-  end
 end
 
 # https://rails.lighthouseapp.com/projects/8994/tickets/6225-memcachestore-cant-deal-with-umlauts-and-special-characters
@@ -747,15 +741,6 @@ module LocalCacheBehavior
     app = @cache.middleware.new(app)
     app.call({})
   end
-
-  def test_can_call_deprecated_set_cache_value
-    @cache.with_local_cache do
-      assert_deprecated "`set_cache_value` is deprecated" do
-        @cache.send(:set_cache_value, 1, "foo", :ignored, {})
-      end
-      assert_equal 1, @cache.read("foo")
-    end
-  end
 end
 
 module AutoloadingCacheBehavior
@@ -918,12 +903,6 @@ class FileStoreTest < ActiveSupport::TestCase
     @cache.write(1, nil)
     assert_equal false, @cache.write(1, "aaaaaaaaaa", unless_exist: true)
   end
-
-  def test_can_call_deprecated_key_file_path
-    assert_deprecated "`key_file_path` is deprecated" do
-      assert_equal 111, @cache.send(:key_file_path, 111)
-    end
-  end
 end
 
 class MemoryStoreTest < ActiveSupport::TestCase
@@ -1098,12 +1077,6 @@ class MemCacheStoreTest < ActiveSupport::TestCase
     value << "bingo"
     assert_not_equal value, @cache.read("foo")
   end
-
-  def test_can_call_deprecated_escape_key
-    assert_deprecated "`escape_key` is deprecated" do
-      assert_equal 111, @cache.send(:escape_key, 111)
-    end
-  end
 end
 
 class NullStoreTest < ActiveSupport::TestCase
diff --git a/activesupport/test/core_ext/hash_ext_test.rb b/activesupport/test/core_ext/hash_ext_test.rb
index d35fa491a2..8b816b3aad 100644
--- a/activesupport/test/core_ext/hash_ext_test.rb
+++ b/activesupport/test/core_ext/hash_ext_test.rb
@@ -1051,13 +1051,6 @@ class HashExtTest < ActiveSupport::TestCase
     assert_nothing_raised { hash.to_hash }
   end
 
-  def test_new_from_hash_copying_default_should_not_raise_when_default_proc_does
-    hash = Hash.new
-    hash.default_proc = proc { |h, k| raise "walrus" }
-
-    assert_deprecated { HashWithIndifferentAccess.new_from_hash_copying_default(hash) }
-  end
-
   def test_new_with_to_hash_conversion_copies_default
     normal_hash = Hash.new(3)
     normal_hash[:a] = 1
diff --git a/activesupport/test/core_ext/load_error_test.rb b/activesupport/test/core_ext/load_error_test.rb
index b50a35b2cb..44ff6bb051 100644
--- a/activesupport/test/core_ext/load_error_test.rb
+++ b/activesupport/test/core_ext/load_error_test.rb
@@ -1,14 +1,6 @@
 require "abstract_unit"
 require "active_support/core_ext/load_error"
 
-class TestMissingSourceFile < ActiveSupport::TestCase
-  def test_it_is_deprecated
-    assert_deprecated do
-      MissingSourceFile.new
-    end
-  end
-end
-
 class TestLoadError < ActiveSupport::TestCase
   def test_with_require
     assert_raise(LoadError) { require 'no_this_file_don\'t_exist' }
diff --git a/activesupport/test/core_ext/module/qualified_const_test.rb b/activesupport/test/core_ext/module/qualified_const_test.rb
deleted file mode 100644
index 418bc80ab9..0000000000
--- a/activesupport/test/core_ext/module/qualified_const_test.rb
+++ /dev/null
@@ -1,118 +0,0 @@
-require "abstract_unit"
-require "active_support/core_ext/module/qualified_const"
-
-module QualifiedConstTestMod
-  X = false
-
-  module M
-    X = 1
-
-    class C
-      X = 2
-    end
-  end
-
-  module N
-    include M
-  end
-end
-
-class QualifiedConstTest < ActiveSupport::TestCase
-  test "Object.qualified_const_defined?" do
-    assert_deprecated do
-      assert Object.qualified_const_defined?("QualifiedConstTestMod")
-      assert !Object.qualified_const_defined?("NonExistingQualifiedConstTestMod")
-
-      assert Object.qualified_const_defined?("QualifiedConstTestMod::X")
-      assert !Object.qualified_const_defined?("QualifiedConstTestMod::Y")
-
-      assert Object.qualified_const_defined?("QualifiedConstTestMod::M::X")
-      assert !Object.qualified_const_defined?("QualifiedConstTestMod::M::Y")
-
-      if Module.method(:const_defined?).arity == 1
-        assert !Object.qualified_const_defined?("QualifiedConstTestMod::N::X")
-      else
-        assert Object.qualified_const_defined?("QualifiedConstTestMod::N::X")
-        assert !Object.qualified_const_defined?("QualifiedConstTestMod::N::X", false)
-        assert Object.qualified_const_defined?("QualifiedConstTestMod::N::X", true)
-      end
-    end
-  end
-
-  test "mod.qualified_const_defined?" do
-    assert_deprecated do
-      assert QualifiedConstTestMod.qualified_const_defined?("M")
-      assert !QualifiedConstTestMod.qualified_const_defined?("NonExistingM")
-
-      assert QualifiedConstTestMod.qualified_const_defined?("M::X")
-      assert !QualifiedConstTestMod.qualified_const_defined?("M::Y")
-
-      assert QualifiedConstTestMod.qualified_const_defined?("M::C::X")
-      assert !QualifiedConstTestMod.qualified_const_defined?("M::C::Y")
-
-      if Module.method(:const_defined?).arity == 1
-        assert !QualifiedConstTestMod.qualified_const_defined?("QualifiedConstTestMod::N::X")
-      else
-        assert QualifiedConstTestMod.qualified_const_defined?("N::X")
-        assert !QualifiedConstTestMod.qualified_const_defined?("N::X", false)
-        assert QualifiedConstTestMod.qualified_const_defined?("N::X", true)
-      end
-    end
-  end
-
-  test "qualified_const_get" do
-    assert_deprecated do
-      assert_equal false, Object.qualified_const_get("QualifiedConstTestMod::X")
-      assert_equal false, QualifiedConstTestMod.qualified_const_get("X")
-      assert_equal 1, QualifiedConstTestMod.qualified_const_get("M::X")
-      assert_equal 1, QualifiedConstTestMod.qualified_const_get("N::X")
-      assert_equal 2, QualifiedConstTestMod.qualified_const_get("M::C::X")
-
-      assert_raise(NameError) { QualifiedConstTestMod.qualified_const_get("M::C::Y") }
-    end
-  end
-
-  test "qualified_const_set" do
-    assert_deprecated do
-      begin
-        m = Module.new
-        assert_equal m, Object.qualified_const_set("QualifiedConstTestMod2", m)
-        assert_equal m, ::QualifiedConstTestMod2
-
-        # We are going to assign to existing constants on purpose, so silence warnings.
-        silence_warnings do
-          assert_equal true, QualifiedConstTestMod.qualified_const_set("QualifiedConstTestMod::X", true)
-          assert_equal true, QualifiedConstTestMod::X
-
-          assert_equal 10, QualifiedConstTestMod::M.qualified_const_set("X", 10)
-          assert_equal 10, QualifiedConstTestMod::M::X
-        end
-      ensure
-        silence_warnings do
-          QualifiedConstTestMod.qualified_const_set("QualifiedConstTestMod::X", false)
-          QualifiedConstTestMod::M.qualified_const_set("X", 1)
-        end
-      end
-    end
-  end
-
-  test "reject absolute paths" do
-    assert_deprecated do
-      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_defined?("::X") }
-      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_defined?("::X::Y") }
-
-      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_get("::X") }
-      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_get("::X::Y") }
-
-      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_set("::X", nil) }
-      assert_raise_with_message(NameError, "wrong constant name ::X") { Object.qualified_const_set("::X::Y", nil) }
-    end
-  end
-
-  private
-
-    def assert_raise_with_message(expected_exception, expected_message, &block)
-      exception = assert_raise(expected_exception, &block)
-      assert_equal expected_message, exception.message
-    end
-end
diff --git a/activesupport/test/core_ext/module_test.rb b/activesupport/test/core_ext/module_test.rb
index e1e5236e65..8f2df22f27 100644
--- a/activesupport/test/core_ext/module_test.rb
+++ b/activesupport/test/core_ext/module_test.rb
@@ -386,231 +386,6 @@ class ModuleTest < ActiveSupport::TestCase
     assert_equal [Yz, Object], Yz::Zy.parents
   end
 
-  def test_local_constants
-    ActiveSupport::Deprecation.silence do
-      assert_equal %w(Constant1 Constant3), Ab.local_constants.sort.map(&:to_s)
-    end
-  end
-
-  def test_local_constants_is_deprecated
-    assert_deprecated { Ab.local_constants.sort.map(&:to_s) }
-  end
-end
-
-module BarMethodAliaser
-  def self.included(foo_class)
-    foo_class.class_eval do
-      include BarMethods
-      alias_method_chain :bar, :baz
-    end
-  end
-end
-
-module BarMethods
-  def bar_with_baz
-    bar_without_baz << "_with_baz"
-  end
-
-  def quux_with_baz!
-    quux_without_baz! << "_with_baz"
-  end
-
-  def quux_with_baz?
-    false
-  end
-
-  def quux_with_baz=(v)
-    send(:quux_without_baz=, v) << "_with_baz"
-  end
-
-  def duck_with_orange
-    duck_without_orange << "_with_orange"
-  end
-end
-
-class MethodAliasingTest < ActiveSupport::TestCase
-  def setup
-    Object.const_set :FooClassWithBarMethod, Class.new { def bar() "bar" end }
-    @instance = FooClassWithBarMethod.new
-  end
-
-  def teardown
-    Object.instance_eval { remove_const :FooClassWithBarMethod }
-  end
-
-  def test_alias_method_chain_deprecated
-    assert_deprecated(/alias_method_chain/) do
-      Module.new do
-        def base
-        end
-
-        def base_with_deprecated
-        end
-
-        alias_method_chain :base, :deprecated
-      end
-    end
-  end
-
-  def test_alias_method_chain
-    assert_deprecated(/alias_method_chain/) do
-      assert @instance.respond_to?(:bar)
-      feature_aliases = [:bar_with_baz, :bar_without_baz]
-
-      feature_aliases.each do |method|
-        assert !@instance.respond_to?(method)
-      end
-
-      assert_equal "bar", @instance.bar
-
-      FooClassWithBarMethod.class_eval { include BarMethodAliaser }
-
-      feature_aliases.each do |method|
-        assert_respond_to @instance, method
-      end
-
-      assert_equal "bar_with_baz", @instance.bar
-      assert_equal "bar", @instance.bar_without_baz
-    end
-  end
-
-  def test_alias_method_chain_with_punctuation_method
-    assert_deprecated(/alias_method_chain/) do
-      FooClassWithBarMethod.class_eval do
-        def quux!; "quux" end
-      end
-
-      assert !@instance.respond_to?(:quux_with_baz!)
-      FooClassWithBarMethod.class_eval do
-        include BarMethodAliaser
-        alias_method_chain :quux!, :baz
-      end
-      assert_respond_to @instance, :quux_with_baz!
-
-      assert_equal "quux_with_baz", @instance.quux!
-      assert_equal "quux", @instance.quux_without_baz!
-    end
-  end
-
-  def test_alias_method_chain_with_same_names_between_predicates_and_bang_methods
-    assert_deprecated(/alias_method_chain/) do
-      FooClassWithBarMethod.class_eval do
-        def quux!; "quux!" end
-        def quux?; true end
-        def quux=(v); "quux=" end
-      end
-
-      assert !@instance.respond_to?(:quux_with_baz!)
-      assert !@instance.respond_to?(:quux_with_baz?)
-      assert !@instance.respond_to?(:quux_with_baz=)
-
-      FooClassWithBarMethod.class_eval { include BarMethodAliaser }
-      assert_respond_to @instance, :quux_with_baz!
-      assert_respond_to @instance, :quux_with_baz?
-      assert_respond_to @instance, :quux_with_baz=
-
-      FooClassWithBarMethod.alias_method_chain :quux!, :baz
-      assert_equal "quux!_with_baz", @instance.quux!
-      assert_equal "quux!", @instance.quux_without_baz!
-
-      FooClassWithBarMethod.alias_method_chain :quux?, :baz
-      assert_equal false, @instance.quux?
-      assert_equal true,  @instance.quux_without_baz?
-
-      FooClassWithBarMethod.alias_method_chain :quux=, :baz
-      assert_equal "quux=_with_baz", @instance.send(:quux=, 1234)
-      assert_equal "quux=", @instance.send(:quux_without_baz=, 1234)
-    end
-  end
-
-  def test_alias_method_chain_with_feature_punctuation
-    assert_deprecated(/alias_method_chain/) do
-      FooClassWithBarMethod.class_eval do
-        def quux; "quux" end
-        def quux?; "quux?" end
-        include BarMethodAliaser
-        alias_method_chain :quux, :baz!
-      end
-
-      assert_nothing_raised do
-        assert_equal "quux_with_baz", @instance.quux_with_baz!
-      end
-
-      assert_raise(NameError) do
-        FooClassWithBarMethod.alias_method_chain :quux?, :baz!
-      end
-    end
-  end
-
-  def test_alias_method_chain_yields_target_and_punctuation
-    assert_deprecated(/alias_method_chain/) do
-      args = nil
-
-      FooClassWithBarMethod.class_eval do
-        def quux?; end
-        include BarMethods
-
-        FooClassWithBarMethod.alias_method_chain :quux?, :baz do |target, punctuation|
-          args = [target, punctuation]
-        end
-      end
-
-      assert_not_nil args
-      assert_equal "quux", args[0]
-      assert_equal "?", args[1]
-    end
-  end
-
-  def test_alias_method_chain_preserves_private_method_status
-    assert_deprecated(/alias_method_chain/) do
-      FooClassWithBarMethod.class_eval do
-        def duck; "duck" end
-        include BarMethodAliaser
-        private :duck
-        alias_method_chain :duck, :orange
-      end
-
-      assert_raise NoMethodError do
-        @instance.duck
-      end
-
-      assert_equal "duck_with_orange", @instance.instance_eval { duck }
-      assert FooClassWithBarMethod.private_method_defined?(:duck)
-    end
-  end
-
-  def test_alias_method_chain_preserves_protected_method_status
-    assert_deprecated(/alias_method_chain/) do
-      FooClassWithBarMethod.class_eval do
-        def duck; "duck" end
-        include BarMethodAliaser
-        protected :duck
-        alias_method_chain :duck, :orange
-      end
-
-      assert_raise NoMethodError do
-        @instance.duck
-      end
-
-      assert_equal "duck_with_orange", @instance.instance_eval { duck }
-      assert FooClassWithBarMethod.protected_method_defined?(:duck)
-    end
-  end
-
-  def test_alias_method_chain_preserves_public_method_status
-    assert_deprecated(/alias_method_chain/) do
-      FooClassWithBarMethod.class_eval do
-        def duck; "duck" end
-        include BarMethodAliaser
-        public :duck
-        alias_method_chain :duck, :orange
-      end
-
-      assert_equal "duck_with_orange", @instance.duck
-      assert FooClassWithBarMethod.public_method_defined?(:duck)
-    end
-  end
-
   def test_delegate_with_case
     event = Event.new(Tester.new)
     assert_equal 1, event.foo
diff --git a/activesupport/test/core_ext/numeric_ext_test.rb b/activesupport/test/core_ext/numeric_ext_test.rb
index c60b654d1d..5361b7b708 100644
--- a/activesupport/test/core_ext/numeric_ext_test.rb
+++ b/activesupport/test/core_ext/numeric_ext_test.rb
@@ -287,21 +287,6 @@ class NumericExtFormattingTest < ActiveSupport::TestCase
     assert_equal "10 Bytes",  10.to_s(:human_size)
   end
 
-  def test_to_s__human_size_with_si_prefix
-    assert_deprecated do
-      assert_equal "3 Bytes",    3.14159265.to_s(:human_size, prefix: :si)
-      assert_equal "123 Bytes",  123.0.to_s(:human_size, prefix: :si)
-      assert_equal "123 Bytes",  123.to_s(:human_size, prefix: :si)
-      assert_equal "1.23 KB",    1234.to_s(:human_size, prefix: :si)
-      assert_equal "12.3 KB",    12345.to_s(:human_size, prefix: :si)
-      assert_equal "1.23 MB",    1234567.to_s(:human_size, prefix: :si)
-      assert_equal "1.23 GB",    1234567890.to_s(:human_size, prefix: :si)
-      assert_equal "1.23 TB",    1234567890123.to_s(:human_size, prefix: :si)
-      assert_equal "1.23 PB",    1234567890123456.to_s(:human_size, prefix: :si)
-      assert_equal "1.23 EB",    1234567890123456789.to_s(:human_size, prefix: :si)
-    end
-  end
-
   def test_to_s__human_size_with_options_hash
     assert_equal "1.2 MB",   1234567.to_s(:human_size, precision: 2)
     assert_equal "3 Bytes",  3.14159265.to_s(:human_size, precision: 4)
@@ -391,12 +376,6 @@ class NumericExtFormattingTest < ActiveSupport::TestCase
     assert_equal "1 Million", BigDecimal("1000010").to_s(:human)
   end
 
-  def test_to_formatted_s_is_deprecated
-    assert_deprecated do
-      5551234.to_formatted_s(:phone)
-    end
-  end
-
   def test_to_s_with_invalid_formatter
     assert_equal "123", 123.to_s(:invalid)
     assert_equal "2.5", 2.5.to_s(:invalid)
diff --git a/activesupport/test/core_ext/string_ext_test.rb b/activesupport/test/core_ext/string_ext_test.rb
index 4b40503d22..98bcdda45b 100644
--- a/activesupport/test/core_ext/string_ext_test.rb
+++ b/activesupport/test/core_ext/string_ext_test.rb
@@ -168,14 +168,6 @@ class StringInflectionsTest < ActiveSupport::TestCase
     end
   end
 
-  def test_string_parameterized_no_separator_deprecated
-    StringToParameterizeWithNoSeparator.each do |normal, slugged|
-      assert_deprecated(/Passing the separator argument as a positional parameter is deprecated and will soon be removed. Use `separator: ''` instead./i) do
-        assert_equal(normal.parameterize(""), slugged)
-      end
-    end
-  end
-
   def test_string_parameterized_no_separator_preserve_case
     StringToParameterizePreserveCaseWithNoSeparator.each do |normal, slugged|
       assert_equal(normal.parameterize(separator: "", preserve_case: true), slugged)
@@ -188,14 +180,6 @@ class StringInflectionsTest < ActiveSupport::TestCase
     end
   end
 
-  def test_string_parameterized_underscore_deprecated
-    StringToParameterizeWithUnderscore.each do |normal, slugged|
-      assert_deprecated(/Passing the separator argument as a positional parameter is deprecated and will soon be removed. Use `separator: '_'` instead./i) do
-        assert_equal(normal.parameterize("_"), slugged)
-      end
-    end
-  end
-
   def test_string_parameterized_underscore_preserve_case
     StringToParameterizePreserceCaseWithUnderscore.each do |normal, slugged|
       assert_equal(normal.parameterize(separator: "_", preserve_case: true), slugged)
diff --git a/activesupport/test/inflector_test.rb b/activesupport/test/inflector_test.rb
index 1c5a4f378c..d881bd346d 100644
--- a/activesupport/test/inflector_test.rb
+++ b/activesupport/test/inflector_test.rb
@@ -272,15 +272,6 @@ class InflectorTest < ActiveSupport::TestCase
     end
   end
 
-  def test_parameterize_with_custom_separator_deprecated
-    jruby_skip "UTF-8 to UTF8-MAC Converter is unavailable"
-    StringToParameterizeWithUnderscore.each do |some_string, parameterized_string|
-      assert_deprecated(/Passing the separator argument as a positional parameter is deprecated and will soon be removed. Use `separator: '_'` instead./i) do
-        assert_equal(parameterized_string, ActiveSupport::Inflector.parameterize(some_string, "_"))
-      end
-    end
-  end
-
   def test_parameterize_with_multi_character_separator
     jruby_skip "UTF-8 to UTF8-MAC Converter is unavailable"
     StringToParameterized.each do |some_string, parameterized_string|
@@ -288,15 +279,6 @@ class InflectorTest < ActiveSupport::TestCase
     end
   end
 
-  def test_parameterize_with_multi_character_separator_deprecated
-    jruby_skip "UTF-8 to UTF8-MAC Converter is unavailable"
-    StringToParameterized.each do |some_string, parameterized_string|
-      assert_deprecated(/Passing the separator argument as a positional parameter is deprecated and will soon be removed. Use `separator: '__sep__'` instead./i) do
-        assert_equal(parameterized_string.gsub("-", "__sep__"), ActiveSupport::Inflector.parameterize(some_string, "__sep__"))
-      end
-    end
-  end
-
   def test_classify
     ClassNameToTableName.each do |class_name, table_name|
       assert_equal(class_name, ActiveSupport::Inflector.classify(table_name))
diff --git a/activesupport/test/number_helper_test.rb b/activesupport/test/number_helper_test.rb
index 8f6eb91e71..dc0c34d4e2 100644
--- a/activesupport/test/number_helper_test.rb
+++ b/activesupport/test/number_helper_test.rb
@@ -244,23 +244,6 @@ module ActiveSupport
         end
       end
 
-      def test_number_to_human_size_with_si_prefix
-        assert_deprecated do
-          [@instance_with_helpers, TestClassWithClassNumberHelpers, ActiveSupport::NumberHelper].each do |number_helper|
-            assert_equal "3 Bytes",    number_helper.number_to_human_size(3.14159265, prefix: :si)
-            assert_equal "123 Bytes",  number_helper.number_to_human_size(123.0, prefix: :si)
-            assert_equal "123 Bytes",  number_helper.number_to_human_size(123, prefix: :si)
-            assert_equal "1.23 KB",    number_helper.number_to_human_size(1234, prefix: :si)
-            assert_equal "12.3 KB",    number_helper.number_to_human_size(12345, prefix: :si)
-            assert_equal "1.23 MB",    number_helper.number_to_human_size(1234567, prefix: :si)
-            assert_equal "1.23 GB",    number_helper.number_to_human_size(1234567890, prefix: :si)
-            assert_equal "1.23 TB",    number_helper.number_to_human_size(1234567890123, prefix: :si)
-            assert_equal "1.23 PB",    number_helper.number_to_human_size(1234567890123456, prefix: :si)
-            assert_equal "1.23 EB",    number_helper.number_to_human_size(1234567890123456789, prefix: :si)
-          end
-        end
-      end
-
       def test_number_to_human_size_with_options_hash
         [@instance_with_helpers, TestClassWithClassNumberHelpers, ActiveSupport::NumberHelper].each do |number_helper|
           assert_equal "1.2 MB",   number_helper.number_to_human_size(1234567, precision: 2)