mime-types 1.16 → 3.5.2

data/test/test_mime_type.rb

@@ -1,356 +1,657 @@
-#! /usr/bin/env ruby
-#--
-# MIME::Types
-# A Ruby implementation of a MIME Types information library. Based in spirit
-# on the Perl MIME::Types information library by Mark Overmeer.
-# http://rubyforge.org/projects/mime-types/
-#
-# Licensed under the Ruby disjunctive licence with the GNU GPL or the Perl
-# Artistic licence. See Licence.txt for more information.
-#
-# Copyright 2003 - 2009 Austin Ziegler
-#++
-$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib") if __FILE__ == $0
-
-require 'mime/types'
-require 'test/unit' unless defined? $ZENTEST and $ZENTEST
-
-module TestMIME
-  class TestType < Test::Unit::TestCase #:nodoc:
-    def setup
-      @zip = MIME::Type.new('x-appl/x-zip') { |t| t.extensions = ['zip', 'zp'] }
-    end
-
-    def test_class_from_array
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit', 'linux')
-      end
-      assert_instance_of(MIME::Type, @yaml)
-      assert_equal('text/yaml', @yaml.simplified)
+# frozen_string_literal: true
+
+require "mime/types"
+require "minitest_helper"
+
+describe MIME::Type do
+  def mime_type(content_type)
+    MIME::Type.new(content_type) { |mt| yield mt if block_given? }
+  end
+
+  let(:x_appl_x_zip) {
+    mime_type("x-appl/x-zip") { |t| t.extensions = %w[zip zp] }
+  }
+  let(:text_plain) { mime_type("text/plain") }
+  let(:text_html) { mime_type("text/html") }
+  let(:image_jpeg) { mime_type("image/jpeg") }
+  let(:application_javascript) {
+    mime_type("application/javascript") do |js|
+      js.friendly("en" => "JavaScript")
+      js.xrefs = {
+        "rfc" => %w[rfc4239 rfc4239],
+        "template" => %w[application/javascript]
+      }
+      js.encoding = "8bit"
+      js.extensions = %w[js sj]
+      js.registered = true
+    end
+  }
+  let(:text_x_yaml) {
+    mime_type("text/x-yaml") do |yaml|
+      yaml.extensions = %w[yaml yml]
+      yaml.encoding = "8bit"
+      yaml.friendly("en" => "YAML Structured Document")
+    end
+  }
+  let(:text_x_yaml_with_docs) {
+    text_x_yaml.dup.tap do |yaml|
+      yaml.docs = "Test YAML"
     end
+  }
 
-    def test_class_from_hash
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_hash('Content-Type' => 'text/x-yaml',
-                                   'Content-Transfer-Encoding' => '8bit',
-                                   'System' => 'linux',
-                                   'Extensions' => %w(yaml yml))
-      end
-      assert_instance_of(MIME::Type, @yaml)
-      assert_equal('text/yaml', @yaml.simplified)
+  describe ".simplified" do
+    it "leaves normal types alone" do
+      assert_equal "text/plain", MIME::Type.simplified("text/plain")
     end
 
