xenon 0.0.3 → 0.0.4

data/spec/xenon/headers/cache_control_spec.rb

@@ -1,64 +0,0 @@
-require 'xenon/headers/cache_control'
-
-describe Xenon::Headers::CacheControl do
-
-  context '::parse' do
-    ['max-age', 'max-stale', 'min-fresh', 's-maxage'].each do |dir|
-      it "can parse the #{dir} directive" do
-        header = Xenon::Headers::CacheControl.parse("#{dir}=5")
-        expect(header.directives.size).to eq(1)
-        expect(header.directives[0].to_s).to eq("#{dir}=5")
-      end
-
-      it "can parse the #{dir} directive with a quoted value" do # should not be sent by clients but is permitted
-        header = Xenon::Headers::CacheControl.parse("#{dir}=\"5\"")
-        expect(header.directives.size).to eq(1)
-        expect(header.directives[0].to_s).to eq("#{dir}=5")
-      end
-    end
-
-    ['no-cache', 'no-store', 'no-transform', 'only-if-cached', 'must-revalidate', 'public', 'proxy-revalidate'].each do |dir|
-      it "can parse the #{dir} directive" do
-        header = Xenon::Headers::CacheControl.parse("#{dir}")
-        expect(header.directives.size).to eq(1)
-        expect(header.directives[0].to_s).to eq("#{dir}")
-      end
-    end
-
-    it "can parse the private directive with no field names" do
-      header = Xenon::Headers::CacheControl.parse('private')
-      expect(header.directives.size).to eq(1)
-      expect(header.directives[0].to_s).to eq('private')
-    end
-
-    # TODO: private directive with field names
-
-    it 'can parse extension directives with quoted string values' do
-      header = Xenon::Headers::CacheControl.parse('ext="hello \"world\""')
-      expect(header.directives.size).to eq(1)
-      expect(header.directives[0].name).to eq('ext')
-      expect(header.directives[0].value).to eq("hello \"world\"")
-    end
-
-    it 'can parse more complex directives' do
-      header = Xenon::Headers::CacheControl.parse('public, max-age=3600, must-revalidate')
-      expect(header.directives.size).to eq(3)
-      expect(header.directives[0].to_s).to eq('public')
-      expect(header.directives[1].to_s).to eq('max-age=3600')
-      expect(header.directives[2].to_s).to eq('must-revalidate')
-    end
-  end
-
-  context '#merge' do
-    it 'can merge two headers and maintain directive order' do
-      h1 = Xenon::Headers::CacheControl.parse('public, max-age=3600')
-      h2 = Xenon::Headers::CacheControl.parse('must-revalidate')
-      header = h1.merge(h2)
-      expect(header.directives.size).to eq(3)
-      expect(header.directives[0].to_s).to eq('public')
-      expect(header.directives[1].to_s).to eq('max-age=3600')
-      expect(header.directives[2].to_s).to eq('must-revalidate')
-    end
-  end
-
-end

data/spec/xenon/headers/if_match_spec.rb

