mime-types 2.99.3 → 3.3.1

data/test/test_mime_types.rb

@@ -1,121 +1,169 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'mime/types'
 require 'minitest_helper'
 
-class TestMIMETypes < Minitest::Test
-  def setup
-    @mime_types = MIME::Types.new
-    @mime_types.add(MIME::Type.new(['text/plain', %w(txt)]),
-                    MIME::Type.new(['image/jpeg', %w(jpg jpeg)]),
-                    MIME::Type.new('application/x-wordperfect6.1'),
-                    MIME::Type.new('content-type' => 'application/x-www-form-urlencoded', 'registered' => true),
-                    MIME::Type.new(['application/x-gzip', %w(gz)]),
-                    MIME::Type.new(['application/gzip', %w(gz)]))
+describe MIME::Types do
+  def mime_types
+    @mime_types ||= MIME::Types.new.tap { |mt|
+      mt.add MIME::Type.new(['text/plain', %w(txt)]),
+             MIME::Type.new(['image/jpeg', %w(jpg jpeg)]),
+             MIME::Type.new('application/x-wordperfect6.1'),
+             MIME::Type.new(
+               'content-type' => 'application/x-www-form-urlencoded',
+               'registered' => true
+             ),
+             MIME::Type.new(['application/x-gzip', %w(gz)]),
+             MIME::Type.new(
+               'content-type' => 'application/gzip',
+               'extensions' => 'gz',
+               'registered' => true
+             )
+    }
   end
 
-  def test_enumerable
-    assert(@mime_types.any? { |type| type.content_type == 'text/plain' })
-    assert_kind_of(Enumerator, @mime_types.each)
-    assert_equal(6, @mime_types.each.count)
-  end
+  describe 'is enumerable' do
+    it 'correctly uses an Enumerable method like #any?' do
+      assert(mime_types.any? { |type| type.content_type == 'text/plain' })
+    end
 
-  def test_index_with_mime_type
-    xtxp = MIME::Type.new('x-text/x-plain')
-    assert_includes(@mime_types[xtxp], 'text/plain')
-    assert_equal(1, @mime_types[xtxp].size)
-  end
+    it 'implements each with no parameters to return an Enumerator' do
+      assert_kind_of Enumerator, mime_types.each
+      assert_kind_of Enumerator, mime_types.map
+    end
 
-  def test_index_with_regex
-    assert_includes(@mime_types[/plain/], 'text/plain')
-    assert_equal(1, @mime_types[/plain/].size)
-  end
+    it 'will create a lazy enumerator' do
+      assert_kind_of Enumerator::Lazy, mime_types.lazy
+      assert_kind_of Enumerator::Lazy, mime_types.map.lazy
+    end
 
-  def test_index_with_string
-    assert_includes(@mime_types['text/plain'], 'text/plain')
-    assert_equal(1, @mime_types['text/plain'].size)
+    it 'is countable with an enumerator' do
+      assert_equal 6, mime_types.each.count
+      assert_equal 6, mime_types.lazy.count
+    end
   end
 
-  def test_index_with_complete_flag
-    assert_empty(@mime_types['text/vnd.fly', complete: true])
-    refute_empty(@mime_types['text/plain', complete: true])
-  end
+  describe '#[]' do
+    it 'can be searched with a MIME::Type' do
+      text_plain = MIME::Type.new('text/plain')
+      assert_includes mime_types[text_plain], 'text/plain'
+      assert_equal 1, mime_types[text_plain].size
+    end
 
-  def test_index_with_registered_flag
-    assert_empty(@mime_types['application/x-wordperfect6.1',
-                             registered: true])
-    refute_empty(@mime_types['application/x-www-form-urlencoded',
-                             registered: true])
-    refute_empty(@mime_types['application/gzip', registered: true])
-    refute_equal(@mime_types['application/gzip'].size,
-                 @mime_types['application/gzip', registered: true])
-  end
+    it 'can be searched with a regular expression' do
+      assert_includes mime_types[/plain$/], 'text/plain'
+      assert_equal 1, mime_types[/plain$/].size
+    end
 
