mime-types 1.17.2 → 3.0

data/test/test_mime_types.rb

@@ -1,99 +1,161 @@
-$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib") if __FILE__ == $0
+# -*- ruby encoding: utf-8 -*-
 
 require 'mime/types'
+require 'minitest_helper'
+
+describe MIME::Types do
+  def mime_types
+    @mime_types ||= MIME::Types.new.tap do |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
+  end
 
-class TestMIME_Types < MiniTest::Unit::TestCase #:nodoc:
-  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)
+  describe 'is enumerable' do
+    it 'correctly uses an Enumerable method like #any?' do
+      assert mime_types.any? { |type| type.content_type == 'text/plain' }
     end
-    text_plain_vms = MIME::Type.new('text/plain') do |t|
-      t.encoding = '8bit'
-      t.extensions = %w(doc)
-      t.system = 'vms'
+
+    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
+
+    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
 
-    assert_equal(MIME::Types['text/plain'], [text_plain, text_plain_vms])
+    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_class_index_2
-    tst_bmp = MIME::Types["image/x-bmp"] +
-      MIME::Types["image/vnd.wap.wbmp"] + MIME::Types["image/x-win-bmp"]
+  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
 
-    assert_equal(tst_bmp.sort, MIME::Types[/bmp$/].sort)
+    it 'can be searched with a regular expression' do
+      assert_includes mime_types[/plain$/], 'text/plain'
+      assert_equal 1, mime_types[/plain$/].size
+    end
 
-    MIME::Types['image/bmp'][0].system = RUBY_PLATFORM
+    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
 
-    assert_equal([MIME::Type.from_array('image/x-bmp', ['bmp'])],
-                 MIME::Types[/bmp$/, { :platform => true }])
-  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
 
-  def test_class_index_3
-    assert(MIME::Types['text/vnd.fly', { :complete => true }].empty?)
-    assert(!MIME::Types['text/plain', { :complete => true} ].empty?)
-  end
+    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
 
-  def _test_class_index_extensions
-    raise NotImplementedError, 'Need to write test_class_index_extensions'
+    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_class_add
-    eruby = MIME::Type.new("application/x-eruby") do |t|
-      t.extensions = "rhtml"
-      t.encoding = "8bit"
-    end
+  describe '#add' do
+    let(:eruby) { MIME::Type.new('application/x-eruby') }
+    let(:jinja) { MIME::Type.new('application/jinja2' )}
 
-    MIME::Types.add(eruby)
+    it 'successfully adds a new type' do
+      mime_types.add(eruby)
+      assert_equal mime_types['application/x-eruby'], [ eruby ]
+    end
 
-    assert_equal(MIME::Types['application/x-eruby'], [eruby])
-  end
+    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
 
-  def _test_class_add_type_variant
-    raise NotImplementedError, 'Need to write test_class_add_type_variant'
-  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
 
-  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
+    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
 
-  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
+    it 'successfully adds from another MIME::Types' do
+      mt = MIME::Types.new
+      mt.add(mime_types)
+      assert_equal mime_types.count, mt.count
 
-  def _test_add
-    raise NotImplementedError, 'Need to write test_add'
+      mime_types.each do |type|
+        assert_equal mt[type.content_type], [ type ]
+      end
+    end
   end
 
-  def _test_add_type_variant
-    raise NotImplementedError, 'Need to write test_add_type_variant'
-  end
+  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
 
-  def _test_data_version
-    raise NotImplementedError, 'Need to write test_data_version'
-  end
+    it 'separates the extension from filenames' do
+      assert_equal %w(image/jpeg), mime_types.of(['foo.jpeg', 'bar.jpeg'])
+    end
 
-  def _test_index
-    raise NotImplementedError, 'Need to write test_index'
-  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_index_extensions
-    raise NotImplementedError, 'Need to write test_index_extensions'
-  end
+    it 'does not find unknown extensions' do
+      assert_empty mime_types.type_for('zzz')
+    end
 
-  def _test_of
-    raise NotImplementedError, 'Need to write test_of'
+    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_type_for
-    raise NotImplementedError, 'Need to write test_type_for'
+  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