-    def test_class_from_mime_type
-      assert_nothing_raised do
-        @zip2 = MIME::Type.from_mime_type(@zip)
-      end
-      assert_instance_of(MIME::Type, @zip)
-      assert_equal('appl/zip', @zip.simplified)
-      assert_not_equal(@zip.object_id, @zip2.object_id)
-    end
-
-    def test_class_simplified
-      assert_equal(MIME::Type.simplified('text/plain'), 'text/plain')
-      assert_equal(MIME::Type.simplified('image/jpeg'), 'image/jpeg')
-      assert_equal(MIME::Type.simplified('application/x-msword'), 'application/msword')
-      assert_equal(MIME::Type.simplified('text/vCard'), 'text/vcard')
-      assert_equal(MIME::Type.simplified('application/pkcs7-mime'), 'application/pkcs7-mime')
-      assert_equal(@zip.simplified, 'appl/zip')
-      assert_equal(MIME::Type.simplified('x-xyz/abc'), 'xyz/abc')
-    end
-
-    def test_CMP # '<=>'
-      assert(MIME::Type.new('text/plain') == MIME::Type.new('text/plain'))
-      assert(MIME::Type.new('text/plain') != MIME::Type.new('image/jpeg'))
-      assert(MIME::Type.new('text/plain') == 'text/plain')
-      assert(MIME::Type.new('text/plain') != 'image/jpeg')
-      assert(MIME::Type.new('text/plain') > MIME::Type.new('text/html'))
-      assert(MIME::Type.new('text/plain') > 'text/html')
-      assert(MIME::Type.new('text/html') < MIME::Type.new('text/plain'))
-      assert(MIME::Type.new('text/html') < 'text/plain')
-      assert('text/html' == MIME::Type.new('text/html'))
-      assert('text/html' < MIME::Type.new('text/plain'))
-      assert('text/plain' > MIME::Type.new('text/html'))
-    end
-
-    def test_ascii_eh
-      assert(MIME::Type.new('text/plain').ascii?)
-      assert(!MIME::Type.new('image/jpeg').ascii?)
-      assert(!MIME::Type.new('application/x-msword').ascii?)
-      assert(MIME::Type.new('text/vCard').ascii?)
-      assert(!MIME::Type.new('application/pkcs7-mime').ascii?)
-      assert(!@zip.ascii?)
-    end
-
-    def test_binary_eh
-      assert(!MIME::Type.new('text/plain').binary?)
-      assert(MIME::Type.new('image/jpeg').binary?)
-      assert(MIME::Type.new('application/x-msword').binary?)
-      assert(!MIME::Type.new('text/vCard').binary?)
-      assert(MIME::Type.new('application/pkcs7-mime').binary?)
-      assert(@zip.binary?)
-    end
-
-    def test_complete_eh
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'linux')
+    it "does not remove x- prefixes by default" do
+      assert_equal "application/x-msword",
+        MIME::Type.simplified("application/x-msword")
+      assert_equal "x-xyz/abc", MIME::Type.simplified("x-xyz/abc")
+    end
+
+    it "removes x- prefixes when requested" do
+      assert_equal "application/msword",
+        MIME::Type.simplified("application/x-msword", remove_x_prefix: true)
+      assert_equal "xyz/abc",
+        MIME::Type.simplified("x-xyz/abc", remove_x_prefix: true)
+    end
+
+    it "lowercases mixed-case types" do
+      assert_equal "text/vcard", MIME::Type.simplified("text/vCard")
+    end
+
+    it "returns nil when the value provided is not a valid content type" do
+      assert_nil MIME::Type.simplified("text")
+    end
+  end
+
+  describe ".i18n_key" do
+    it "converts text/plain to text.plain" do
+      assert_equal "text.plain", MIME::Type.i18n_key("text/plain")
+    end
+
+    it "does not remove x-prefixes" do
+      assert_equal "application.x-msword",
+        MIME::Type.i18n_key("application/x-msword")
+    end
+
+    it "converts text/vCard to text.vcard" do
+      assert_equal "text.vcard", MIME::Type.i18n_key("text/vCard")
+    end
+
+    it "returns nil when the value provided is not a valid content type" do
+      assert_nil MIME::Type.i18n_key("text")
+    end
+  end
+
+  describe ".new" do
+    it "fails if an invalid content type is provided" do
+      exception = assert_raises MIME::Type::InvalidContentType do
+        MIME::Type.new("apps")
       end
-      assert(@yaml.complete?)
-      assert_nothing_raised { @yaml.extensions = nil }
-      assert(!@yaml.complete?)
-    end
-
-    def test_content_type
-      assert_equal(MIME::Type.new('text/plain').content_type, 'text/plain')
-      assert_equal(MIME::Type.new('image/jpeg').content_type, 'image/jpeg')
-      assert_equal(MIME::Type.new('application/x-msword').content_type, 'application/x-msword')
-      assert_equal(MIME::Type.new('text/vCard').content_type, 'text/vCard')
-      assert_equal(MIME::Type.new('application/pkcs7-mime').content_type, 'application/pkcs7-mime')
-      assert_equal(@zip.content_type, 'x-appl/x-zip');
-    end
-
-    def test_encoding
-      assert_equal(MIME::Type.new('text/plain').encoding, 'quoted-printable')
-      assert_equal(MIME::Type.new('image/jpeg').encoding, 'base64')
-      assert_equal(MIME::Type.new('application/x-msword').encoding, 'base64')
-      assert_equal(MIME::Type.new('text/vCard').encoding, 'quoted-printable')
-      assert_equal(MIME::Type.new('application/pkcs7-mime').encoding, 'base64')
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'linux')
+      assert_equal 'Invalid Content-Type "apps"', exception.to_s
+    end
+
+    it "creates a valid content type just from a string" do
+      type = MIME::Type.new("text/x-yaml")
+
+      assert_instance_of MIME::Type, type
+      assert_equal "text/x-yaml", type.content_type
+    end
+
+    it "yields the content type in a block" do
+      MIME::Type.new("text/x-yaml") do |type|
+        assert_instance_of MIME::Type, type
+        assert_equal "text/x-yaml", type.content_type
       end