-  def test_index_with_platform_flag
-    assert_deprecated('MIME::Types#[]', 'using the :platform flag') do
-      refute_empty MIME::Types['text/plain', platform: true]
+    it 'sorts by priority with multiple matches' do
+      assert_equal %w(application/gzip application/x-gzip), mime_types[/gzip$/]
+      assert_equal 2, mime_types[/gzip$/].size
+    end
+
+    it 'can be searched with a string' do
+      assert_includes mime_types['text/plain'], 'text/plain'
+      assert_equal 1, mime_types['text/plain'].size
     end
-  end
 
-  def test_add
-    eruby = MIME::Type.new('application/x-eruby') do |t|
-      t.extensions = 'rhtml'
-      t.encoding = '8bit'
+    it 'can be searched with the complete flag' do
+      assert_empty mime_types[
+        'application/x-www-form-urlencoded',
+        complete: true
+      ]
+      assert_includes mime_types['text/plain', complete: true], 'text/plain'
+      assert_equal 1, mime_types['text/plain', complete: true].size
     end
 
-    @mime_types.add(eruby)
+    it 'can be searched with the registered flag' do
+      assert_empty mime_types['application/x-wordperfect6.1', registered: true]
+      refute_empty mime_types[
+        'application/x-www-form-urlencoded',
+        registered: true
+      ]
+      refute_empty mime_types[/gzip/, registered: true]
+      refute_equal mime_types[/gzip/], mime_types[/gzip/, registered: true]
+    end
 
-    assert_equal(@mime_types['application/x-eruby'], [eruby])
+    it 'properly returns an empty result on a regular expression miss' do
+      assert_empty mime_types[/^foo/]
+      assert_empty mime_types[/^foo/, registered: true]
+      assert_empty mime_types[/^foo/, complete: true]
+    end
   end
 
-  def test_type_for
-    assert_equal(%w(application/gzip application/x-gzip),
-                 @mime_types.type_for('gz'))
-    assert_equal(%w(image/jpeg), MIME::Types.of('foo.jpeg'))
-    assert_equal(%w(image/jpeg text/plain),
-                 MIME::Types.type_for(%w(foo.txt foo.jpeg)))
-    assert_deprecated('MIME::Types#type_for', 'using the platform parameter') do
-      assert_equal(@mime_types.of('gif', true), @mime_types['image/gif'])
+  describe '#add' do
+    let(:eruby) { MIME::Type.new('application/x-eruby') }
+    let(:jinja) { MIME::Type.new('application/jinja2') }
+
+    it 'successfully adds a new type' do
+      mime_types.add(eruby)
+      assert_equal mime_types['application/x-eruby'], [eruby]
     end
-    assert_empty(MIME::Types.type_for('coverallsjson'))
-    assert_deprecated('MIME::Types#type_for', 'using the platform parameter') do
-      assert_equal @mime_types.type_for('jpeg', true), @mime_types['image/jpeg']
+
+    it 'complains about adding a duplicate type' do
+      mime_types.add(eruby)
+      assert_output '', /is already registered as a variant/ do
+        mime_types.add(eruby)
+      end
+      assert_equal mime_types['application/x-eruby'], [eruby]
     end
-    assert_empty(@mime_types.type_for('zzz'))
-  end
 
-  def test_count
-    assert_equal(6, @mime_types.count)
-  end
+    it 'does not complain about adding a duplicate type when quiet' do
+      mime_types.add(eruby)
+      assert_output '', '' do
+        mime_types.add(eruby, :silent)
+      end
+      assert_equal mime_types['application/x-eruby'], [eruby]
+    end
 
