Use `Mime[:foo]` instead of `Mime::Type[:FOO]` for back compat

Rails 4.x and earlier didn't support `Mime::Type[:FOO]`, so libraries
that support multiple Rails versions would've had to feature-detect
whether to use `Mime::Type[:FOO]` or `Mime::FOO`.

`Mime[:foo]` has been around for ages to look up registered MIME types
by symbol / extension, though, so libraries and plugins can safely
switch to that without breaking backward- or forward-compatibility.

Note: `Mime::ALL` isn't a real MIME type and isn't registered for lookup
by type or extension, so it's not available as `Mime[:all]`. We use it
internally as a wildcard for `respond_to` negotiation. If you use this
internal constant, continue to reference it with `Mime::ALL`.

Ref. efc6dd550ee49e7e443f9d72785caa0f240def53

12 files changed, 113 insertions, 128 deletions

diff --git a/actionpack/test/abstract/collector_test.rb b/actionpack/test/abstract/collector_test.rb
index 3b36e43c0b..edbb84d462 100644
--- a/actionpack/test/abstract/collector_test.rb
+++ b/actionpack/test/abstract/collector_test.rb
@@ -53,9 +53,9 @@ module AbstractController
         collector.html
         collector.text(:foo)
         collector.js(:bar) { :baz }
-        assert_equal [Mime::Type[:HTML], [], nil], collector.responses[0]
-        assert_equal [Mime::Type[:TEXT], [:foo], nil], collector.responses[1]
-        assert_equal [Mime::Type[:JS], [:bar]], collector.responses[2][0,2]
+        assert_equal [Mime[:html], [], nil], collector.responses[0]
+        assert_equal [Mime[:text], [:foo], nil], collector.responses[1]
+        assert_equal [Mime[:js], [:bar]], collector.responses[2][0,2]
         assert_equal :baz, collector.responses[2][2].call
       end
     end
diff --git a/actionpack/test/controller/action_pack_assertions_test.rb b/actionpack/test/controller/action_pack_assertions_test.rb
index 7dfeadceb0..899d92f815 100644
--- a/actionpack/test/controller/action_pack_assertions_test.rb
+++ b/actionpack/test/controller/action_pack_assertions_test.rb
@@ -65,7 +65,7 @@ class ActionPackAssertionsController < ActionController::Base
   end
 
   def render_text_with_custom_content_type
-    render body: "Hello!", content_type: Mime::Type[:RSS]
+    render body: "Hello!", content_type: Mime[:rss]
   end
 
   def session_stuffing
diff --git a/actionpack/test/controller/content_type_test.rb b/actionpack/test/controller/content_type_test.rb
index 4a86f1bad3..c02607b55e 100644
--- a/actionpack/test/controller/content_type_test.rb
+++ b/actionpack/test/controller/content_type_test.rb
@@ -3,7 +3,7 @@ require 'abstract_unit'
 class OldContentTypeController < ActionController::Base
   # :ported:
   def render_content_type_from_body
-    response.content_type = Mime::Type[:RSS]
+    response.content_type = Mime[:rss]
     render body: "hello world!"
   end
 
@@ -14,7 +14,7 @@ class OldContentTypeController < ActionController::Base
 
   # :ported:
   def render_content_type_from_render
-    render body: "hello world!", :content_type => Mime::Type[:RSS]
+    render body: "hello world!", :content_type => Mime[:rss]
   end
 
   # :ported:
@@ -36,7 +36,7 @@ class OldContentTypeController < ActionController::Base
   end
 
   def render_change_for_builder
-    response.content_type = Mime::Type[:HTML]
+    response.content_type = Mime[:html]
     render :action => "render_default_for_builder"
   end
 
@@ -45,7 +45,7 @@ class OldContentTypeController < ActionController::Base
       format.html { render body: "hello world!" }
       format.xml  { render action: "render_default_content_types_for_respond_to" }
       format.js   { render body: "hello world!" }
-      format.rss  { render body: "hello world!", content_type: Mime::Type[:XML] }
+      format.rss  { render body: "hello world!", content_type: Mime[:xml] }
     end
   end
 end
@@ -64,68 +64,68 @@ class ContentTypeTest < ActionController::TestCase
   def test_render_defaults
     get :render_defaults
     assert_equal "utf-8", @response.charset
-    assert_equal Mime::Type[:TEXT], @response.content_type
+    assert_equal Mime[:text], @response.content_type
   end
 
   def test_render_changed_charset_default
     with_default_charset "utf-16" do
       get :render_defaults
       assert_equal "utf-16", @response.charset
-      assert_equal Mime::Type[:TEXT], @response.content_type
+      assert_equal Mime[:text], @response.content_type
     end
   end
 
   # :ported:
   def test_content_type_from_body
     get :render_content_type_from_body