-      assert_equal(@yaml.encoding, '8bit')
-      assert_nothing_raised { @yaml.encoding = 'base64' }
-      assert_equal(@yaml.encoding, 'base64')
-      assert_nothing_raised { @yaml.encoding = :default }
-      assert_equal(@yaml.encoding, 'quoted-printable')
-      assert_raises(ArgumentError) { @yaml.encoding = 'binary' }
-      assert_equal(@zip.encoding, 'base64')
     end
 
-    def _test_default_encoding
-      raise NotImplementedError, 'Need to write test_default_encoding'
+    it "creates a valid content type from a hash" do
+      type = MIME::Type.new(
+        "content-type" => "text/x-yaml",
+        "obsolete" => true
+      )
+      assert_instance_of MIME::Type, type
+      assert_equal "text/x-yaml", type.content_type
+      assert type.obsolete?
     end
 
-    def _test_docs
-      raise NotImplementedError, 'Need to write test_docs'
+    it "creates a valid content type from an array" do
+      type = MIME::Type.new(%w[text/x-yaml yaml yml yz])
+      assert_instance_of MIME::Type, type
+      assert_equal "text/x-yaml", type.content_type
+      assert_equal %w[yaml yml yz], type.extensions
     end
+  end
 
-    def _test_docs_equals
-      raise NotImplementedError, 'Need to write test_docs_equals'
+  describe "#like?" do
+    it "compares two MIME::Types on #simplified values without x- prefixes" do
+      assert text_plain.like?(text_plain)
+      refute text_plain.like?(text_html)
     end
 
-    def test_eql?
-      assert(MIME::Type.new('text/plain').eql?(MIME::Type.new('text/plain')))
-      assert(!MIME::Type.new('text/plain').eql?(MIME::Type.new('image/jpeg')))
-      assert(!MIME::Type.new('text/plain').eql?('text/plain'))
-      assert(!MIME::Type.new('text/plain').eql?('image/jpeg'))
+    it "compares MIME::Type against string without x- prefixes" do
+      assert text_plain.like?(text_plain.to_s)
+      refute text_plain.like?(text_html.to_s)
     end
+  end
 
-    def _test_encoding
-      raise NotImplementedError, 'Need to write test_encoding'
+  describe "#<=>" do
+    it "correctly compares identical types" do
+      assert_equal text_plain, text_plain
     end
 
-    def _test_encoding_equals
-      raise NotImplementedError, 'Need to write test_encoding_equals'
+    it "correctly compares equivalent types" do
+      right = mime_type("text/Plain")
+      refute_same text_plain, right
+      assert_equal text_plain, right
     end
 
-    def test_extensions
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'linux')
-      end
-      assert_equal(@yaml.extensions, %w(yaml yml))
-      assert_nothing_raised { @yaml.extensions = 'yaml' }
-      assert_equal(@yaml.extensions, ['yaml'])
-      assert_equal(@zip.extensions.size, 2)
-      assert_equal(@zip.extensions, ['zip', 'zp'])
+    it "correctly compares types that sort earlier" do
+      refute_equal text_html, text_plain
+      assert_operator text_html, :<, text_plain
     end
 
-    def _test_extensions_equals
-      raise NotImplementedError, 'Need to write test_extensions_equals'
+    it "correctly compares types that sort later" do
+      refute_equal text_plain, text_html
+      assert_operator text_plain, :>, text_html
     end
 
-    def test_like_eh
-      assert(MIME::Type.new('text/plain').like?(MIME::Type.new('text/plain')))
-      assert(MIME::Type.new('text/plain').like?(MIME::Type.new('text/x-plain')))
-      assert(!MIME::Type.new('text/plain').like?(MIME::Type.new('image/jpeg')))
-      assert(MIME::Type.new('text/plain').like?('text/plain'))
-      assert(MIME::Type.new('text/plain').like?('text/x-plain'))
-      assert(!MIME::Type.new('text/plain').like?('image/jpeg'))
+    it "correctly compares types against equivalent strings" do
+      assert_equal text_plain, "text/plain"
     end
 