-  # This tests the instance implementation through the class implementation.
-  def test_add_type_variant
-    xtxp = MIME::Type.new('x-text/x-plain')
-    assert_deprecated('MIME::Types#add_type_variant', 'and will be private') do
-      @mime_types.add_type_variant(xtxp)
+    it 'successfully adds from an array' do
+      mime_types.add([eruby, jinja])
+      assert_equal mime_types['application/x-eruby'], [eruby]
+      assert_equal mime_types['application/jinja2'], [jinja]
     end
-    assert_includes(@mime_types['text/plain'], xtxp)
-  end
 
-  def test_data_version
-    assert_equal(MIME::Type::VERSION, @mime_types.data_version)
-  end
+    it 'successfully adds from another MIME::Types' do
+      mt = MIME::Types.new
+      mt.add(mime_types)
+      assert_equal mime_types.count, mt.count
 
-  # This tests the instance implementation through the class implementation.
-  def test_index_extensions
-    xtxp = MIME::Type.new(['x-text/x-plain', %w(tzt)])
-    assert_deprecated('MIME::Types#index_extensions', 'and will be private') do
-      @mime_types.index_extensions(xtxp)
+      mime_types.each do |type|
+        assert_equal mt[type.content_type], [type]
+      end
     end
-    assert_includes(@mime_types.of('tzt'), xtxp)
   end
 
-  def test_defined_types
-    assert_deprecated('MIME::Types#defined_types') do
-      assert_empty(MIME::Types.new.defined_types)
+  describe '#type_for' do
+    it 'finds all types for a given extension' do
+      assert_equal %w(application/gzip application/x-gzip),
+                   mime_types.type_for('gz')
+    end
+
+    it 'separates the extension from filenames' do
+      assert_equal %w(image/jpeg), mime_types.of(['foo.jpeg', 'bar.jpeg'])
     end
-    assert_deprecated('MIME::Types#defined_types') do
-      refute_empty(@mime_types.defined_types)
+
+    it 'finds multiple extensions' do
+      assert_equal %w(image/jpeg text/plain),
+                   mime_types.type_for(%w(foo.txt foo.jpeg))
+    end
+
+    it 'does not find unknown extensions' do
+      keys = mime_types.instance_variable_get(:@extension_index).keys
+      assert_empty mime_types.type_for('zzz')
+      assert_equal keys, mime_types.instance_variable_get(:@extension_index).keys
+    end
+
+    it 'modifying type extensions causes reindexing' do
+      plain_text = mime_types['text/plain'].first
+      plain_text.add_extensions('xtxt')
+      assert_includes mime_types.type_for('xtxt'), 'text/plain'
+    end
+  end
+
+  describe '#count' do
+    it 'can count the number of types inside' do
+      assert_equal 6, mime_types.count
     end
   end
 end

data/test/test_mime_types_cache.rb

@@ -1,19 +1,26 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'mime/types'
 require 'minitest_helper'
 
-class TestMIMETypesCache < Minitest::Test
-  def setup
+describe MIME::Types::Cache do
+  include Minitest::Hooks
+
+  MUTEX = Mutex.new
+
+  def around
     require 'fileutils'
-    @cache_file = File.expand_path('../cache.tst', __FILE__)
-    ENV['RUBY_MIME_TYPES_CACHE'] = @cache_file
-    clear_cache_file
-  end
 
-  def teardown
-    clear_cache_file
-    ENV.delete('RUBY_MIME_TYPES_CACHE')
+    MUTEX.synchronize do
+      @cache_file = File.expand_path('../cache.tst', __FILE__)
+      ENV['RUBY_MIME_TYPES_CACHE'] = @cache_file
+      clear_cache_file
+
+      super
+
+      clear_cache_file
+      ENV.delete('RUBY_MIME_TYPES_CACHE')
+    end
   end
 
   def reset_mime_types
@@ -25,66 +32,87 @@ class TestMIMETypesCache < Minitest::Test
     FileUtils.rm @cache_file if File.exist? @cache_file
   end
 