@@ -1,73 +0,0 @@
-require 'xenon/headers/if_match'
-
-describe Xenon::Headers::IfMatch do
-
-  context '::parse' do
-    it 'can parse a single etag' do
-      header = Xenon::Headers::IfMatch.parse('"xyzzy"')
-      expect(header.etags.size).to eq(1)
-      expect(header.etags[0]).to eq(Xenon::ETag.new('xyzzy'))
-    end
-
-    it 'can parse multiple etags' do
-      header = Xenon::Headers::IfMatch.parse('"xyzzy", "r2d2xxxx", "c3piozzzz"')
-      expect(header.etags.size).to eq(3)
-      expect(header.etags[0]).to eq(Xenon::ETag.new('xyzzy'))
-      expect(header.etags[1]).to eq(Xenon::ETag.new('r2d2xxxx'))
-      expect(header.etags[2]).to eq(Xenon::ETag.new('c3piozzzz'))
-    end
-
-    it 'can parse a wildcard header' do
-      header = Xenon::Headers::IfMatch.parse('*')
-      expect(header.etags.size).to eq(0)
-    end
-  end
-
-  context '#merge' do
-    it 'can merge two headers and maintain etag order' do
-      h1 = Xenon::Headers::IfMatch.parse('"xyzzy", "r2d2xxxx"')
-      h2 = Xenon::Headers::IfMatch.parse('"c3piozzzz"')
-      header = h1.merge(h2)
-      expect(header.etags.size).to eq(3)
-      expect(header.etags[0]).to eq(Xenon::ETag.new('xyzzy'))
-      expect(header.etags[1]).to eq(Xenon::ETag.new('r2d2xxxx'))
-      expect(header.etags[2]).to eq(Xenon::ETag.new('c3piozzzz'))
-    end
-
-    it 'raises a protocol error when trying to merge into a wildcard header' do
-      h1 = Xenon::Headers::IfMatch.parse('*')
-      h2 = Xenon::Headers::IfMatch.parse('"c3piozzzz"')
-      expect { h1.merge(h2) }.to raise_error(Xenon::ProtocolError)
-    end
-
-    it 'raises a protocol error when trying to merge a wildcard into a header' do
-      h1 = Xenon::Headers::IfMatch.parse('"xyzzy"')
-      h2 = Xenon::Headers::IfMatch.parse('*')
-      expect { h1.merge(h2) }.to raise_error(Xenon::ProtocolError)
-    end
-
-    it 'raises a protocol error when trying to merge two wildcard headers' do
-      h1 = Xenon::Headers::IfMatch.parse('*')
-      h2 = Xenon::Headers::IfMatch.parse('*')
-      expect { h1.merge(h2) }.to raise_error(Xenon::ProtocolError)
-    end
-  end
-
-  context '#to_s' do
-    it 'returns the string representation a single etag' do
-      header = Xenon::Headers::IfMatch.parse('"xyzzy"')
-      expect(header.to_s).to eq('"xyzzy"')
-    end
-
-    it 'returns the string representation of multiple etags' do
-      header = Xenon::Headers::IfMatch.parse('"xyzzy", "r2d2xxxx", "c3piozzzz"')
-      expect(header.to_s).to eq('"xyzzy", "r2d2xxxx", "c3piozzzz"')
-    end
-
-    it 'returns the string representation of a wildcard header' do
-      header = Xenon::Headers::IfMatch.wildcard
-      expect(header.to_s).to eq('*')
-    end
-  end
-
-end

data/spec/xenon/headers/if_modified_since_spec.rb

@@ -1,19 +0,0 @@
-require 'xenon/headers/if_modified_since'
-
-describe Xenon::Headers::IfModifiedSince do
-
-  context '::parse' do
-    it 'can parse an http date' do
-      header = Xenon::Headers::IfModifiedSince.parse('Sat, 29 Oct 1994 19:43:31 GMT')
-      expect(header.date).to eq(Time.utc(1994, 10, 29, 19, 43, 31))
-    end
-  end
-
-  context '#to_s' do
-    it 'returns the http date format' do
-      header = Xenon::Headers::IfModifiedSince.new(Time.utc(1994, 10, 29, 19, 43, 31))
-      expect(header.to_s).to eq('Sat, 29 Oct 1994 19:43:31 GMT')
-    end
-  end
-
-end

data/spec/xenon/headers/if_none_match_spec.rb