-    assert_equal Mime::Type[:RSS], @response.content_type
+    assert_equal Mime[:rss], @response.content_type
     assert_equal "utf-8", @response.charset
   end
 
   # :ported:
   def test_content_type_from_render
     get :render_content_type_from_render
-    assert_equal Mime::Type[:RSS], @response.content_type
+    assert_equal Mime[:rss], @response.content_type
     assert_equal "utf-8", @response.charset
   end
 
   # :ported:
   def test_charset_from_body
     get :render_charset_from_body
-    assert_equal Mime::Type[:TEXT], @response.content_type
+    assert_equal Mime[:text], @response.content_type
     assert_equal "utf-16", @response.charset
   end
 
   # :ported:
   def test_nil_charset_from_body
     get :render_nil_charset_from_body
-    assert_equal Mime::Type[:TEXT], @response.content_type
+    assert_equal Mime[:text], @response.content_type
     assert_equal "utf-8", @response.charset, @response.headers.inspect
   end
 
   def test_nil_default_for_erb
     with_default_charset nil do
       get :render_default_for_erb
-      assert_equal Mime::Type[:HTML], @response.content_type
+      assert_equal Mime[:html], @response.content_type
       assert_nil @response.charset, @response.headers.inspect
     end
   end
 
   def test_default_for_erb
     get :render_default_for_erb
-    assert_equal Mime::Type[:HTML], @response.content_type
+    assert_equal Mime[:html], @response.content_type
     assert_equal "utf-8", @response.charset
   end
 
   def test_default_for_builder
     get :render_default_for_builder
-    assert_equal Mime::Type[:XML], @response.content_type
+    assert_equal Mime[:xml], @response.content_type
     assert_equal "utf-8", @response.charset
   end
 
   def test_change_for_builder
     get :render_change_for_builder
-    assert_equal Mime::Type[:HTML], @response.content_type
+    assert_equal Mime[:html], @response.content_type
     assert_equal "utf-8", @response.charset
   end
 
@@ -144,24 +144,24 @@ class AcceptBasedContentTypeTest < ActionController::TestCase
   tests OldContentTypeController
 
   def test_render_default_content_types_for_respond_to
-    @request.accept = Mime::Type[:HTML].to_s
+    @request.accept = Mime[:html].to_s
     get :render_default_content_types_for_respond_to
-    assert_equal Mime::Type[:HTML], @response.content_type
+    assert_equal Mime[:html], @response.content_type
 
-    @request.accept = Mime::Type[:JS].to_s
+    @request.accept = Mime[:js].to_s
     get :render_default_content_types_for_respond_to
-    assert_equal Mime::Type[:JS], @response.content_type
+    assert_equal Mime[:js], @response.content_type
   end
 
   def test_render_default_content_types_for_respond_to_with_template
-    @request.accept = Mime::Type[:XML].to_s
+    @request.accept = Mime[:xml].to_s
     get :render_default_content_types_for_respond_to
-    assert_equal Mime::Type[:XML], @response.content_type
+    assert_equal Mime[:xml], @response.content_type
   end
 
   def test_render_default_content_types_for_respond_to_with_overwrite
-    @request.accept = Mime::Type[:RSS].to_s
+    @request.accept = Mime[:rss].to_s
     get :render_default_content_types_for_respond_to
-    assert_equal Mime::Type[:XML], @response.content_type
+    assert_equal Mime[:xml], @response.content_type
   end
 end
diff --git a/actionpack/test/controller/mime/respond_to_test.rb b/actionpack/test/controller/mime/respond_to_test.rb
index 64eb33f78f..c025c7fa00 100644
--- a/actionpack/test/controller/mime/respond_to_test.rb
+++ b/actionpack/test/controller/mime/respond_to_test.rb
@@ -81,7 +81,7 @@ class RespondToController < ActionController::Base
   def using_defaults_with_all
     respond_to do |type|
       type.html
-      type.all{ render body: "ALL" }
+      type.all { render body: "ALL" }
     end
   end
 
diff --git a/actionpack/test/controller/new_base/content_type_test.rb b/actionpack/test/controller/new_base/content_type_test.rb
index d9899fe01f..a9dcdde4b8 100644
--- a/actionpack/test/controller/new_base/content_type_test.rb
+++ b/actionpack/test/controller/new_base/content_type_test.rb
@@ -7,12 +7,12 @@ module ContentType
     end
 
     def set_on_response_obj
-      response.content_type = Mime::Type[:RSS]
+      response.content_type = Mime[:rss]
       render body: "Hello world!"
     end
 
     def set_on_render
-      render body: "Hello world!", content_type: Mime::Type[:RSS]
+      render body: "Hello world!", content_type: Mime[:rss]
     end
   end
 