-  def test_does_not_use_cache_when_unset
-    ENV.delete('RUBY_MIME_TYPES_CACHE')
-    assert_equal(nil, MIME::Types::Cache.load)
-  end
+  describe '.load' do
+    it 'does not use cache when RUBY_MIME_TYPES_CACHE is unset' do
+      ENV.delete('RUBY_MIME_TYPES_CACHE')
+      assert_nil MIME::Types::Cache.load
+    end
 
-  def test_does_not_use_cache_when_missing
-    assert_equal(nil, MIME::Types::Cache.load)
-  end
+    it 'does not use cache when missing' do
+      assert_nil MIME::Types::Cache.load
+    end
 
-  def test_does_not_create_cache_when_unset
-    ENV.delete('RUBY_MIME_TYPES_CACHE')
-    assert_equal(nil, MIME::Types::Cache.save)
-  end
+    it 'registers the data to be updated by #add_extensions' do
+      MIME::Types::Cache.save
+      reset_mime_types
+      assert_equal([], MIME::Types.type_for('foo.additional'))
+      html = MIME::Types['text/html'][0]
+      html.add_extensions('additional')
+      assert_equal([html], MIME::Types.type_for('foo.additional'))
+    end
 
-  def test_creates_cache
-    assert_equal(false, File.exist?(@cache_file))
-    MIME::Types::Cache.save
-    assert_equal(true, File.exist?(@cache_file))
+    it 'outputs an error when there is an invalid version' do
+      v = MIME::Types::Data::VERSION
+      MIME::Types::Data.send(:remove_const, :VERSION)
+      MIME::Types::Data.const_set(:VERSION, '0.0')
+      MIME::Types::Cache.save
+      MIME::Types::Data.send(:remove_const, :VERSION)
+      MIME::Types::Data.const_set(:VERSION, v)
+      MIME::Types.instance_variable_set(:@__types__, nil)
+      assert_output '', /MIME::Types cache: invalid version/ do
+        MIME::Types['text/html']
+      end
+    end
+
+    it 'outputs an error when there is a marshal file incompatibility' do
+      MIME::Types::Cache.save
+      data = File.binread(@cache_file).reverse
+      File.open(@cache_file, 'wb') do |f| f.write(data) end
+      MIME::Types.instance_variable_set(:@__types__, nil)
+      assert_output '', /incompatible marshal file format/ do
+        MIME::Types['text/html']
+      end
+    end
   end
 
-  def test_uses_cache
-    MIME::Types['text/html'].first.extensions << 'hex'
-    MIME::Types::Cache.save
-    MIME::Types.instance_variable_set(:@__types__, nil)
+  describe '.save' do
+    it 'does not create cache when RUBY_MIME_TYPES_CACHE is unset' do
+      ENV.delete('RUBY_MIME_TYPES_CACHE')
+      assert_nil MIME::Types::Cache.save
+    end
 
-    assert_includes(MIME::Types['text/html'].first.extensions, 'hex')
+    it 'creates the cache ' do
+      assert_equal(false, File.exist?(@cache_file))
+      MIME::Types::Cache.save
+      assert_equal(true, File.exist?(@cache_file))
+    end
 
-    reset_mime_types
-  end
+    it 'uses the cache' do
+      MIME::Types['text/html'].first.add_extensions('hex')
+      MIME::Types::Cache.save
+      MIME::Types.instance_variable_set(:@__types__, nil)
 
-  def test_load_different_version
-    v = MIME::Types::VERSION.dup
-    MIME::Types::VERSION.gsub!(/.*/, '0.0')
-    MIME::Types::Cache.save
-    MIME::Types::VERSION.gsub!(/.*/, v)
-    MIME::Types.instance_variable_set(:@__types__, nil)
-    assert_output(nil, /MIME::Types cache: invalid version/) do
-      MIME::Types['text/html']
-    end
-  end
+      assert_includes MIME::Types['text/html'].first.extensions, 'hex'
 
