mime-types 1.25.1 → 2.0

data/test/test_mime_types.rb

@@ -1,122 +1,113 @@
 # -*- ruby encoding: utf-8 -*-
 
 require 'mime/types'
+require 'minitest_helper'
 
 class TestMIMETypes < Minitest::Test
   def setup
-    MIME::Types.instance_variable_set(:@__types__, nil)
-    MIME::Types.send(:load_mime_types)
+    @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)]))
   end
 
-  def test_class_index_1
-    text_plain = MIME::Type.new('text/plain') do |t|
-      t.encoding = '8bit'
-      t.extensions = %w(asc txt c cc h hh cpp hpp dat hlp)
-    end
-    text_plain_vms = MIME::Type.new('text/plain') do |t|
-      t.encoding = '8bit'
-      t.extensions = %w(doc)
-      t.system = 'vms'
-    end
-
-    assert_equal(MIME::Types['text/plain'], [text_plain, text_plain_vms])
+  def test_enumerable
+    assert(@mime_types.any? {|type| type.content_type == 'text/plain'})
   end
 
-  def test_class_index_2
-    tst_bmp = MIME::Types["image/x-bmp"] +
-      MIME::Types["image/vnd.wap.wbmp"] + MIME::Types["image/x-win-bmp"]
-
-    assert_equal(tst_bmp.sort, MIME::Types[/bmp$/].sort)
+  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
 
-    MIME::Types['image/bmp'][0].system = RUBY_PLATFORM
+  def test_index_with_regex
+    assert_includes(@mime_types[/plain/], 'text/plain')
+    assert_equal(1, @mime_types[/plain/].size)
+  end
 
-    assert_equal([MIME::Type.from_array('image/x-bmp', ['bmp'])],
-                 MIME::Types[/bmp$/, { :platform => true }])
+  def test_index_with_string
+    assert_includes(@mime_types['text/plain'], 'text/plain')
+    assert_equal(1, @mime_types['text/plain'].size)
   end
 
-  def test_class_index_3
-    assert(MIME::Types['text/vnd.fly', { :complete => true }].empty?)
-    assert(!MIME::Types['text/plain', { :complete => true} ].empty?)
+  def test_index_with_complete_flag
+    assert_empty(@mime_types['text/vnd.fly', complete: true])
+    refute_empty(@mime_types['text/plain', complete: true])
   end
 
-  def _test_class_index_extensions
-    raise NotImplementedError, 'Need to write test_class_index_extensions'
+  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
 
-  def test_class_add
+  def test_index_with_platform_flag
+    assert_deprecated("MIME::Types#[]", "using the :platform flag") do
+      assert_empty(MIME::Types['text/plain', platform: true])
+    end
+  end
+  def test_add
     eruby = MIME::Type.new("application/x-eruby") do |t|
       t.extensions = "rhtml"
       t.encoding = "8bit"
     end
 
-    MIME::Types.add(eruby)
-
-    assert_equal(MIME::Types['application/x-eruby'], [eruby])
-  end
-
-  def _test_class_add_type_variant
-    raise NotImplementedError, 'Need to write test_class_add_type_variant'
-  end
-
-  def test_class_type_for
-    assert_equal(MIME::Types.type_for('xml').sort, [ MIME::Types['text/xml'], MIME::Types['application/xml'] ].sort)
-    assert_equal(MIME::Types.type_for('gif'), MIME::Types['image/gif'])
-    MIME::Types['image/gif'][0].system = RUBY_PLATFORM
-    assert_equal(MIME::Types.type_for('gif', true), MIME::Types['image/gif'])
-    assert(MIME::Types.type_for('zzz').empty?)
-  end
-
-  def test_class_of
-    assert_equal(MIME::Types.of('xml').sort, [ MIME::Types['text/xml'], MIME::Types['application/xml'] ].sort)
-    assert_equal(MIME::Types.of('gif'), MIME::Types['image/gif'])
-    MIME::Types['image/gif'][0].system = RUBY_PLATFORM
-    assert_equal(MIME::Types.of('gif', true), MIME::Types['image/gif'])
-    assert(MIME::Types.of('zzz').empty?)
-  end
-
-  def test_class_enumerable
-    assert( MIME::Types.any? {|type| type.content_type == 'text/plain'} )
-  end
-
-  def test_class_count
-    assert(MIME::Types.count > 42, "A lot of types are expected to be known.")
-  end
-
-  def test_ebook_formats
-    assert_equal( MIME::Types['application/x-mobipocket-ebook'],  MIME::Types.type_for("book.mobi"))
-    assert_equal( MIME::Types['application/epub+zip'],  MIME::Types.type_for("book.epub"))
-    assert_equal( MIME::Types['application/x-ibooks+zip'], MIME::Types.type_for("book.ibooks") )
-  end
-
-  def test_apple_formats
-    assert_equal( MIME::Types['application/x-apple-diskimage'], MIME::Types.type_for("disk.dmg") )
-  end
+    @mime_types.add(eruby)
 