diff --git a/actionpack/test/controller/render_other_test.rb b/actionpack/test/controller/render_other_test.rb
index 8891f6177f..1f5215ac55 100644
--- a/actionpack/test/controller/render_other_test.rb
+++ b/actionpack/test/controller/render_other_test.rb
@@ -12,7 +12,7 @@ class RenderOtherTest < ActionController::TestCase
 
   def test_using_custom_render_option
     ActionController.add_renderer :simon do |says, options|
-      self.content_type  = Mime::Type[:TEXT]
+      self.content_type  = Mime[:text]
       self.response_body = "Simon says: #{says}"
     end
 
diff --git a/actionpack/test/controller/render_xml_test.rb b/actionpack/test/controller/render_xml_test.rb
index 094d3ea1d2..f0fd7ddc5e 100644
--- a/actionpack/test/controller/render_xml_test.rb
+++ b/actionpack/test/controller/render_xml_test.rb
@@ -92,6 +92,6 @@ class RenderXmlTest < ActionController::TestCase
 
   def test_should_use_implicit_content_type
     get :implicit_content_type, format: 'atom'
-    assert_equal Mime::Type[:ATOM], @response.content_type
+    assert_equal Mime[:atom], @response.content_type
   end
 end
diff --git a/actionpack/test/controller/send_file_test.rb b/actionpack/test/controller/send_file_test.rb
index 3224d84b58..2820425c31 100644
--- a/actionpack/test/controller/send_file_test.rb
+++ b/actionpack/test/controller/send_file_test.rb
@@ -22,7 +22,7 @@ class SendFileController < ActionController::Base
 
   def test_send_file_headers_bang
     options = {
-      :type => Mime::Type[:PNG],
+      :type => Mime[:png],
       :disposition => 'disposition',
       :filename => 'filename'
     }
@@ -32,7 +32,7 @@ class SendFileController < ActionController::Base
 
   def test_send_file_headers_with_disposition_as_a_symbol
     options = {
-      :type => Mime::Type[:PNG],
+      :type => Mime[:png],
       :disposition => :disposition,
       :filename => 'filename'
     }
diff --git a/actionpack/test/controller/webservice_test.rb b/actionpack/test/controller/webservice_test.rb
index 2aee914a24..6d377c4691 100644
--- a/actionpack/test/controller/webservice_test.rb
+++ b/actionpack/test/controller/webservice_test.rb
@@ -65,7 +65,7 @@ class WebServiceTest < ActionDispatch::IntegrationTest
 
   def test_register_and_use_json_simple
     with_test_route_set do
-      with_params_parsers Mime::Type[:JSON] => Proc.new { |data| ActiveSupport::JSON.decode(data)['request'].with_indifferent_access } do
+      with_params_parsers Mime[:json] => Proc.new { |data| ActiveSupport::JSON.decode(data)['request'].with_indifferent_access } do
         post "/",
           params: '{"request":{"summary":"content...","title":"JSON"}}',
           headers: { 'CONTENT_TYPE' => 'application/json' }
@@ -99,7 +99,7 @@ class WebServiceTest < ActionDispatch::IntegrationTest
   def test_parsing_json_doesnot_rescue_exception
     req = Class.new(ActionDispatch::Request) do
       def params_parsers
-        { Mime::Type[:JSON] => Proc.new { |data| raise Interrupt } }
+        { Mime[:json] => Proc.new { |data| raise Interrupt } }
       end
 
       def content_length; get_header('rack.input').length; end
diff --git a/actionpack/test/dispatch/mime_type_test.rb b/actionpack/test/dispatch/mime_type_test.rb
index 68083ed747..149e37bf3d 100644
--- a/actionpack/test/dispatch/mime_type_test.rb
+++ b/actionpack/test/dispatch/mime_type_test.rb
@@ -1,7 +1,6 @@
 require 'abstract_unit'
 
 class MimeTypeTest < ActiveSupport::TestCase
-
   test "parse single" do
     Mime::LOOKUP.each_key do |mime_type|
       unless mime_type == 'image/*'
@@ -11,95 +10,95 @@ class MimeTypeTest < ActiveSupport::TestCase
   end
 
   test "unregister" do
+    assert_nil Mime[:mobile]
+
     begin
-      Mime::Type.register("text/x-mobile", :mobile)
-      assert Mime::Type.registered?(:MOBILE)
-      assert_equal Mime::Type[:MOBILE], Mime::LOOKUP['text/x-mobile']
-      assert_equal Mime::Type[:MOBILE], Mime::EXTENSION_LOOKUP['mobile']
+      mime = Mime::Type.register("text/x-mobile", :mobile)
+      assert_equal mime, Mime[:mobile]
+      assert_equal mime, Mime::Type.lookup('text/x-mobile')
+      assert_equal mime, Mime::Type.lookup_by_extension(:mobile)
 
       Mime::Type.unregister(:mobile)
