mime-types 2.99.3 → 3.4.1

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'
+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

data/test/test_mime_types_lazy.rb

@@ -1,28 +1,16 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'mime/types'
-require 'minitest_helper'
+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
+    ENV["RUBY_MIME_TYPES_LAZY_LOAD"] = "true"
   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
+    ENV.delete("RUBY_MIME_TYPES_LAZY_LOAD")
   end
 
   def reset_mime_types
@@ -30,18 +18,32 @@ class TestMIMETypesLazy < Minitest::Test
     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,59 +1,32 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'mime/types'
-require 'minitest_helper'
+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)
-    @bad_path = File.expand_path('../bad-fixtures', __FILE__)
+    @path = File.expand_path("../fixture", __FILE__)
+    @loader = MIME::Types::Loader.new(@path)
+    @bad_path = File.expand_path("../bad-fixtures", __FILE__)
   end
 
   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_includes(types, "application/1d-interleaved-parityfec")
+    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_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)
+    assert(types["audio/vnd.qcelp"].first.obsolete?)
+    assert_equal("audio/QCELP", types["audio/vnd.qcelp"].first.use_instead)
   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