mime-types 2.99.3 → 3.2.2

data/test/test_mime_types_class.rb

@@ -1,139 +1,161 @@
+# frozen_string_literal: true
+
 # -*- ruby encoding: utf-8 -*-
 
 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|
+        t == 'application/gzip' || t == 'application/x-gzip' || t == 'multipart/x-gzip'
+      }
+      # 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

data/test/test_mime_types_lazy.rb

@@ -1,47 +1,51 @@
+# frozen_string_literal: true
+
 # -*- ruby encoding: utf-8 -*-
 
 require 'mime/types'
 require 'minitest_helper'
 
-class TestMIMETypesLazy < Minitest::Test
+describe MIME::Types, 'lazy loading' do
   def setup
-    @cache_file = File.expand_path('../cache.tst', __FILE__)
     ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = 'true'
-    ENV['RUBY_MIME_TYPES_CACHE'] = @cache_file
-    MIME::Types::Cache.save
   end
 
   def teardown
-    clear_cache_file
     reset_mime_types
-    if File.exist? ENV['RUBY_MIME_TYPES_CACHE']
-      FileUtils.rm ENV['RUBY_MIME_TYPES_CACHE']
-      ENV.delete('RUBY_MIME_TYPES_CACHE')
-    end
     ENV.delete('RUBY_MIME_TYPES_LAZY_LOAD')
   end
 
-  def clear_cache_file
-    FileUtils.rm @cache_file if File.exist? @cache_file
-  end
-
   def reset_mime_types
     MIME::Types.instance_variable_set(:@__types__, nil)
     MIME::Types.send(:load_default_mime_types)
   end
 
-  def test_lazy_load?
-    assert_equal(true, MIME::Types.send(:lazy_load?))
-    ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = nil
-    assert_equal(nil, MIME::Types.send(:lazy_load?))
-    ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = 'false'
-    assert_equal(false, MIME::Types.send(:lazy_load?))
+  describe '.lazy_load?' do
+    it 'is true when RUBY_MIME_TYPES_LAZY_LOAD is set' do
+      assert_output '', /RUBY_MIME_TYPES_LAZY_LOAD/ do
+        assert_equal true, MIME::Types.send(:lazy_load?)
+      end
+    end
+
+    it 'is nil when RUBY_MIME_TYPES_LAZY_LOAD is unset' do
+      ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = nil
+      assert_output '', '' do
+        assert_nil MIME::Types.send(:lazy_load?)
+      end
+    end
+
+    it 'is false when RUBY_MIME_TYPES_LAZY_LOAD is false' do
+      ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = 'false'
+      assert_output '', /RUBY_MIME_TYPES_LAZY_LOAD/ do
+        assert_equal false, MIME::Types.send(:lazy_load?)
+      end
+    end
   end
 
-  def test_lazy_loading
+  it 'loads lazily when RUBY_MIME_TYPES_LAZY_LOAD is set' do
     MIME::Types.instance_variable_set(:@__types__, nil)
-    assert_nil(MIME::Types.instance_variable_get(:@__types__))
-    refute_nil(MIME::Types['text/html'].first)
-    refute_nil(MIME::Types.instance_variable_get(:@__types__))
+    assert_nil MIME::Types.instance_variable_get(:@__types__)
+    refute_nil MIME::Types['text/html'].first
+    refute_nil MIME::Types.instance_variable_get(:@__types__)
   end
 end

data/test/test_mime_types_loader.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 # -*- ruby encoding: utf-8 -*-
 
 require 'mime/types'
 require 'minitest_helper'
 
-class TestMIMETypesLoader < Minitest::Test
+describe MIME::Types::Loader do
   def setup
     @path     = File.expand_path('../fixture', __FILE__)
     @loader   = MIME::Types::Loader.new(@path)
@@ -12,48 +14,21 @@ class TestMIMETypesLoader < Minitest::Test
 
   def assert_correctly_loaded(types)
     assert_includes(types, 'application/1d-interleaved-parityfec')
-    assert_deprecated('MIME::Type#references') do
-      assert_empty types['application/acad'].first.references
-    end
-    assert_deprecated('MIME::Type#urls') do
-      assert_empty types['audio/webm'].first.urls
-    end
     assert_equal(%w(webm), types['audio/webm'].first.extensions)
     refute(types['audio/webm'].first.registered?)
 
     assert_equal('Fixes a bug with IE6 and progressive JPEGs',
                  types['image/pjpeg'].first.docs)
 
-    assert_deprecated('MIME::Type#system?') do
-      refute types['application/x-apple-diskimage'].first.system?
-    end
-    assert_deprecated('MIME::Type#system') do
-      assert_nil types['application/x-apple-diskimage'].first.system
-    end
-
     assert(types['audio/vnd.qcelp'].first.obsolete?)
     assert_equal('audio/QCELP', types['audio/vnd.qcelp'].first.use_instead)
   end
 
-  def test_load_yaml
-    assert_correctly_loaded(@loader.load_yaml)
-  end
-
-  def test_load_json
-    assert_correctly_loaded(@loader.load_json)
-  end
-
-  def test_load_v1
-    assert_deprecated('MIME::Types::Loader.load_v1') do
-      assert_correctly_loaded(@loader.load_v1)
-    end
+  it 'loads YAML files correctly' do
+    assert_correctly_loaded @loader.load_yaml
   end
 
-  def test_malformed_v1
-    assert_output(nil, /1: Parsing error in v1 MIME type definition/) {
-      assert_raises(MIME::Types::Loader::BadV1Format) {
-        MIME::Types::Loader.load_from_v1(File.join(@bad_path, 'malformed'))
-      }
-    }
+  it 'loads JSON files correctly' do
+    assert_correctly_loaded @loader.load_json
   end
 end