-      assert !Mime::Type.registered?(:MOBILE), "Mime::MOBILE should not be defined"
-      assert !Mime::LOOKUP.has_key?('text/x-mobile'), "Mime::LOOKUP should not have key ['text/x-mobile]"
-      assert !Mime::EXTENSION_LOOKUP.has_key?('mobile'), "Mime::EXTENSION_LOOKUP should not have key ['mobile]"
+      assert_nil Mime[:mobile], "Mime[:mobile] should be nil after unregistering :mobile"
+      assert_nil Mime::Type.lookup_by_extension(:mobile), "Should be missing MIME extension lookup for :mobile"
     ensure
-      Mime::LOOKUP.reject!{|key,_| key == 'text/x-mobile'}
+      Mime::Type.unregister :mobile
     end
   end
 
   test "parse text with trailing star at the beginning" do
     accept = "text/*, text/html, application/json, multipart/form-data"
-    expect = [Mime::Type[:HTML], Mime::Type[:TEXT], Mime::Type[:JS], Mime::Type[:CSS], Mime::Type[:ICS], Mime::Type[:CSV], Mime::Type[:VCF], Mime::Type[:XML], Mime::Type[:YAML], Mime::Type[:JSON], Mime::Type[:MULTIPART_FORM]]
+    expect = [Mime[:html], Mime[:text], Mime[:js], Mime[:css], Mime[:ics], Mime[:csv], Mime[:vcf], Mime[:xml], Mime[:yaml], Mime[:json], Mime[:multipart_form]]
     parsed = Mime::Type.parse(accept)
     assert_equal expect, parsed
   end
 
   test "parse text with trailing star in the end" do
     accept = "text/html, application/json, multipart/form-data, text/*"
-    expect = [Mime::Type[:HTML], Mime::Type[:JSON], Mime::Type[:MULTIPART_FORM], Mime::Type[:TEXT], Mime::Type[:JS], Mime::Type[:CSS], Mime::Type[:ICS], Mime::Type[:CSV], Mime::Type[:VCF], Mime::Type[:XML], Mime::Type[:YAML]]
+    expect = [Mime[:html], Mime[:json], Mime[:multipart_form], Mime[:text], Mime[:js], Mime[:css], Mime[:ics], Mime[:csv], Mime[:vcf], Mime[:xml], Mime[:yaml]]
     parsed = Mime::Type.parse(accept)
     assert_equal expect, parsed
   end
 
   test "parse text with trailing star" do
     accept = "text/*"
-    expect = [Mime::Type[:HTML], Mime::Type[:TEXT], Mime::Type[:JS], Mime::Type[:CSS], Mime::Type[:ICS], Mime::Type[:CSV], Mime::Type[:VCF], Mime::Type[:XML], Mime::Type[:YAML], Mime::Type[:JSON]]
+    expect = [Mime[:html], Mime[:text], Mime[:js], Mime[:css], Mime[:ics], Mime[:csv], Mime[:vcf], Mime[:xml], Mime[:yaml], Mime[:json]]
     parsed = Mime::Type.parse(accept)
     assert_equal expect, parsed
   end
 
   test "parse application with trailing star" do
     accept = "application/*"
-    expect = [Mime::Type[:HTML], Mime::Type[:JS], Mime::Type[:XML], Mime::Type[:RSS], Mime::Type[:ATOM], Mime::Type[:YAML], Mime::Type[:URL_ENCODED_FORM], Mime::Type[:JSON], Mime::Type[:PDF], Mime::Type[:ZIP]]
+    expect = [Mime[:html], Mime[:js], Mime[:xml], Mime[:rss], Mime[:atom], Mime[:yaml], Mime[:url_encoded_form], Mime[:json], Mime[:pdf], Mime[:zip]]
     parsed = Mime::Type.parse(accept)
     assert_equal expect, parsed
   end
 
   test "parse without q" do
     accept = "text/xml,application/xhtml+xml,text/yaml,application/xml,text/html,image/png,text/plain,application/pdf,*/*"
-    expect = [Mime::Type[:HTML], Mime::Type[:XML], Mime::Type[:YAML], Mime::Type[:PNG], Mime::Type[:TEXT], Mime::Type[:PDF], Mime::Type[:ALL]]
-    assert_equal expect, Mime::Type.parse(accept)
+    expect = [Mime[:html], Mime[:xml], Mime[:yaml], Mime[:png], Mime[:text], Mime[:pdf], '*/*']
+    assert_equal expect.map(&:to_s), Mime::Type.parse(accept).map(&:to_s)
   end
 
   test "parse with q" do
     accept = "text/xml,application/xhtml+xml,text/yaml; q=0.3,application/xml,text/html; q=0.8,image/png,text/plain; q=0.5,application/pdf,*/*; q=0.2"