-  def test_cache_load_failure
-    MIME::Types::Cache.save
-    data = File.binread(@cache_file).reverse
-    File.open(@cache_file, 'wb') { |f| f.write(data) }
-    MIME::Types.instance_variable_set(:@__types__, nil)
-    assert_output(nil, /Could not load MIME::Types cache: incompatible marshal file format/) do
-      MIME::Types['text/html']
+      reset_mime_types
     end
   end
+end
 
-  def test_container_marshalling
+describe MIME::Types::Container do
+  it 'marshals and unmarshals correctly' do
     container = MIME::Types::Container.new
-    # default proc should return []
-    assert_equal([], container['abc'])
+    container.add('xyz', 'abc')
+
+    # default proc should return Set[]
+    assert_equal(Set[], container['abc'])
+    assert_equal(Set['abc'], container['xyz'])
 
     marshalled = Marshal.dump(container)
     loaded_container = Marshal.load(marshalled)
 
-    # default proc should still return []
-    assert_equal([], loaded_container['abcd'])
+    # default proc should still return Set[]
+    assert_equal(Set[], loaded_container['abc'])
+    assert_equal(Set['abc'], container['xyz'])
   end
 end

data/test/test_mime_types_class.rb

@@ -1,139 +1,159 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'mime/types'
 require 'minitest_helper'
 
-class TestMIMETypesQueryClassMethods < Minitest::Test
+describe MIME::Types, 'registry' do
   def setup
     MIME::Types.send(:load_default_mime_types)
   end
 
-  def test_enumerable
-    assert(MIME::Types.any? { |type| type.content_type == 'text/plain' })
-    assert_kind_of(Enumerator, MIME::Types.each)
-    assert(MIME::Types.each.count > 999)
-  end
+  describe 'is enumerable' do
+    it 'correctly uses an Enumerable method like #any?' do
+      assert(MIME::Types.any? { |type| type.content_type == 'text/plain' })
+    end
 
-  def test_load_from_file
-    fn = File.expand_path('../fixture/old-data', __FILE__)
-    assert_deprecated('MIME::Types.load_from_file') do
-      MIME::Types.load_from_file(fn)
+    it 'implements each with no parameters to return an Enumerator' do
+      assert_kind_of Enumerator, MIME::Types.each
+      assert_kind_of Enumerator, MIME::Types.map
     end
-  end
 
-  def test_index_with_mime_type
-    xtxp = MIME::Type.new('x-text/x-plain')
-    assert_includes(MIME::Types[xtxp], 'text/plain')
-    assert_equal(1, MIME::Types[xtxp].size)
-  end
+    it 'will create a lazy enumerator' do
+      assert_kind_of Enumerator::Lazy, MIME::Types.lazy
+      assert_kind_of Enumerator::Lazy, MIME::Types.map.lazy
+    end
 
-  def test_index_with_regex
-    assert_includes(MIME::Types[/plain/], 'text/plain')
-    assert_equal(1, MIME::Types[/plain/].size)
+    it 'is countable with an enumerator' do
+      assert MIME::Types.each.count > 999
+      assert MIME::Types.lazy.count > 999
+    end
   end
 
-  def test_index_with_string
-    assert_includes(MIME::Types['text/plain'], 'text/plain')
-    assert_equal(1, MIME::Types['text/plain'].size)
-  end
+  describe '.[]' do
+    it 'can be searched with a MIME::Type' do
+      text_plain = MIME::Type.new('text/plain')
+      assert_includes MIME::Types[text_plain], 'text/plain'
+      assert_equal 1, MIME::Types[text_plain].size
+    end
 
-  def test_index_with_complete_flag
-    assert_empty(MIME::Types['application/1d-interleaved-parityfec', complete: true])
-    refute_empty(MIME::Types['text/plain', complete: true])
-  end
+    it 'can be searched with a regular expression' do
+      assert_includes MIME::Types[/plain$/], 'text/plain'
+      assert_equal 1, MIME::Types[/plain$/].size
+    end
 