-    def test_media_type
-      assert_equal(MIME::Type.new('text/plain').media_type, 'text')
-      assert_equal(MIME::Type.new('image/jpeg').media_type, 'image')
-      assert_equal(MIME::Type.new('application/x-msword').media_type, 'application')
-      assert_equal(MIME::Type.new('text/vCard').media_type, 'text')
-      assert_equal(MIME::Type.new('application/pkcs7-mime').media_type, 'application')
-      assert_equal(MIME::Type.new('x-chemical/x-pdb').media_type, 'chemical')
-      assert_equal(@zip.media_type, 'appl')
+    it "correctly compares types against strings that sort earlier" do
+      refute_equal text_html, "text/plain"
+      assert_operator text_html, :<, "text/plain"
     end
 
-    def _test_obsolete_eh
-      raise NotImplementedError, 'Need to write test_obsolete_eh'
+    it "correctly compares types against strings that sort later" do
+      refute_equal text_plain, "text/html"
+      assert_operator text_plain, :>, "text/html"
     end
 
-    def _test_obsolete_equals
-      raise NotImplementedError, 'Need to write test_obsolete_equals'
+    it "correctly compares against nil" do
+      refute_equal text_html, nil
+      assert_operator text_plain, :<, nil
     end
+  end
 
-    def test_platform_eh
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'oddbox')
-      end
-      assert(!@yaml.platform?)
-      assert_nothing_raised { @yaml.system = nil }
-      assert(!@yaml.platform?)
-      assert_nothing_raised { @yaml.system = /#{RUBY_PLATFORM}/ }
-        assert(@yaml.platform?)
+  describe "#ascii?" do
+    it "defaults to true for text/* types" do
+      assert text_plain.ascii?
     end
 
-    def test_raw_media_type
-      assert_equal(MIME::Type.new('text/plain').raw_media_type, 'text')
-      assert_equal(MIME::Type.new('image/jpeg').raw_media_type, 'image')
-      assert_equal(MIME::Type.new('application/x-msword').raw_media_type, 'application')
-      assert_equal(MIME::Type.new('text/vCard').raw_media_type, 'text')
-      assert_equal(MIME::Type.new('application/pkcs7-mime').raw_media_type, 'application')
+    it "defaults to false for non-text/* types" do
+      refute image_jpeg.ascii?
+    end
+  end
 
-      assert_equal(MIME::Type.new('x-chemical/x-pdb').raw_media_type, 'x-chemical')
-      assert_equal(@zip.raw_media_type, 'x-appl')
+  describe "#binary?" do
+    it "defaults to false for text/* types" do
+      refute text_plain.binary?
     end
 
-    def test_raw_sub_type
-      assert_equal(MIME::Type.new('text/plain').raw_sub_type, 'plain')
-      assert_equal(MIME::Type.new('image/jpeg').raw_sub_type, 'jpeg')
-      assert_equal(MIME::Type.new('application/x-msword').raw_sub_type, 'x-msword')
-      assert_equal(MIME::Type.new('text/vCard').raw_sub_type, 'vCard')
-      assert_equal(MIME::Type.new('application/pkcs7-mime').raw_sub_type, 'pkcs7-mime')
-      assert_equal(@zip.raw_sub_type, 'x-zip')
+    it "defaults to true for non-text/* types" do
+      assert image_jpeg.binary?
     end
+  end
 
-    def test_registered_eh
-      assert(MIME::Type.new('text/plain').registered?)
-      assert(MIME::Type.new('image/jpeg').registered?)
-      assert(!MIME::Type.new('application/x-msword').registered?)
-      assert(MIME::Type.new('text/vCard').registered?)
-      assert(MIME::Type.new('application/pkcs7-mime').registered?)
-      assert(!@zip.registered?)
+  describe "#complete?" do
+    it "is true when there are extensions" do
+      assert text_x_yaml.complete?
     end
 
-    def _test_registered_equals
-      raise NotImplementedError, 'Need to write test_registered_equals'
+    it "is false when there are no extensions" do
+      refute mime_type("text/plain").complete?
     end
+  end
 
-    def test_signature_eh
-      assert(!MIME::Type.new('text/plain').signature?)
-      assert(!MIME::Type.new('image/jpeg').signature?)
-      assert(!MIME::Type.new('application/x-msword').signature?)
-      assert(MIME::Type.new('text/vCard').signature?)
-      assert(MIME::Type.new('application/pkcs7-mime').signature?)
+  describe "#content_type" do
+    it "preserves the original case" do
+      assert_equal "text/plain", text_plain.content_type
+      assert_equal "text/vCard", mime_type("text/vCard").content_type
     end
 
-    def test_simplified
-      assert_equal(MIME::Type.new('text/plain').simplified, 'text/plain')
-      assert_equal(MIME::Type.new('image/jpeg').simplified, 'image/jpeg')
-      assert_equal(MIME::Type.new('application/x-msword').simplified, 'application/msword')
-      assert_equal(MIME::Type.new('text/vCard').simplified, 'text/vcard')
-      assert_equal(MIME::Type.new('application/pkcs7-mime').simplified, 'application/pkcs7-mime')
-      assert_equal(MIME::Type.new('x-chemical/x-pdb').simplified, 'chemical/pdb')
+    it "does not remove x- prefixes" do
+      assert_equal "x-appl/x-zip", x_appl_x_zip.content_type
     end
+  end
 
-    def test_sub_type
-      assert_equal(MIME::Type.new('text/plain').sub_type, 'plain')
-      assert_equal(MIME::Type.new('image/jpeg').sub_type, 'jpeg')
-      assert_equal(MIME::Type.new('application/x-msword').sub_type, 'msword')
-      assert_equal(MIME::Type.new('text/vCard').sub_type, 'vcard')
-      assert_equal(MIME::Type.new('application/pkcs7-mime').sub_type, 'pkcs7-mime')
-      assert_equal(@zip.sub_type, 'zip')
+  describe "#default_encoding" do
+    it "is quoted-printable for text/* types" do
+      assert_equal "quoted-printable", text_plain.default_encoding
     end
 
-    def test_system_equals
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'linux')
-      end
-      assert_equal(@yaml.system, %r{linux})
-      assert_nothing_raised { @yaml.system = /win32/ }
-      assert_equal(@yaml.system, %r{win32})
-      assert_nothing_raised { @yaml.system = nil }
-      assert_nil(@yaml.system)
+    it "is base64 for non-text/* types" do
+      assert_equal "base64", image_jpeg.default_encoding
+    end
+  end
+
+  describe "#encoding, #encoding=" do
+    it "returns #default_encoding if not set explicitly" do
+      assert_equal "quoted-printable", text_plain.encoding
+      assert_equal "base64", image_jpeg.encoding
     end
 