-    expect = [Mime::Type[:HTML], Mime::Type[:XML], Mime::Type[:PNG], Mime::Type[:PDF], Mime::Type[:TEXT], Mime::Type[:YAML], Mime::Type[:ALL]]
-    assert_equal expect, Mime::Type.parse(accept)
+    expect = [Mime[:html], Mime[:xml], Mime[:png], Mime[:pdf], Mime[:text], Mime[:yaml], '*/*']
+    assert_equal expect.map(&:to_s), Mime::Type.parse(accept).map(&:to_s)
   end
 
   test "parse single media range with q" do
     accept = "text/html;q=0.9"
-    expect = [Mime::Type[:HTML]]
+    expect = [Mime[:html]]
     assert_equal expect, Mime::Type.parse(accept)
   end
 
   test "parse arbitrary media type parameters" do
     accept = 'multipart/form-data; boundary="simple boundary"'
-    expect = [Mime::Type[:MULTIPART_FORM]]
+    expect = [Mime[:multipart_form]]
     assert_equal expect, Mime::Type.parse(accept)
   end
 
   # Accept header send with user HTTP_USER_AGENT: Sunrise/0.42j (Windows XP)
   test "parse broken acceptlines" do
     accept = "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/*,,*/*;q=0.5"
-    expect = [Mime::Type[:HTML], Mime::Type[:XML], "image/*", Mime::Type[:TEXT], Mime::Type[:ALL]]
-    assert_equal expect, Mime::Type.parse(accept).collect(&:to_s)
+    expect = [Mime[:html], Mime[:xml], "image/*", Mime[:text], '*/*']
+    assert_equal expect.map(&:to_s), Mime::Type.parse(accept).map(&:to_s)
   end
 
   # Accept header send with user HTTP_USER_AGENT: Mozilla/4.0
   #  (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; InfoPath.1)
   test "parse other broken acceptlines" do
     accept = "image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword,  , pronto/1.00.00, sslvpn/1.00.00.00, */*"
-    expect = ['image/gif', 'image/x-xbitmap', 'image/jpeg','image/pjpeg', 'application/x-shockwave-flash', 'application/vnd.ms-excel', 'application/vnd.ms-powerpoint', 'application/msword', 'pronto/1.00.00', 'sslvpn/1.00.00.00', Mime::Type[:ALL]]
-    assert_equal expect, Mime::Type.parse(accept).collect(&:to_s)
+    expect = ['image/gif', 'image/x-xbitmap', 'image/jpeg','image/pjpeg', 'application/x-shockwave-flash', 'application/vnd.ms-excel', 'application/vnd.ms-powerpoint', 'application/msword', 'pronto/1.00.00', 'sslvpn/1.00.00.00', '*/*']
+    assert_equal expect.map(&:to_s), Mime::Type.parse(accept).map(&:to_s)
   end
 
   test "custom type" do
     begin
       type = Mime::Type.register("image/foo", :foo)
-      assert_equal Mime::Type[:FOO], type
-      assert Mime::Type.registered?(:FOO)
+      assert_equal type, Mime[:foo]
     ensure
-      Mime::Type.unregister(:FOO)
+      Mime::Type.unregister(:foo)
     end
   end
 
@@ -107,10 +106,10 @@ class MimeTypeTest < ActiveSupport::TestCase
     begin
       Mime::Type.register "text/foobar", :foobar, ["text/foo", "text/bar"]
       %w[text/foobar text/foo text/bar].each do |type|
-        assert_equal Mime::Type[:FOOBAR], type
+        assert_equal Mime[:foobar], type
       end
     ensure
-      Mime::Type.unregister(:FOOBAR)
+      Mime::Type.unregister(:foobar)
     end
   end
 
@@ -121,10 +120,10 @@ class MimeTypeTest < ActiveSupport::TestCase
         registered_mimes << mime
       end
 
-      Mime::Type.register("text/foo", :foo)
-      assert_equal [Mime::Type[:FOO]], registered_mimes
+      mime = Mime::Type.register("text/foo", :foo)
+      assert_equal [mime], registered_mimes
     ensure
-      Mime::Type.unregister(:FOO)
+      Mime::Type.unregister(:foo)
     end
   end
 
@@ -132,36 +131,32 @@ class MimeTypeTest < ActiveSupport::TestCase
     begin
       Mime::Type.register "text/foobar", :foobar, [], [:foo, "bar"]
       %w[foobar foo bar].each do |extension|
-        assert_equal Mime::Type[:FOOBAR], Mime::EXTENSION_LOOKUP[extension]
+        assert_equal Mime[:foobar], Mime::EXTENSION_LOOKUP[extension]
       end
     ensure