@@ -1,79 +0,0 @@
-require 'xenon/headers/if_none_match'
-
-describe Xenon::Headers::IfNoneMatch do
-
-  context '::parse' do
-    it 'can parse a single strong etag' do
-      header = Xenon::Headers::IfNoneMatch.parse('"xyzzy"')
-      expect(header.etags.size).to eq(1)
-      expect(header.etags[0]).to eq(Xenon::ETag.new('xyzzy'))
-    end
-
-    it 'can parse a single weak etag' do
-      header = Xenon::Headers::IfNoneMatch.parse('W/"xyzzy"')
-      expect(header.etags.size).to eq(1)
-      expect(header.etags[0]).to eq(Xenon::ETag.new('xyzzy', weak: true))
-    end
-
-    it 'can parse multiple etags' do
-      header = Xenon::Headers::IfNoneMatch.parse('"xyzzy", W/"r2d2xxxx", "c3piozzzz"')
-      expect(header.etags.size).to eq(3)
-      expect(header.etags[0]).to eq(Xenon::ETag.new('xyzzy'))
-      expect(header.etags[1]).to eq(Xenon::ETag.new('r2d2xxxx', weak: true))
-      expect(header.etags[2]).to eq(Xenon::ETag.new('c3piozzzz'))
-    end
-
-    it 'can parse a wildcard header' do
-      header = Xenon::Headers::IfNoneMatch.parse('*')
-      expect(header.etags.size).to eq(0)
-    end
-  end
-
-  context '#merge' do
-    it 'can merge two headers and maintain etag order' do
-      h1 = Xenon::Headers::IfNoneMatch.parse('"xyzzy", W/"r2d2xxxx"')
-      h2 = Xenon::Headers::IfNoneMatch.parse('"c3piozzzz"')
-      header = h1.merge(h2)
-      expect(header.etags.size).to eq(3)
-      expect(header.etags[0]).to eq(Xenon::ETag.new('xyzzy'))
-      expect(header.etags[1]).to eq(Xenon::ETag.new('r2d2xxxx', weak: true))
-      expect(header.etags[2]).to eq(Xenon::ETag.new('c3piozzzz'))
-    end
-
-    it 'raises a protocol error when trying to merge into a wildcard header' do
-      h1 = Xenon::Headers::IfNoneMatch.parse('*')
-      h2 = Xenon::Headers::IfNoneMatch.parse('"c3piozzzz"')
-      expect { h1.merge(h2) }.to raise_error(Xenon::ProtocolError)
-    end
-
-    it 'raises a protocol error when trying to merge a wildcard into a header' do
-      h1 = Xenon::Headers::IfNoneMatch.parse('"xyzzy"')
-      h2 = Xenon::Headers::IfNoneMatch.parse('*')
-      expect { h1.merge(h2) }.to raise_error(Xenon::ProtocolError)
-    end
-
-    it 'raises a protocol error when trying to merge two wildcard headers' do
-      h1 = Xenon::Headers::IfNoneMatch.parse('*')
-      h2 = Xenon::Headers::IfNoneMatch.parse('*')
-      expect { h1.merge(h2) }.to raise_error(Xenon::ProtocolError)
-    end
-  end
-
-  context '#to_s' do
-    it 'returns the string representation a single etag' do
-      header = Xenon::Headers::IfNoneMatch.parse('"xyzzy"')
-      expect(header.to_s).to eq('"xyzzy"')
-    end
-
-    it 'returns the string representation of multiple etags' do
-      header = Xenon::Headers::IfNoneMatch.parse('"xyzzy", W/"r2d2xxxx", "c3piozzzz"')
-      expect(header.to_s).to eq('"xyzzy", W/"r2d2xxxx", "c3piozzzz"')
-    end
-
-    it 'returns the string representation of a wildcard header' do
-      header = Xenon::Headers::IfNoneMatch.wildcard
-      expect(header.to_s).to eq('*')
-    end
-  end
-
-end

data/spec/xenon/headers/if_range_spec.rb