-  def _test_add
-    raise NotImplementedError, 'Need to write test_add'
+    assert_equal(@mime_types['application/x-eruby'], [eruby])
   end
 
-  def _test_add_type_variant
-    raise NotImplementedError, 'Need to write test_add_type_variant'
+  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_equal(@mime_types.of('gif', true), @mime_types['image/gif'])
+    assert_deprecated("MIME::Types#type_for", "using the platform parameter") do
+      assert_empty(MIME::Types.type_for('jpeg', true))
+    end
+    assert_empty(@mime_types.type_for('zzz'))
   end
 
-  def _test_data_version
-    raise NotImplementedError, 'Need to write test_data_version'
+  def test_count
+    assert_equal(6, @mime_types.count)
   end
 
-  def _test_index
-    raise NotImplementedError, 'Need to write test_index'
+  # 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)
+    end
+    assert_includes(@mime_types['text/plain'], xtxp)
   end
 
-  def _test_index_extensions
-    raise NotImplementedError, 'Need to write test_index_extensions'
+  def test_data_version
+    assert_equal(MIME::Type::VERSION, @mime_types.data_version)
   end
 
-  def _test_of
-    raise NotImplementedError, 'Need to write test_of'
+  # 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)
+    end
+    assert_includes(@mime_types.of('tzt'), xtxp)
   end
 
-  def _test_type_for
-    raise NotImplementedError, 'Need to write test_type_for'
+  def test_defined_types
+    assert_deprecated("MIME::Types#defined_types") do
+      assert_empty(MIME::Types.new.defined_types)
+    end
+    refute_empty(@mime_types.defined_types)
   end
 end

data/test/test_mime_types_cache.rb

@@ -1,6 +1,7 @@
 # -*- ruby encoding: utf-8 -*-
 
 require 'mime/types'
+require 'minitest_helper'
 
 class TestMIMETypesCache < Minitest::Test
   def setup
@@ -17,61 +18,61 @@ class TestMIMETypesCache < Minitest::Test
 
   def reset_mime_types
     MIME::Types.instance_variable_set(:@__types__, nil)
-    MIME::Types.send(:load_mime_types)
+    MIME::Types.send(:load_default_mime_types)
   end
 
   def clear_cache_file
     FileUtils.rm @cache_file if File.exist? @cache_file
   end
 
-  def test_uses_correct_cache_file
-    assert_equal(@cache_file, MIME::Types.cache_file)
-  end
-
   def test_does_not_use_cache_when_unset
     ENV.delete('RUBY_MIME_TYPES_CACHE')
-    assert_equal(nil, MIME::Types.send(:load_mime_types_from_cache))
-  end
-
-  def test_raises_exception_when_load_forced_without_cache_file
-    assert_raises(ArgumentError) {
-      ENV.delete('RUBY_MIME_TYPES_CACHE')
-      MIME::Types.send(:load_mime_types_from_cache!)
-    }
+    assert_equal(nil, MIME::Types::Cache.load)
   end
 
   def test_does_not_use_cache_when_missing
-    assert_equal(false, MIME::Types.send(:load_mime_types_from_cache))
+    assert_equal(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.send(:write_mime_types_to_cache))
-  end
-
-  def test_raises_exception_when_write_forced_without_cache_file
-    assert_raises(ArgumentError) {
-      ENV.delete('RUBY_MIME_TYPES_CACHE')
-      MIME::Types.send(:write_mime_types_to_cache!)
-    }
+    assert_equal(nil, MIME::Types::Cache.save)
   end
 
   def test_creates_cache
     assert_equal(false, File.exist?(@cache_file))