-      Mime::Type.unregister(:FOOBAR)
+      Mime::Type.unregister(:foobar)
     end
   end
 
   test "register alias" do
     begin
       Mime::Type.register_alias "application/xhtml+xml", :foobar
-      assert_equal Mime::Type[:HTML], Mime::EXTENSION_LOOKUP['foobar']
+      assert_equal Mime[:html], Mime::EXTENSION_LOOKUP['foobar']
     ensure
-      Mime::Type.unregister(:FOOBAR)
+      Mime::Type.unregister(:foobar)
     end
   end
 
   test "type should be equal to symbol" do
-    assert_equal Mime::Type[:HTML], 'application/xhtml+xml'
-    assert_equal Mime::Type[:HTML], :html
+    assert_equal Mime[:html], 'application/xhtml+xml'
+    assert_equal Mime[:html], :html
   end
 
   test "type convenience methods" do
-    # Don't test Mime::Type[:ALL], since it Mime::Type[:ALL].html? == true
-    types = Mime::SET.symbols.uniq - [:all, :iphone]
-
-    # Remove custom Mime::Type instances set in other tests, like Mime::Type[:GIF] and Mime::Type[:IPHONE]
-    types.delete_if { |type| !Mime::Type.registered?(type.upcase) }
+    types = Mime::SET.symbols.uniq - [:iphone]
 
     types.each do |type|
-      mime = Mime::Type[type.upcase]
+      mime = Mime[type]
       assert mime.respond_to?("#{type}?"), "#{mime.inspect} does not respond to #{type}?"
       assert_equal type, mime.symbol, "#{mime.inspect} is not #{type}?"
       invalid_types = types - [type]
@@ -172,41 +167,31 @@ class MimeTypeTest < ActiveSupport::TestCase
     end
   end
 
-  test "mime all is html" do
-    assert Mime::Type[:ALL].all?,  "Mime::ALL is not all?"
-    assert Mime::Type[:ALL].html?, "Mime::ALL is not html?"
-  end
-
   test "deprecated lookup" do
     assert_deprecated do
-      assert Mime::ALL.all?,  "Mime::ALL is not all?"
+      Mime::HTML
     end
   end
 
   test "deprecated const_defined?" do
-    assert_deprecated { Mime.const_defined?(:ALL) }
-  end
-
-  test "verifiable mime types" do
-    all_types = Mime::SET.symbols
-    all_types.uniq!
-    # Remove custom Mime::Type instances set in other tests, like Mime::Type[:GIF] and Mime::Type[:IPHONE]
-    all_types.delete_if { |type| !Mime::Type.registered?(type.upcase) }
+    assert_deprecated do
+      Mime.const_defined? :HTML
+    end
   end
 
   test "references gives preference to symbols before strings" do
-    assert_equal :html, Mime::Type[:HTML].ref
+    assert_equal :html, Mime[:html].ref
     another = Mime::Type.lookup("foo/bar")
     assert_nil another.to_sym
     assert_equal "foo/bar", another.ref
   end
 
   test "regexp matcher" do
-    assert Mime::Type[:JS] =~ "text/javascript"
-    assert Mime::Type[:JS] =~ "application/javascript"
-    assert Mime::Type[:JS] !~ "text/html"
-    assert !(Mime::Type[:JS] !~ "text/javascript")
-    assert !(Mime::Type[:JS] !~ "application/javascript")
-    assert Mime::Type[:HTML] =~ 'application/xhtml+xml'
+    assert Mime[:js] =~ "text/javascript"
+    assert Mime[:js] =~ "application/javascript"
+    assert Mime[:js] !~ "text/html"
+    assert !(Mime[:js] !~ "text/javascript")
+    assert !(Mime[:js] !~ "application/javascript")
+    assert Mime[:html] =~ 'application/xhtml+xml'
   end
 end
diff --git a/actionpack/test/dispatch/request_test.rb b/actionpack/test/dispatch/request_test.rb
index 40866595ed..af2ed24f43 100644
--- a/actionpack/test/dispatch/request_test.rb
+++ b/actionpack/test/dispatch/request_test.rb
@@ -750,33 +750,33 @@ class RequestFormat < BaseRequestTest
   test "xml format" do
     request = stub_request
     assert_called(request, :parameters, times: 2, returns: {format: :xml}) do
-      assert_equal Mime::Type[:XML], request.format
+      assert_equal Mime[:xml], request.format
     end
   end
 
   test "xhtml format" do
     request = stub_request
     assert_called(request, :parameters, times: 2, returns: {format: :xhtml}) do