@@ -1,45 +0,0 @@
-require 'xenon/headers/if_range'
-
-describe Xenon::Headers::IfRange do
-
-  context '::parse' do
-    it 'can parse an http date' do
-      header = Xenon::Headers::IfRange.parse('Sat, 29 Oct 1994 19:43:31 GMT')
-      expect(header.date).to eq(Time.utc(1994, 10, 29, 19, 43, 31))
-    end
-
-    it 'can parse an obsolete RFC 850 date' do
-      header = Xenon::Headers::IfRange.parse('Sunday, 06-Nov-94 08:49:37 GMT')
-      expect(header.date).to eq(Time.utc(1994, 11, 6, 8, 49, 37))
-    end
-
-    it 'can parse an obsolete asctime date' do
-      header = Xenon::Headers::IfRange.parse('Sun Nov  6 08:49:37 1994')
-      expect(header.date).to eq(Time.utc(1994, 11, 6, 8, 49, 37))
-    end
-
-    it 'can parse a strong etag' do
-      header = Xenon::Headers::IfRange.parse('"xyzzy"')
-      expect(header.etag).to_not be_nil
-      expect(header.etag.opaque_tag).to eq 'xyzzy'
-      expect(header.etag).to be_strong
-    end
-
-    it 'should raise a ProtocolError if the etag is weak' do
-      expect { Xenon::Headers::IfRange.parse('W/"xyzzy"') }.to raise_error Xenon::ProtocolError
-    end
-  end
-
-  context '#to_s' do
-    it 'returns the http date format for dates' do
-      header = Xenon::Headers::IfRange.new(Time.utc(1994, 10, 29, 19, 43, 31))
-      expect(header.to_s).to eq('Sat, 29 Oct 1994 19:43:31 GMT')
-    end
-
-    it 'returns the etag format for etags' do
-      header = Xenon::Headers::IfRange.new(Xenon::ETag.new('xyzzy'))
-      expect(header.to_s).to eq('"xyzzy"')
-    end
-  end
-
-end

data/spec/xenon/headers/if_unmodified_since_spec.rb

@@ -1,19 +0,0 @@
-require 'xenon/headers/if_unmodified_since'
-
-describe Xenon::Headers::IfUnmodifiedSince do
-
-  context '::parse' do
-    it 'can parse an http date' do
-      header = Xenon::Headers::IfUnmodifiedSince.parse('Sat, 29 Oct 1994 19:43:31 GMT')
-      expect(header.date).to eq(Time.utc(1994, 10, 29, 19, 43, 31))
-    end
-  end
-
-  context '#to_s' do
-    it 'returns the http date format' do
-      header = Xenon::Headers::IfUnmodifiedSince.new(Time.utc(1994, 10, 29, 19, 43, 31))
-      expect(header.to_s).to eq('Sat, 29 Oct 1994 19:43:31 GMT')
-    end
-  end
-
-end

data/spec/xenon/headers/user_agent_spec.rb