-  def test_index_with_registered_flag
-    assert_empty(MIME::Types['application/x-wordperfect6.1',
-                             registered: true])
-    refute_empty(MIME::Types['application/x-www-form-urlencoded',
-                             registered: true])
-    refute_empty(MIME::Types['application/gzip', registered: true])
-    refute_equal(MIME::Types['application/gzip'].size,
-                 MIME::Types['application/gzip', registered: true])
-  end
+    it 'sorts by priority with multiple matches' do
+      types = MIME::Types[/gzip$/].select { |t|
+        %w(application/gzip application/x-gzip multipart/x-gzip).include?(t)
+      }
+      # This is this way because of a new type ending with gzip that only
+      # appears in some data files.
+      assert_equal %w(application/gzip application/x-gzip multipart/x-gzip), types
+      assert_equal 3, types.size
+    end
 
-  def test_index_with_platform_flag
-    assert_deprecated('MIME::Types#[]', 'using the :platform flag') do
-      refute_empty MIME::Types['text/plain', platform: true]
+    it 'can be searched with a string' do
+      assert_includes MIME::Types['text/plain'], 'text/plain'
+      assert_equal 1, MIME::Types['text/plain'].size
     end
-  end
 
-  def test_type_for
-    assert_equal(%w(application/xml text/xml), MIME::Types.type_for('xml'))
-    assert_equal(%w(image/gif), MIME::Types.of('foo.gif'))
-    assert_equal(%w(application/xml image/gif text/xml),
-                 MIME::Types.type_for(%w(xml gif)))
-    assert_deprecated('MIME::Types#type_for', 'using the platform parameter') do
-      refute_empty MIME::Types.type_for('gif', true)
+    it 'can be searched with the complete flag' do
+      assert_empty MIME::Types[
+        'application/x-www-form-urlencoded',
+        complete: true
+      ]
+      assert_includes MIME::Types['text/plain', complete: true], 'text/plain'
+      assert_equal 1, MIME::Types['text/plain', complete: true].size
     end
-    assert_empty(MIME::Types.type_for('zzz'))
-  end
 
-  def test_count
-    assert(MIME::Types.count.nonzero?,
-           'A lot of types are expected to be known.')
+    it 'can be searched with the registered flag' do
+      assert_empty MIME::Types['application/x-wordperfect6.1', registered: true]
+      refute_empty MIME::Types[
+        'application/x-www-form-urlencoded',
+        registered: true
+      ]
+      refute_empty MIME::Types[/gzip/, registered: true]
+      refute_equal MIME::Types[/gzip/], MIME::Types[/gzip/, registered: true]
+    end
   end
 
-  def test_cache_file
-    ENV['RUBY_MIME_TYPES_CACHE'] = 'foo'
-    assert_deprecated('MIME::Types.cache_file') do
-      assert_equal('foo', MIME::Types.cache_file)
+  describe '.type_for' do
+    it 'finds all types for a given extension' do
+      assert_equal %w(application/gzip application/x-gzip),
+                   MIME::Types.type_for('gz')
     end
-    ENV.delete('RUBY_MIME_TYPES_CACHE')
-    assert_deprecated('MIME::Types.cache_file') do
-      assert_nil(MIME::Types.cache_file)
+
+    it 'separates the extension from filenames' do
+      assert_equal %w(image/jpeg), MIME::Types.of(['foo.jpeg', 'bar.jpeg'])
     end
-  end
-end
 
-class TestMIMETypesClassMethods < Minitest::Test
-  def setup
-    MIME::Types.instance_variable_set(:@__types__, nil)
-    MIME::Types.send(:load_default_mime_types)
-  end
+    it 'finds multiple extensions' do
+      assert_equal %w(image/jpeg text/plain),
+                   MIME::Types.type_for(%w(foo.txt foo.jpeg))
+    end
 