-      assert_equal Mime::Type[:HTML], request.format
+      assert_equal Mime[:html], request.format
     end
   end
 
   test "txt format" do
     request = stub_request
     assert_called(request, :parameters, times: 2, returns: {format: :txt}) do
-      assert_equal Mime::Type[:TEXT], request.format
+      assert_equal Mime[:text], request.format
     end
   end
 
   test "XMLHttpRequest" do
     request = stub_request(
       'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest',
-      'HTTP_ACCEPT' => [Mime::Type[:JS], Mime::Type[:HTML], Mime::Type[:XML], "text/xml", Mime::Type[:ALL]].join(",")
+      'HTTP_ACCEPT' => [Mime[:js], Mime[:html], Mime[:xml], "text/xml", "*/*"].join(",")
     )
 
     assert_called(request, :parameters, times: 1, returns: {}) do
       assert request.xhr?
-      assert_equal Mime::Type[:JS], request.format
+      assert_equal Mime[:js], request.format
     end
   end
 
@@ -796,29 +796,29 @@ class RequestFormat < BaseRequestTest
 
   test "formats text/html with accept header" do
     request = stub_request 'HTTP_ACCEPT' => 'text/html'
-    assert_equal [Mime::Type[:HTML]], request.formats
+    assert_equal [Mime[:html]], request.formats
   end
 
   test "formats blank with accept header" do
     request = stub_request 'HTTP_ACCEPT' => ''
-    assert_equal [Mime::Type[:HTML]], request.formats
+    assert_equal [Mime[:html]], request.formats
   end
 
   test "formats XMLHttpRequest with accept header" do
     request = stub_request 'HTTP_X_REQUESTED_WITH' => "XMLHttpRequest"
-    assert_equal [Mime::Type[:JS]], request.formats
+    assert_equal [Mime[:js]], request.formats
   end
 
   test "formats application/xml with accept header" do
     request = stub_request('CONTENT_TYPE' => 'application/xml; charset=UTF-8',
                            'HTTP_X_REQUESTED_WITH' => "XMLHttpRequest")
-    assert_equal [Mime::Type[:XML]], request.formats
+    assert_equal [Mime[:xml]], request.formats
   end
 
   test "formats format:text with accept header" do
     request = stub_request
     assert_called(request, :parameters, times: 2, returns: {format: :txt}) do
-      assert_equal [Mime::Type[:TEXT]], request.formats
+      assert_equal [Mime[:text]], request.formats
     end
   end
 
@@ -848,7 +848,7 @@ class RequestFormat < BaseRequestTest
   test "formats with xhr request" do
     request = stub_request 'HTTP_X_REQUESTED_WITH' => "XMLHttpRequest"
     assert_called(request, :parameters, times: 1, returns: {}) do
-      assert_equal [Mime::Type[:JS]], request.formats
+      assert_equal [Mime[:js]], request.formats
     end
   end
 
@@ -859,35 +859,35 @@ class RequestFormat < BaseRequestTest
     begin
       request = stub_request 'HTTP_ACCEPT' => 'application/xml'
       assert_called(request, :parameters, times: 1, returns: {}) do
-        assert_equal [ Mime::Type[:HTML] ], request.formats
+        assert_equal [ Mime[:html] ], request.formats
       end
 
       request = stub_request 'HTTP_ACCEPT' => 'koz-asked/something-crazy'
       assert_called(request, :parameters, times: 1, returns: {}) do
-        assert_equal [ Mime::Type[:HTML] ], request.formats
+        assert_equal [ Mime[:html] ], request.formats
       end
 
       request = stub_request 'HTTP_ACCEPT' => '*/*;q=0.1'
       assert_called(request, :parameters, times: 1, returns: {}) do
-        assert_equal [ Mime::Type[:HTML] ], request.formats
+        assert_equal [ Mime[:html] ], request.formats
       end
 
       request = stub_request 'HTTP_ACCEPT' => 'application/jxw'
       assert_called(request, :parameters, times: 1, returns: {}) do
-        assert_equal [ Mime::Type[:HTML] ], request.formats
+        assert_equal [ Mime[:html] ], request.formats
       end
 
       request = stub_request 'HTTP_ACCEPT' => 'application/xml',
                              'HTTP_X_REQUESTED_WITH' => "XMLHttpRequest"
 
       assert_called(request, :parameters, times: 1, returns: {}) do
-        assert_equal [ Mime::Type[:JS] ], request.formats
+        assert_equal [ Mime[:js] ], request.formats
       end
 
       request = stub_request 'HTTP_ACCEPT' => 'application/xml',
                              'HTTP_X_REQUESTED_WITH' => "XMLHttpRequest"
       assert_called(request, :parameters, times: 2, returns: {format: :json}) do