@@ -1,67 +0,0 @@
-require 'xenon/headers/user_agent'
-
-describe Xenon::Headers::UserAgent do
-
-  context '::parse' do
-    it 'can parse a user agent with a product name' do
-      header = Xenon::Headers::UserAgent.parse('Mozilla')
-      expect(header.products.size).to eq(1)
-      expect(header.products[0].name).to eq('Mozilla')
-      expect(header.products[0].version).to be_nil
-      expect(header.products[0].comment).to be_nil
-    end
-
-    it 'can parse a user agent with a product name and version' do
-      header = Xenon::Headers::UserAgent.parse('Mozilla/5.0')
-      expect(header.products.size).to eq(1)
-      expect(header.products[0].name).to eq('Mozilla')
-      expect(header.products[0].version).to eq('5.0')
-      expect(header.products[0].comment).to be_nil
-    end
-
-    it 'can parse a user agent with a product name and comment' do
-      header = Xenon::Headers::UserAgent.parse('Mozilla (Macintosh; Intel Mac OS X 10_10_2)')
-      expect(header.products.size).to eq(1)
-      expect(header.products[0].name).to eq('Mozilla')
-      expect(header.products[0].version).to be_nil
-      expect(header.products[0].comment).to eq('Macintosh; Intel Mac OS X 10_10_2')
-    end
-
-    it 'can parse a user agent with a product name, version and comment' do
-      header = Xenon::Headers::UserAgent.parse('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_2)')
-      expect(header.products.size).to eq(1)
-      expect(header.products[0].name).to eq('Mozilla')
-      expect(header.products[0].version).to eq('5.0')
-      expect(header.products[0].comment).to eq('Macintosh; Intel Mac OS X 10_10_2')
-    end
-
-    it 'can parse a user agent with multiple comments' do
-      header = Xenon::Headers::UserAgent.parse('Mozilla/5.0 (Macintosh) (Intel Mac OS X 10_10_2)')
-      expect(header.products.size).to eq(2)
-      expect(header.products[0].name).to eq('Mozilla')
-      expect(header.products[0].version).to eq('5.0')
-      expect(header.products[0].comment).to eq('Macintosh')
-      expect(header.products[1].name).to be_nil
-      expect(header.products[1].version).to be_nil
-      expect(header.products[1].comment).to eq('Intel Mac OS X 10_10_2')
-    end
-
-    it 'can parse a typical Chrome user agent' do
-      header = Xenon::Headers::UserAgent.parse('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.89 Safari/537.36')
-      expect(header.products.size).to eq(4)
-      expect(header.products[0].name).to eq('Mozilla')
-      expect(header.products[0].version).to eq('5.0')
-      expect(header.products[0].comment).to eq('Macintosh; Intel Mac OS X 10_10_2')
-      expect(header.products[1].name).to eq('AppleWebKit')
-      expect(header.products[1].version).to eq('537.36')
-      expect(header.products[1].comment).to eq('KHTML, like Gecko')
-      expect(header.products[2].name).to eq('Chrome')
-      expect(header.products[2].version).to eq('41.0.2272.89')
-      expect(header.products[2].comment).to be_nil
-      expect(header.products[3].name).to eq('Safari')
-      expect(header.products[3].version).to eq('537.36')
-      expect(header.products[3].comment).to be_nil
-    end
-  end
-
-end

data/spec/xenon/headers/www_authenticate_spec.rb

@@ -1,43 +0,0 @@
-require 'xenon/headers/www_authenticate'
-
-describe Xenon::Headers::WWWAuthenticate do
-
-  context '::parse' do
-
-    it 'can parse a Basic challenge with a realm' do
-      header = Xenon::Headers::WWWAuthenticate.parse('Basic realm="simple"')
-      expect(header.challenges.size).to eq(1)
-      expect(header.challenges[0].auth_scheme).to eq('Basic')
-      expect(header.challenges[0].realm).to eq('simple')
-    end
-
-    it 'can parse a Digest challenge with a realm' do
-      header = Xenon::Headers::WWWAuthenticate.parse('Digest realm="testrealm@host.com", qop="auth,auth-int", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", opaque="5ccc069c403ebaf9f0171e9517f40e41"')
-      expect(header.challenges.size).to eq(1)
-      expect(header.challenges[0].auth_scheme).to eq('Digest')
-      expect(header.challenges[0].realm).to eq('testrealm@host.com')
-      expect(header.challenges[0].qop).to eq('auth,auth-int')
-      expect(header.challenges[0].nonce).to eq('dcd98b7102dd2f0e8b11d0f600bfb0c093')
-      expect(header.challenges[0].opaque).to eq('5ccc069c403ebaf9f0171e9517f40e41')
-    end
-
-    it 'can parse a custom challenge' do
-      header = Xenon::Headers::WWWAuthenticate.parse('Newauth realm="apps", type=1, title="Login to \"apps\""')
-      expect(header.challenges.size).to eq(1)
-      expect(header.challenges[0].auth_scheme).to eq('Newauth')
-      expect(header.challenges[0].realm).to eq('apps')
-      expect(header.challenges[0].type).to eq('1')
-      expect(header.challenges[0].title).to eq('Login to "apps"')
-    end
-
-    it 'can parse multiple challenges' do
-      header = Xenon::Headers::WWWAuthenticate.parse('Digest realm="testrealm@host.com", qop="auth,auth-int", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", opaque="5ccc069c403ebaf9f0171e9517f40e41", Basic realm="simple", Newauth realm="apps", type=1, title="Login to \"apps\""')
-      expect(header.challenges.size).to eq(3)
-      expect(header.challenges[0].auth_scheme).to eq('Digest')
-      expect(header.challenges[1].auth_scheme).to eq('Basic')
-      expect(header.challenges[2].auth_scheme).to eq('Newauth')
-    end
-
-
-  end
-end