-    def test_system_eh
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'linux')
+    it "returns the set value when set" do
+      text_plain.encoding = "8bit"
+      assert_equal "8bit", text_plain.encoding
+    end
+
+    it "resets to the default encoding when set to nil or :default" do
+      text_plain.encoding = "8bit"
+      text_plain.encoding = nil
+      assert_equal text_plain.default_encoding, text_plain.encoding
+      text_plain.encoding = :default
+      assert_equal text_plain.default_encoding, text_plain.encoding
+    end
+
+    it "raises a MIME::Type::InvalidEncoding for an invalid encoding" do
+      exception = assert_raises MIME::Type::InvalidEncoding do
+        text_plain.encoding = "binary"
       end
-      assert(@yaml.system?)
-      assert_nothing_raised { @yaml.system = nil }
-      assert(!@yaml.system?)
+      assert_equal 'Invalid Encoding "binary"', exception.to_s
+    end
+  end
+
+  describe "#eql?" do
+    it "is not true for a non-MIME::Type" do
+      refute text_plain.eql?("text/plain")
+    end
+
+    it "is not true for a different MIME::Type" do
+      refute text_plain.eql?(image_jpeg)
+    end
+
+    it "is true for an equivalent MIME::Type" do
+      assert text_plain.eql?(mime_type("text/Plain"))
+    end
+
+    it "is true for an equivalent subclass of MIME::Type" do
+      subclass = Class.new(MIME::Type)
+      assert text_plain.eql?(subclass.new("text/plain"))
+    end
+  end
+
+  describe "#hash" do
+    it "is the same between #eql? MIME::Type instances" do
+      assert_equal text_plain.hash, mime_type("text/plain").hash
+    end
+
+    it "is the same between #eql? MIME::Type instances of different classes" do
+      subclass = Class.new(MIME::Type)
+      assert_equal text_plain.hash, subclass.new("text/plain").hash
+    end
+
+    it "uses the #simplified value" do
+      assert_equal text_plain.hash, mime_type("text/Plain").hash
+    end
+  end
+
+  describe "#extensions, #extensions=" do
+    it "returns an array of extensions" do
+      assert_equal %w[yaml yml], text_x_yaml.extensions
+      assert_equal %w[zip zp], x_appl_x_zip.extensions
+    end
+
+    it "sets a single extension when provided a single value" do
+      text_x_yaml.extensions = "yaml"
+      assert_equal %w[yaml], text_x_yaml.extensions
+    end
+
+    it "deduplicates extensions" do
+      text_x_yaml.extensions = %w[yaml yaml]
+      assert_equal %w[yaml], text_x_yaml.extensions
+    end
+  end
+
+  describe "#add_extensions" do
+    it "does not modify extensions when provided nil" do
+      text_x_yaml.add_extensions(nil)
+      assert_equal %w[yaml yml], text_x_yaml.extensions
+    end
+
+    it "remains deduplicated with duplicate values" do
+      text_x_yaml.add_extensions("yaml")
+      assert_equal %w[yaml yml], text_x_yaml.extensions
+      text_x_yaml.add_extensions(%w[yaml yz])
+      assert_equal %w[yaml yml yz], text_x_yaml.extensions
+    end
+  end
+
+  describe "#priority_compare" do
+    def assert_priority_less(left, right)
+      assert_equal(-1, left.priority_compare(right))
+    end
+
+    def assert_priority_same(left, right)
+      assert_equal 0, left.priority_compare(right)
+    end
+
+    def assert_priority_more(left, right)
+      assert_equal 1, left.priority_compare(right)
+    end
+
+    def assert_priority(left, middle, right)
+      assert_priority_less left, right
+      assert_priority_same left, middle
+      assert_priority_more right, left
+    end
+
+    let(:text_1) { mime_type("text/1") }
+    let(:text_1p) { mime_type("text/1") }
+    let(:text_2) { mime_type("text/2") }
+
+    it "sorts (1) based on the simplified type" do
+      assert_priority text_1, text_1p, text_2
+    end
+
+    it "sorts (2) based on extensions" do
+      text_1.extensions = ["foo", "bar"]
+      text_2.extensions = ["foo"]
+
+      assert_priority_same text_1, text_2
+
+      text_2.registered = true
+
+      assert_priority_more text_1, text_2
+    end
+
+    it "sorts (3) based on the registration state" do
+      text_1.registered = text_1p.registered = true
+      text_1b = mime_type(text_1) { |t| t.registered = false }
+
+      assert_priority text_1, text_1p, text_1b
+    end
+
+    it "sorts (4) based on the completeness" do
+      text_1.extensions = text_1p.extensions = "1"
+      text_1b = mime_type(text_1) { |t| t.extensions = nil }
+
+      assert_priority text_1, text_1p, text_1b
+    end
+
+    it "sorts (5) based on obsolete status" do
+      text_1.obsolete = text_1p.obsolete = false
+      text_1b = mime_type(text_1) { |t| t.obsolete = true }
+
+      assert_priority text_1, text_1p, text_1b
+    end
+
+    it "sorts (5) based on the use-instead value" do
+      text_1.obsolete = text_1p.obsolete = true
+      text_1.use_instead = text_1p.use_instead = "abc/xyz"
+      text_1b = mime_type(text_1) { |t| t.use_instead = nil }
+
+      assert_priority text_1, text_1p, text_1b
+
+      text_1b.use_instead = "abc/zzz"
+
+      assert_priority text_1, text_1p, text_1b
+    end
+  end
+
+  describe "#raw_media_type" do
+    it "extracts the media type as case-preserved" do
+      assert_equal "Text", mime_type("Text/plain").raw_media_type
+    end
+
+    it "does not remove x- prefixes" do
+      assert_equal("x-appl", x_appl_x_zip.raw_media_type)
+    end
+  end
+
+  describe "#media_type" do
+    it "extracts the media type as lowercase" do
+      assert_equal "text", text_plain.media_type
+    end
+
+    it "does not remove x- prefixes" do
+      assert_equal("x-appl", x_appl_x_zip.media_type)
+    end
+  end
+
+  describe "#raw_media_type" do
+    it "extracts the media type as case-preserved" do
+      assert_equal "Text", mime_type("Text/plain").raw_media_type
     end
 