@@ -0,0 +1,100 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'mime/types'
+require 'minitest_helper'
+
+describe MIME::Types::Cache do
+  def setup
+    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')
+  end
+
+  def reset_mime_types
+    MIME::Types.instance_variable_set(:@__types__, nil)
+    MIME::Types.send(:load_default_mime_types)
+  end
+
+  def clear_cache_file
+    FileUtils.rm @cache_file if File.exist? @cache_file
+  end
+
+  describe '.load' do
+    it 'does not use cache when RUBY_MIME_TYPES_CACHE is unset' do
+      ENV.delete('RUBY_MIME_TYPES_CACHE')
+      assert_equal(nil, MIME::Types::Cache.load)
+    end
+
+    it 'does not use cache when missing' do
+      assert_equal(nil, MIME::Types::Cache.load)
+    end
+
+    it 'outputs an error when there is an invalid version' do
+      v = MIME::Types::Data::VERSION.dup
+      MIME::Types::Data::VERSION.gsub!(/.*/, '0.0')
+      MIME::Types::Cache.save
+      MIME::Types::Data::VERSION.gsub!(/.*/, 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') { |f| f.write(data) }
+      MIME::Types.instance_variable_set(:@__types__, nil)
+      assert_output '', /incompatible marshal file format/ do
+        MIME::Types['text/html']
+      end
+    end
+  end
+
+  describe '.save' do
+    it 'does not create cache when RUBY_MIME_TYPES_CACHE is unset' do
+      ENV.delete('RUBY_MIME_TYPES_CACHE')
+      assert_equal(nil, MIME::Types::Cache.save)
+    end
+
+    it 'creates the cache ' do
+      assert_equal(false, File.exist?(@cache_file))
+      MIME::Types::Cache.save
+      assert_equal(true, File.exist?(@cache_file))
+    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)
+
+      assert_includes MIME::Types['text/html'].first.extensions, 'hex'
+
+      reset_mime_types
+    end
+  end
+end
+
+describe MIME::Types::Container do
+  it 'marshals and unmarshals correctly' do
+    container = MIME::Types::Container.new
+    container['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 Set[]
+    assert_equal(Set[], loaded_container['abc'])
+    assert_equal(Set['abc'], container['xyz'])
+  end
+end

data/test/test_mime_types_class.rb

@@ -0,0 +1,155 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'mime/types'
+require 'minitest_helper'
+
+describe MIME::Types, 'registry' do
+  def setup
+    MIME::Types.send(:load_default_mime_types)
+  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
+
+    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
+
+    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
+
+    it 'is countable with an enumerator' do
+      assert MIME::Types.each.count > 999
+      assert MIME::Types.lazy.count > 999
+    end
+  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
+
+    it 'can be searched with a regular expression' do
+      assert_includes MIME::Types[/plain$/], 'text/plain'
+      assert_equal 1, MIME::Types[/plain$/].size
+    end
+
+    it 'sorts by priority with multiple matches' do
+      assert_equal %w(application/gzip application/x-gzip multipart/x-gzip),
+        MIME::Types[/gzip$/]
+      assert_equal 3, 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
+
+    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
+
+    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
+
+  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
+
+    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
+      assert_empty MIME::Types.type_for('zzz')
+    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 MIME::Types.count > 999
+    end
+  end
+
+  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
+
+    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
+
+    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
+
+    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
+
+    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
+  end
+end

data/test/test_mime_types_lazy.rb

@@ -0,0 +1,43 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'mime/types'
+require 'minitest_helper'
+
+describe MIME::Types, 'lazy loading' do
+  def setup
+    ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = 'true'
+  end
+
+  def teardown
+    reset_mime_types
+    ENV.delete('RUBY_MIME_TYPES_LAZY_LOAD')
+  end
+
+  def reset_mime_types
+    MIME::Types.instance_variable_set(:@__types__, nil)
+    MIME::Types.send(:load_default_mime_types)
+  end
+
+  describe '.lazy_load?' do
+    it 'is true when RUBY_MIME_TYPES_LAZY_LOAD is set' do
+      assert_equal true, MIME::Types.send(:lazy_load?)
+    end
+
+    it 'is nil when RUBY_MIME_TYPES_LAZY_LOAD is unset' do
+      ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = nil
+      assert_equal nil, MIME::Types.send(:lazy_load?)
+    end
+
+    it 'is false when RUBY_MIME_TYPES_LAZY_LOAD is false' do
+      ENV['RUBY_MIME_TYPES_LAZY_LOAD'] = 'false'
+      assert_equal false, MIME::Types.send(:lazy_load?)
+    end
+  end
+
+  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__)
+  end
+end

data/test/test_mime_types_loader.rb

@@ -0,0 +1,32 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'mime/types'
+require 'minitest_helper'
+
+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__)
+  end
+
+  def assert_correctly_loaded(types)
+    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(types['audio/vnd.qcelp'].first.obsolete?)
+    assert_equal('audio/QCELP', types['audio/vnd.qcelp'].first.use_instead)
+  end
+
+  it 'loads YAML files correctly' do
+    assert_correctly_loaded @loader.load_yaml
+  end
+
+  it 'loads JSON files correctly' do
+    assert_correctly_loaded @loader.load_json
+  end
+end