data/spec/xenon/media_type_spec.rb

@@ -1,267 +0,0 @@
-require 'xenon/media_type'
-
-describe Xenon::MediaType do
-
-  context '::parse' do
-    it 'can parse basic media types' do
-      mt = Xenon::MediaType.parse('application/json')
-      expect(mt.type).to eq('application')
-      expect(mt.subtype).to eq('json')
-    end
-    it 'can parse media types with a subtype suffix' do
-      mt = Xenon::MediaType.parse('application/rss+xml')
-      expect(mt.type).to eq('application')
-      expect(mt.subtype).to eq('rss+xml')
-    end
-
-    it 'can parse media types with parameters' do
-      mt = Xenon::MediaType.parse('text/plain; format=flowed; paged')
-      expect(mt.type).to eq('text')
-      expect(mt.subtype).to eq('plain')
-      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
-    end
-
-    it 'strips whitespace around separators' do
-      mt = Xenon::MediaType.parse('text/plain ; format = flowed ; paged')
-      expect(mt.type).to eq('text')
-      expect(mt.subtype).to eq('plain')
-      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
-    end
-
-    it 'raises an error when the media type contains wildcards' do
-      expect { Xenon::MediaType.parse('*/*') }.to raise_error(Xenon::ParseError)
-      expect { Xenon::MediaType.parse('application/*') }.to raise_error(Xenon::ParseError)
-    end
-
-    it 'raises an error when the media type is invalid' do
-      expect { Xenon::MediaType.parse('application') }.to raise_error(Xenon::ParseError)
-      expect { Xenon::MediaType.parse('application; foo=bar') }.to raise_error(Xenon::ParseError)
-      expect { Xenon::MediaType.parse('/json') }.to raise_error(Xenon::ParseError)
-      expect { Xenon::MediaType.parse('/json; foo=bar') }.to raise_error(Xenon::ParseError)
-    end
-  end
-
-  %w(application audio image message multipart text video).each do |type|
-    context "#{type}?" do
-      it "returns true when the root type is '#{type}'" do
-        mt = Xenon::MediaType.new(type, 'dummy')
-        expect(mt.send("#{type}?")).to eq(true)
-      end
-
-      it "returns false when the root type is not '#{type}'" do
-        mt = Xenon::MediaType.new('dummy', 'dummy')
-        expect(mt.send("#{type}?")).to eq(false)
-      end
-    end
-  end
-
-  { experimental?: 'x', personal?: 'prs', vendor?: 'vnd' }.each do |method, prefix|
-    context method do
-      it "returns true when the subtype starts with '#{prefix}.'" do
-        mt = Xenon::MediaType.new('application', "#{prefix}.dummy")
-        expect(mt.send(method)).to eq(true)
-      end
-
-      it "returns false when the subtype does not start with '#{prefix}.'" do
-        mt = Xenon::MediaType.new('application', "dummy.dummy")
-        expect(mt.send(method)).to eq(false)
-      end
-    end
-  end
-
-  %w(ber der fastinfoset json wbxml xml zip).each do |format|
-    context "#{format}?" do
-      it "returns true when the subtype is '#{format}'" do
-        mt = Xenon::MediaType.new('application', format)
-        expect(mt.send("#{format}?")).to eq(true)
-      end
-
-      it "returns true when the subtype ends with '+#{format}'" do
-        mt = Xenon::MediaType.new('application', "dummy+#{format}")
-        expect(mt.send("#{format}?")).to eq(true)
-      end
-
-      it "returns false when the subtype is not '#{format}' and does not end with '+#{format}'" do
-        mt = Xenon::MediaType.new('dummy', 'dummy+dummy')
-        expect(mt.send("#{format}?")).to eq(false)
-      end
-    end
-  end
-
-  context '#to_s' do
-    it 'returns the string representation of a media type' do
-      mt = Xenon::MediaType.new('text', 'plain', 'format' => 'flowed', 'paged' => nil)
-      expect(mt.to_s).to eq('text/plain; format=flowed; paged')
-    end
-  end
-  
-end
-
-describe Xenon::MediaRange do
-
-  context '::parse' do
-    it 'can parse basic media ranges' do
-      mt = Xenon::MediaRange.parse('application/json')
-      expect(mt.type).to eq('application')
-      expect(mt.subtype).to eq('json')
-    end
-
-    it 'can parse media ranges with parameters' do
-      mt = Xenon::MediaRange.parse('text/plain; format=flowed; paged')
-      expect(mt.type).to eq('text')
-      expect(mt.subtype).to eq('plain')
-      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
-    end
-
-    it 'strips whitespace around separators' do
-      mt = Xenon::MediaRange.parse('text/plain ; format = flowed ; paged')
-      expect(mt.type).to eq('text')
-      expect(mt.subtype).to eq('plain')
-      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
-    end
-
-    it 'can parse media ranges with subtype wildcards' do
-      mt = Xenon::MediaRange.parse('application/*')
-      expect(mt.type).to eq('application')
-      expect(mt.subtype).to eq('*')
-    end
-
-    it 'can parse media ranges with type and subtype wildcards' do
-      mt = Xenon::MediaRange.parse('*/*')
-      expect(mt.type).to eq('*')
-      expect(mt.subtype).to eq('*')
-    end
-
-    it 'extracts q from the parameters' do
-      mt = Xenon::MediaRange.parse('text/plain; q=0.8; format=flowed; paged')
-      expect(mt.type).to eq('text')
-      expect(mt.subtype).to eq('plain')
-      expect(mt.q).to eq(0.8)
-      expect(mt.params).to eq({ 'format' => 'flowed', 'paged' => nil })
-    end
-
-    it 'uses the default value for q if the value is not numeric' do
-      mt = Xenon::MediaRange.parse('application/json; q=foo')
-      expect(mt.type).to eq('application')
-      expect(mt.subtype).to eq('json')
-      expect(mt.q).to eq(Xenon::MediaRange::DEFAULT_Q)
-    end
-
-    it 'raises an error when the media range is invalid' do
-      expect { Xenon::MediaRange.parse('application') }.to raise_error(Xenon::ParseError)
-      expect { Xenon::MediaRange.parse('application; foo=bar') }.to raise_error(Xenon::ParseError)
-      expect { Xenon::MediaRange.parse('*/json') }.to raise_error(Xenon::ParseError)
-      expect { Xenon::MediaRange.parse('/json') }.to raise_error(Xenon::ParseError)
-      expect { Xenon::MediaRange.parse('/json; foo=bar') }.to raise_error(Xenon::ParseError)
-    end
-  end
-
-  context '#<=>' do
-    it 'considers a wildcard type less than a regular type' do
-      mr1 = Xenon::MediaRange.new('*', '*')
-      mr2 = Xenon::MediaRange.new('text', '*')
-      expect(mr1 <=> mr2).to eq(-1)
-    end
-
-    it 'considers a wildcard subtype less than a regular subtype' do
-      mr1 = Xenon::MediaRange.new('application', '*')
-      mr2 = Xenon::MediaRange.new('text', 'plain')
-      expect(mr1 <=> mr2).to eq(-1)
-    end
-
-    it 'considers media ranges with type and subtype equal' do
-      mr1 = Xenon::MediaRange.new('application', 'json')
-      mr2 = Xenon::MediaRange.new('text', 'plain')
-      expect(mr1 <=> mr2).to eq(0)
-    end
-
-    it 'considers a media range with parameters greater than one without' do
-      mr1 = Xenon::MediaRange.new('text', 'plain', 'format' => 'flowed')
-      mr2 = Xenon::MediaRange.new('text', 'plain')
-      expect(mr1 <=> mr2).to eq(1)
-    end
-
-    it 'does not consider the quality when one media range is more specific' do
-      mr1 = Xenon::MediaRange.new('application', '*', 'q' => '0.3')
-      mr2 = Xenon::MediaRange.new('*', '*', 'q' => '0.5')
-      expect(mr1 <=> mr2).to eq(1)
-    end
-
-    it 'considers the quality when media ranges are equally specific' do
-      mr1 = Xenon::MediaRange.new('application', 'json', 'q' => '0.8')
-      mr2 = Xenon::MediaRange.new('application', 'xml')
-      expect(mr1 <=> mr2).to eq(-1)
-    end
-  end
-
-  %i(=~ ===).each do |name|
-    context "##{name}" do
-      it 'returns true when the type and subtype are wildcards' do
-        mr = Xenon::MediaRange.new('*', '*')
-        mt = Xenon::MediaType.new('application', 'json')
-        expect(mr.send(name, mt)).to eq(true)
-      end
-
-      it 'returns true when the type matches and subtype is a wildcard' do
-        mr = Xenon::MediaRange.new('application', '*')
-        mt = Xenon::MediaType.new('application', 'json')
-        expect(mr.send(name, mt)).to eq(true)
-      end
-
-      it 'returns true when the type and subtype match exactly' do
-        mr = Xenon::MediaRange.new('application', 'json')
-        mt = Xenon::MediaType.new('application', 'json')
-        expect(mr.send(name, mt)).to eq(true)
-      end
-
-      it 'returns true when the type, subtype and parameters match exactly' do
-        mr = Xenon::MediaRange.new('text', 'plain', 'format' => 'flowed')
-        mt = Xenon::MediaType.new('text', 'plain', 'format' => 'flowed', 'paged' => nil)
-        expect(mr.send(name, mt)).to eq(true)
-      end
-
-      it 'returns true when the the media type has more specific parameters' do
-        mr = Xenon::MediaRange.new('text', 'plain')
-        mt = Xenon::MediaType.new('text', 'plain', 'format' => 'flowed', 'paged' => nil)
-        expect(mr.send(name, mt)).to eq(true)
-      end
-
-      it 'returns false when the type is different' do
-        mr = Xenon::MediaRange.new('text', 'json')
-        mt = Xenon::MediaType.new('application', 'json')
-        expect(mr.send(name, mt)).to eq(false)
-      end
-
-      it 'returns false when the type matches but subtype is different' do
-        mr = Xenon::MediaRange.new('application', 'xml')
-        mt = Xenon::MediaType.new('application', 'json')
-        expect(mr.send(name, mt)).to eq(false)
-      end
-
-      it 'returns false when the media range has more specific parameters' do
-        mr = Xenon::MediaRange.new('text', 'plain', 'format' => 'flowed', 'paged' => nil)
-        mt = Xenon::MediaType.new('text', 'plain')
-        expect(mr.send(name, mt)).to eq(false)
-      end
-
-      it 'returns false when the media range has a different parameter value' do
-        mr = Xenon::MediaRange.new('text', 'plain', 'format' => 'flowed')
-        mt = Xenon::MediaType.new('text', 'plain', 'format' => 'linear')
-        expect(mr.send(name, mt)).to eq(false)
-      end
-    end
-  end
-
-  context '#to_s' do
-    it 'returns the string representation of a media range' do
-      mt = Xenon::MediaRange.new('text', 'plain', 'q' => 0.8, 'format' => 'flowed', 'paged' => nil)
-      expect(mt.to_s).to eq('text/plain; format=flowed; paged; q=0.8')
-    end
-
-    it 'omits the q parameter when it is 1.0' do
-      mt = Xenon::MediaRange.new('application', 'json', 'q' => 1.0)
-      expect(mt.to_s).to eq('application/json')
-    end
-  end
-
-end