-    def test_to_a
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'linux')
+    it "does not remove x- prefixes" do
+      assert_equal("x-appl", x_appl_x_zip.raw_media_type)
+    end
+  end
+
+  describe "#sub_type" do
+    it "extracts the sub type as lowercase" do
+      assert_equal "plain", text_plain.sub_type
+    end
+
+    it "does not remove x- prefixes" do
+      assert_equal("x-zip", x_appl_x_zip.sub_type)
+    end
+  end
+
+  describe "#raw_sub_type" do
+    it "extracts the sub type as case-preserved" do
+      assert_equal "Plain", mime_type("text/Plain").raw_sub_type
+    end
+
+    it "does not remove x- prefixes" do
+      assert_equal("x-zip", x_appl_x_zip.raw_sub_type)
+    end
+  end
+
+  describe "#to_h" do
+    let(:t) { mime_type("a/b") }
+
+    def assert_has_keys(wanted_keys, actual, msg = nil)
+      wanted_keys = Array(wanted_keys).uniq.sort
+      actual_keys = if actual.is_a?(Hash)
+        actual.keys
+      else
+        actual.to_h.keys
       end
-      assert_equal(@yaml.to_a, ['text/x-yaml', %w(yaml yml), '8bit',
-                   /linux/, nil, nil, nil, false])
+
+      missing = wanted_keys - actual_keys
+      pretty_wanted_keys = (wanted_keys + actual_keys).uniq.sort
+
+      msg = message(msg) {
+        "#{mu_pp(actual)} is missing attribute values\n#{diff(pretty_wanted_keys, actual_keys)}"
+      }
+
+      assert missing.empty?, msg
+    end
+
+    it "has the required keys (content-type, registered, encoding)" do
+      assert_has_keys %w[content-type registered encoding], t
+    end
+
+    it "has the docs key if there are documents" do
+      assert_has_keys "docs", mime_type(t) { |v| v.docs = "a" }
     end
 