-    MIME::Types.send(:write_mime_types_to_cache)
+    MIME::Types::Cache.save
     assert_equal(true, File.exist?(@cache_file))
   end
 
   def test_uses_cache
-    html = MIME::Types['text/html'].first
-    html.extensions << 'hex'
-    MIME::Types.send(:write_mime_types_to_cache)
+    MIME::Types['text/html'].first.extensions << 'hex'
+    MIME::Types::Cache.save
     MIME::Types.instance_variable_set(:@__types__, nil)
 
-    assert_equal(true, MIME::Types.send(:load_mime_types_from_cache))
-    html = MIME::Types['text/html'].first
-    assert_includes(html.extensions, 'hex')
+    assert_includes(MIME::Types['text/html'].first.extensions, 'hex')
 
     reset_mime_types
   end
+
+  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
+
+  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']
+    end
+  end
 end

data/test/test_mime_types_class.rb

@@ -0,0 +1,135 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'mime/types'
+require 'minitest_helper'
+
+class TestMIMETypesQueryClassMethods < Minitest::Test
+  def setup
+    MIME::Types.send(:load_default_mime_types)
+  end
+
+  def test_enumerable
+    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)
+    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(2, MIME::Types[xtxp].size)
+  end
+
+  def test_index_with_regex
+    assert_includes(MIME::Types[/plain/], 'text/plain')
+    assert_equal(2, MIME::Types[/plain/].size)
+  end
+
+  def test_index_with_string
+    assert_includes(MIME::Types['text/plain'], 'text/plain')
+    assert_equal(2, MIME::Types['text/plain'].size)
+  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
+
+  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
+
+  def test_index_with_platform_flag
+    assert_deprecated("MIME::Types#[]", "using the :platform flag") do
+      assert_empty(MIME::Types['text/plain', platform: true])
+    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
+      assert_empty(MIME::Types.type_for('gif', true))
+    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.")
+  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)
+    end
+    ENV.delete('RUBY_MIME_TYPES_CACHE')
+    assert_nil(MIME::Types.cache_file)
+  end
+end
+
+class TestMIMETypesClassMethods < Minitest::Test
+  def setup
+    MIME::Types.instance_variable_set(:@__types__, nil)
+    MIME::Types.send(:load_default_mime_types)
+  end
+
+  def test_add_with_type
+    MIME::Types.add(MIME::Type.new("application/x-eruby"))
+    refute_empty(MIME::Types['application/x-eruby'])
+  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'])
+  end
+
+  def test_add_with_array
+    MIME::Types.add([MIME::Type.new("application/x-eruby")])
+    refute_empty(MIME::Types['application/x-eruby'])
+  end
+
+  def test_add_with_noise_suppression
+    assert_silent do
+      MIME::Types.add(MIME::Type.new("application/x-eruby"))
+    end
+    assert_output(nil, %r{application/x-eruby is already registered}) do
+      MIME::Types.add(MIME::Type.new("application/x-eruby"))
+    end
+    assert_silent do
+      MIME::Types.add(MIME::Type.new("application/x-eruby"), :silent)
+    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)
+    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)
+    end
+    assert_includes(MIME::Types.of('tzt'), xtxp)
+  end
+end

data/test/test_mime_types_lazy.rb

@@ -1,12 +1,13 @@
 # -*- ruby encoding: utf-8 -*-
 
 require 'mime/types'
+require 'minitest_helper'
 
 class TestMIMETypesLazy < Minitest::Test
   def setup
     ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = 'true'
     ENV['RUBY_MIME_TYPES_CACHE'] = File.expand_path('../cache.tst', __FILE__)
-    MIME::Types.send(:write_mime_types_to_cache)
+    MIME::Types::Cache.save
   end
 
   def teardown
@@ -20,7 +21,7 @@ class TestMIMETypesLazy < Minitest::Test
 
   def reset_mime_types
     MIME::Types.instance_variable_set(:@__types__, nil)
-    MIME::Types.send(:load_mime_types)
+    MIME::Types.send(:load_default_mime_types)
   end
 
   def test_lazy_load?