-  def test_add_with_type
-    MIME::Types.add(MIME::Type.new('application/x-eruby'))
-    refute_empty(MIME::Types['application/x-eruby'])
-  end
+    it 'does not find unknown extensions' do
+      assert_empty MIME::Types.type_for('zzz')
+    end
 
-  def test_add_with_types
-    mt = MIME::Types.new
-    mt.add MIME::Type.new('application/x-eruby')
-    MIME::Types.add(mt)
-    refute_empty(MIME::Types['application/x-eruby'])
+    it 'modifying type extensions causes reindexing' do
+      plain_text = MIME::Types['text/plain'].first
+      plain_text.add_extensions('xtxt')
+      assert_includes MIME::Types.type_for('xtxt'), 'text/plain'
+    end
   end
 
-  def test_add_with_array
-    MIME::Types.add([MIME::Type.new('application/x-eruby')])
-    refute_empty(MIME::Types['application/x-eruby'])
+  describe '.count' do
+    it 'can count the number of types inside' do
+      assert MIME::Types.count > 999
+    end
   end
 
-  def test_add_with_noise_suppression
-    assert_silent do
-      MIME::Types.add(MIME::Type.new('application/x-eruby'))
+  describe '.add' do
+    def setup
+      MIME::Types.instance_variable_set(:@__types__, nil)
+      MIME::Types.send(:load_default_mime_types)
+    end
+
+    let(:eruby) { MIME::Type.new('application/x-eruby') }
+    let(:jinja) { MIME::Type.new('application/jinja2') }
+
+    it 'successfully adds a new type' do
+      MIME::Types.add(eruby)
+      assert_equal MIME::Types['application/x-eruby'], [eruby]
     end
-    assert_output(nil, %r{application/x-eruby is already registered}) do
-      MIME::Types.add(MIME::Type.new('application/x-eruby'))
+
+    it 'complains about adding a duplicate type' do
+      MIME::Types.add(eruby)
+      assert_output '', /is already registered as a variant/ do
+        MIME::Types.add(eruby)
+      end
+      assert_equal MIME::Types['application/x-eruby'], [eruby]
     end
-    assert_silent do
-      MIME::Types.add(MIME::Type.new('application/x-eruby'), :silent)
+
+    it 'does not complain about adding a duplicate type when quiet' do
+      MIME::Types.add(eruby)
+      assert_silent do
+        MIME::Types.add(eruby, :silent)
+      end
+      assert_equal MIME::Types['application/x-eruby'], [eruby]
     end
-  end
 
-  def test_add_type_variant
-    xtxp = MIME::Type.new('x-text/x-plain')
-    assert_deprecated('MIME::Types#add_type_variant', 'and will be private') do
-      MIME::Types.add_type_variant(xtxp)
+    it 'successfully adds from an array' do
+      MIME::Types.add([eruby, jinja])
+      assert_equal MIME::Types['application/x-eruby'], [eruby]
+      assert_equal MIME::Types['application/jinja2'], [jinja]
     end
-    assert_includes(MIME::Types['text/plain'], xtxp)
-  end
 
-  def test_index_extensions
-    xtxp = MIME::Type.new(['x-text/x-plain', %w(tzt)])
-    assert_deprecated('MIME::Types#index_extensions', 'and will be private') do
-      MIME::Types.index_extensions(xtxp)
+    it 'successfully adds from another MIME::Types' do
+      old_count = MIME::Types.count
+
+      mt = MIME::Types.new
+      mt.add(eruby)
+
+      MIME::Types.add(mt)
+      assert_equal old_count + 1, MIME::Types.count
+
+      assert_equal MIME::Types[eruby.content_type], [eruby]
     end
-    assert_includes(MIME::Types.of('tzt'), xtxp)
   end
 end