-        assert_equal [ Mime::Type[:JSON] ], request.formats
+        assert_equal [ Mime[:json] ], request.formats
       end
     ensure
       ActionDispatch::Request.ignore_accept_header = old_ignore_accept_header
@@ -897,7 +897,7 @@ end
 
 class RequestMimeType < BaseRequestTest
   test "content type" do
-    assert_equal Mime::Type[:HTML], stub_request('CONTENT_TYPE' => 'text/html').content_mime_type
+    assert_equal Mime[:html], stub_request('CONTENT_TYPE' => 'text/html').content_mime_type
   end
 
   test "no content type" do
@@ -905,11 +905,11 @@ class RequestMimeType < BaseRequestTest
   end
 
   test "content type is XML" do
-    assert_equal Mime::Type[:XML], stub_request('CONTENT_TYPE' => 'application/xml').content_mime_type
+    assert_equal Mime[:xml], stub_request('CONTENT_TYPE' => 'application/xml').content_mime_type
   end
 
   test "content type with charset" do
-    assert_equal Mime::Type[:XML], stub_request('CONTENT_TYPE' => 'application/xml; charset=UTF-8').content_mime_type
+    assert_equal Mime[:xml], stub_request('CONTENT_TYPE' => 'application/xml; charset=UTF-8').content_mime_type
   end
 
   test "user agent" do
@@ -922,9 +922,9 @@ class RequestMimeType < BaseRequestTest
       'HTTP_X_REQUESTED_WITH' => "XMLHttpRequest"
     )
 
-    assert_equal nil, request.negotiate_mime([Mime::Type[:XML], Mime::Type[:JSON]])
-    assert_equal Mime::Type[:HTML], request.negotiate_mime([Mime::Type[:XML], Mime::Type[:HTML]])
-    assert_equal Mime::Type[:HTML], request.negotiate_mime([Mime::Type[:XML], Mime::Type[:ALL]])
+    assert_equal nil, request.negotiate_mime([Mime[:xml], Mime[:json]])
+    assert_equal Mime[:html], request.negotiate_mime([Mime[:xml], Mime[:html]])
+    assert_equal Mime[:html], request.negotiate_mime([Mime[:xml], Mime::ALL])
   end
 
   test "negotiate_mime with content_type" do
@@ -933,7 +933,7 @@ class RequestMimeType < BaseRequestTest
       'HTTP_X_REQUESTED_WITH' => "XMLHttpRequest"
     )
 
-    assert_equal Mime::Type[:XML], request.negotiate_mime([Mime::Type[:XML], Mime::Type[:CSV]])
+    assert_equal Mime[:xml], request.negotiate_mime([Mime[:xml], Mime[:csv]])
   end
 end
 
diff --git a/actionpack/test/dispatch/response_test.rb b/actionpack/test/dispatch/response_test.rb
index c4f52fcc3a..126379a23c 100644
--- a/actionpack/test/dispatch/response_test.rb
+++ b/actionpack/test/dispatch/response_test.rb
@@ -184,13 +184,13 @@ class ResponseTest < ActiveSupport::TestCase
   test "read charset and content type" do
     resp = ActionDispatch::Response.new.tap { |response|
       response.charset = 'utf-16'
-      response.content_type = Mime::Type[:XML]
+      response.content_type = Mime[:xml]
       response.body = 'Hello'
     }
     resp.to_a
 
     assert_equal('utf-16', resp.charset)
-    assert_equal(Mime::Type[:XML], resp.content_type)
+    assert_equal(Mime[:xml], resp.content_type)
 
     assert_equal('application/xml; charset=utf-16', resp.headers['Content-Type'])
   end
@@ -392,7 +392,7 @@ class ResponseIntegrationTest < ActionDispatch::IntegrationTest
     @app = lambda { |env|
       ActionDispatch::Response.new.tap { |resp|
         resp.charset = 'utf-16'
-        resp.content_type = Mime::Type[:XML]
+        resp.content_type = Mime[:xml]
         resp.body = 'Hello'
       }.to_a
     }
@@ -401,7 +401,7 @@ class ResponseIntegrationTest < ActionDispatch::IntegrationTest
     assert_response :success
 
     assert_equal('utf-16', @response.charset)
-    assert_equal(Mime::Type[:XML], @response.content_type)
+    assert_equal(Mime[:xml], @response.content_type)
 
     assert_equal('application/xml; charset=utf-16', @response.headers['Content-Type'])
   end
@@ -417,7 +417,7 @@ class ResponseIntegrationTest < ActionDispatch::IntegrationTest
     assert_response :success
 
     assert_equal('utf-16', @response.charset)
-    assert_equal(Mime::Type[:XML], @response.content_type)
+    assert_equal(Mime[:xml], @response.content_type)
 
     assert_equal('application/xml; charset=utf-16', @response.headers['Content-Type'])
   end