-    def test_to_hash
-      assert_nothing_raised do
-        @yaml = MIME::Type.from_array('text/x-yaml', %w(yaml yml), '8bit',
-                                    'linux')
+    it "has the extensions key if set" do
+      assert_has_keys "extensions", mime_type(t) { |v| v.extensions = "a" }
+    end
+
+    it "has the preferred-extension key if set" do
+      assert_has_keys "preferred-extension", mime_type(t) { |v| v.preferred_extension = "a" }
+    end
+
+    it "has the obsolete key if set" do
+      assert_has_keys "obsolete", mime_type(t) { |v| v.obsolete = true }
+    end
+
+    it "has the obsolete and use-instead keys if set" do
+      assert_has_keys %w[obsolete use-instead], mime_type(t) { |v|
+        v.obsolete = true
+        v.use_instead = "c/d"
+      }
+    end
+
+    it "has the signature key if set" do
+      assert_has_keys "signature", mime_type(t) { |v| v.signature = true }
+    end
+  end
+
+  describe "#to_json" do
+    let(:expected_1) {
+      '{"content-type":"a/b","encoding":"base64","registered":false}'
+    }
+    let(:expected_2) {
+      '{"content-type":"a/b","encoding":"base64","registered":true,"provisional":true}'
+    }
+
+    it "converts to JSON when requested" do
+      assert_equal expected_1, mime_type("a/b").to_json
+    end
+
+    it "converts to JSON with provisional when requested" do
+      type = mime_type("a/b") do |t|
+        t.registered = true
+        t.provisional = true
       end
-      assert_equal(@yaml.to_hash,
-                   { 'Content-Type' => 'text/x-yaml',
-                    'Content-Transfer-Encoding' => '8bit',
-                    'Extensions' => %w(yaml yml),
-                    'System' => /linux/,
-                    'Registered' => false,
-                    'URL' => nil,
-                    'Obsolete' => nil,
-                    'Docs' => nil })
-    end
-
-    def test_to_s
-      assert_equal("#{MIME::Type.new('text/plain')}", 'text/plain')
-    end
-
-    def test_class_constructors
-      assert_not_nil(@zip)
-      yaml = MIME::Type.new('text/x-yaml') do |y|
-        y.extensions = %w(yaml yml)
-        y.encoding = '8bit'
-        y.system = 'linux'
+      assert_equal expected_2, type.to_json
+    end
+  end
+
+  describe "#to_s, #to_str" do
+    it "represents itself as a string of the canonical content_type" do
+      assert_equal "text/plain", text_plain.to_s
+    end
+
+    it "acts like a string of the canonical content_type for comparison" do
+      assert_equal text_plain, "text/plain"
+    end
+
+    it "acts like a string for other purposes" do
+      assert_equal "stringy", "text/plain".sub(text_plain, "stringy")
+    end
+  end
+
+  describe "#xrefs, #xrefs=" do
+    let(:expected) {
+      MIME::Types::Container.new("rfc" => Set["rfc1234", "rfc5678"])
+    }
+
+    it "returns the expected results" do
+      application_javascript.xrefs = {
+        "rfc" => %w[rfc5678 rfc1234 rfc1234]
+      }
+
+      assert_equal expected, application_javascript.xrefs
+    end
+  end
+
+  describe "#xref_urls" do
+    let(:expected) {
+      [
+        "http://www.iana.org/go/draft1",
+        "http://www.iana.org/assignments/media-types/a/b",
+        "http://www.iana.org/assignments/media-types/media-types.xhtml#p-1",
+        "http://www.iana.org/go/rfc-1",
+        "http://www.rfc-editor.org/errata_search.php?eid=err-1",
+        "http://example.org",
+        "text"
+      ]
+    }
+
+    let(:type) {
+      mime_type("a/b").tap do |t|
+        t.xrefs = {
+          "draft" => ["RFC1"],
+          "template" => ["a/b"],
+          "person" => ["p-1"],
+          "rfc" => ["rfc-1"],
+          "rfc-errata" => ["err-1"],
+          "uri" => ["http://example.org"],
+          "text" => ["text"]
+        }
       end
-      assert_instance_of(MIME::Type, yaml)
-      assert_raises(MIME::InvalidContentType) { MIME::Type.new('apps') }
-      assert_raises(MIME::InvalidContentType) { MIME::Type.new(nil) }
+    }
+
+    it "translates according to given rules" do
+      assert_equal expected, type.xref_urls
+    end
+  end
+
+  describe "#use_instead" do
+    it "is nil unless the type is obsolete" do
+      assert_nil text_plain.use_instead
+    end
+
+    it "is nil if not set and the type is obsolete" do
+      text_plain.obsolete = true
+      assert_nil text_plain.use_instead
+    end
+
+    it "is a different type if set and the type is obsolete" do
+      text_plain.obsolete = true
+      text_plain.use_instead = "text/html"
+      assert_equal "text/html", text_plain.use_instead
+    end
+  end
+
+  describe "#preferred_extension, #preferred_extension=" do
+    it "is nil when not set and there are no extensions" do
+      assert_nil text_plain.preferred_extension
+    end
+
+    it "is the first extension when not set but there are extensions" do
+      assert_equal "yaml", text_x_yaml.preferred_extension
+    end
+
+    it "is the extension provided when set" do
+      text_x_yaml.preferred_extension = "yml"
+      assert_equal "yml", text_x_yaml.preferred_extension
+    end
+
+    it "is adds the preferred extension if it does not exist" do
+      text_x_yaml.preferred_extension = "yz"
+      assert_equal "yz", text_x_yaml.preferred_extension
+      assert_includes text_x_yaml.extensions, "yz"
+    end
+  end
+
+  describe "#friendly" do
+    it "returns English by default" do
+      assert_equal "YAML Structured Document", text_x_yaml.friendly
     end
 
-    def _test_to_str
-      raise NotImplementedError, 'Need to write test_to_str'
+    it "returns English when requested" do
+      assert_equal "YAML Structured Document", text_x_yaml.friendly("en")
+      assert_equal "YAML Structured Document", text_x_yaml.friendly(:en)
     end
 
-    def _test_url
-      raise NotImplementedError, 'Need to write test_url'
+    it "returns nothing for an unknown language" do
+      assert_nil text_x_yaml.friendly("zz")
     end
 
-    def _test_url_equals
-      raise NotImplementedError, 'Need to write test_url_equals'
+    it "merges new values from an array parameter" do
+      expected = {"en" => "Text files"}
+      assert_equal expected, text_plain.friendly(["en", "Text files"])
+      expected.update("fr" => "des fichiers texte")
+      assert_equal expected,
+        text_plain.friendly(["fr", "des fichiers texte"])
     end
 
-    def _test_urls
-      raise NotImplementedError, 'Need to write test_urls'
+    it "merges new values from a hash parameter" do
+      expected = {"en" => "Text files"}
+      assert_equal expected, text_plain.friendly(expected)
+      french = {"fr" => "des fichiers texte"}
+      expected.update(french)
+      assert_equal expected, text_plain.friendly(french)
     end
 
-    def __test_use_instead
-      raise NotImplementedError, 'Need to write test_use_instead'
+    it "raises an ArgumentError if an unknown value is provided" do
+      exception = assert_raises ArgumentError do
+        text_plain.friendly(1)
+      end
+
+      assert_equal "Expected a language or translation set, not 1",
+        exception.message
     end
   end
 end