accept_headers 0.1.0 → 0.3.0

data/spec/language/negotiator_spec.rb

@@ -2,84 +2,107 @@ require_relative "../spec_helper"
 
 describe AcceptHeaders::Language::Negotiator do
   subject { AcceptHeaders::Language::Negotiator }
-  let(:language) { AcceptHeaders::Language }
 
-  describe "parsing an accept header" do
-    it "returns a sorted array of media primary tags" do
-      subject.new("en-*;q=0.2, en-us").list.must_equal [
-        language.new('en', 'us'),
-        language.new('en', '*', q: 0.2)
+  describe "parsing an Accept-Language header" do
+    it "sorts ranges by quality and specificity" do
+      subject.new('en;q=0.2, en-us').list.map(&:to_h).must_equal [
+        {primary_tag: 'en', subtag: 'us', q: 1.0},
+        {primary_tag: 'en', subtag: '*', q: 0.2}
       ]
 
-      subject.new("en-*, en-us, *;q=0.8").list.must_equal [
-        language.new('en', 'us'),
-        language.new('en', '*'),
-        language.new('*', '*', q: 0.8)
-      ]
+      subject.new('en, en-us, *;q=0.8').list.map(&:language_tag).must_equal ['en-us', 'en', '*']
     end
 
-    it "ignores the 'Accept-Language:' prefix" do
-      subject.new('Accept-Language: en-us').list.must_equal [
-        language.new('en', 'us')
-      ]
+    it "ignores the Accept-Language prefix" do
+      subject.new('Accept-Language: en-us').list.map(&:language_tag).must_equal ['en-us']
     end
 
-    it "sets media primary tag to */* when the accept header is empty" do
-      subject.new('').list.must_equal [
-        language.new('*', '*')
-      ]
+    it "accepts any language when the header is missing" do
+      subject.new(nil).list.map(&:language_tag).must_equal ['*']
+      subject.new(nil).negotiate('en-US').language_tag.must_equal 'en-us'
     end
 
-    it "sets media primary tag to */* when the primary tag is only *" do
-      subject.new('*').list.must_equal [
-        language.new('*', '*')
-      ]
+    it "accepts no languages when the header is present and empty" do
+      ['', " \t", 'Accept-Language:'].each do |header|
+        assert_empty subject.new(header).list
+        assert_nil subject.new(header).negotiate('en-US')
+      end
     end
 
-    it "defaults q to 1 if it's not explicitly specified" do
-      subject.new("en-us").list.must_equal [
-        language.new('en', 'plain', q: 1.0)
+    it "parses a wildcard range" do
+      subject.new('*').list.map(&:to_h).must_equal [
+        {primary_tag: '*', subtag: '*', q: 1.0}
       ]
     end
 
-    it "strips whitespace from between media primary tags" do
-      subject.new("\ten-us\r,\nen-gb\s").list.must_equal [
-        language.new('en', 'us'),
-        language.new('en', 'gb')
-      ]
+    it "defaults quality to one" do
+      subject.new('en-us').list.first.to_h.must_equal({primary_tag: 'en', subtag: 'us', q: 1.0})
     end
 
-    it "strips whitespace around q" do
-      subject.new("en-us;\tq\r=\n1, en-gb").list.must_equal [
-        language.new('en', 'us'),
-        language.new('en', 'gb')
-      ]
+    it "uses the documented fallback quality for an invalid weight" do
+      subject.new('en-us;q=x').list.first.to_h.must_equal({primary_tag: 'en', subtag: 'us', q: 0.001})
     end
 
-    it "has a q value of 0.001 when parsed q is invalid" do
-      subject.new("en-us;q=x").list.must_equal [
-        language.new('en', 'plain', q: 0.001)
-      ]
+    it "allows optional whitespace around ranges" do
+      subject.new("\ten-us , en-gb\t").list.map(&:language_tag).must_equal ['en-us', 'en-gb']
     end
 
-    it "skips invalid media primary tags" do
-      subject.new("en-us, en-us-omg;q=0.9").list.must_equal [
-        language.new('en', 'us', q: 1)
+    it "retains every subtag and normalizes case" do
+      subject.new('ZH-Hant-TW, en-US-omg;q=0.9').list.map(&:to_h).must_equal [
+        {primary_tag: 'zh', subtag: 'hant-tw', q: 1.0},
+        {primary_tag: 'en', subtag: 'us-omg', q: 0.9}
       ]
     end
+
+    it "skips ranges outside the basic language-range grammar" do
+      invalid = ['en-*', '*-US', 'en_US', '123', 'englishxx', 'en-123456789', 'en--US', 'en - US']
+      subject.new((invalid + ['fr']).join(',')).list.map(&:language_tag).must_equal ['fr']
+    end
   end
 
   describe "#to_s" do
-    it "returns a string of each language #to_s joined by a comma" do
-      subject.new("en-us, en-gb;q=0.9").to_s.must_equal "en-us;q=1,en-gb;q=0.9"
+    it "serializes basic language ranges without adding wildcards" do
+      subject.new('en, zh-Hant-TW;q=0.9').to_s.must_equal 'en;q=1,zh-hant-tw;q=0.9'
     end
   end
 
-  describe "negotiate supported languages" do
-    it "returns a best matching language" do
-      match = language.new('en', 'us')
-      n = subject.new('en-*, en-us, *;q=0.8')
-      n.negotiate('en-us').must_equal language.new('en', 'us')
+  describe "negotiating supported languages" do
+    it "returns the supported language rather than the matching range" do
+      match = subject.new('en, *;q=0.8').negotiate('en-US')
+      match.to_h.must_equal({primary_tag: 'en', subtag: 'us', q: 1.0})
+    end
+
+    it "returns a plain supported language without a synthetic wildcard" do
+      subject.new('*').negotiate('en').language_tag.must_equal 'en'
+    end
+
+    it "matches script and region subtags case insensitively" do
+      subject.new('zh-Hant').negotiate(['zh-Hans-TW', 'ZH-hant-TW']).language_tag.must_equal 'zh-hant-tw'
+    end
+
+    it "applies a more specific exclusion before its parent language range" do
+      match = subject.new('zh, zh-Hant;q=0').negotiate(['zh-Hant-TW', 'zh-Hans-CN'])
+      match.language_tag.must_equal 'zh-hans-cn'
+    end
+
+    it "uses the most specific matching range quality" do
+      match = subject.new('en;q=1, en-US;q=0.1, fr;q=0.5').negotiate(['en-US', 'fr'])
+      match.language_tag.must_equal 'fr'
+    end
+
+    it "rejects candidates outside a subtag boundary" do
+      subject.new('en-US').accept?('en-USA').must_equal false
+    end
+
+    it "requires concrete supported language tags" do
+      ['*', 'en-*', 'en_US', 'en;q=1'].each do |support|
+        assert_raises(AcceptHeaders::InvalidSupportedValue) { subject.new('*').accept?(support) }
+      end
+      subject.new('*').accept?(nil).must_equal false
+    end
+
+    it "returns nil when no supported language matches" do
+      _(subject.new('fr').negotiate('en')).must_be_nil
     end
   end
 end

data/spec/language_spec.rb

@@ -91,6 +91,11 @@ describe AcceptHeaders::Language do
       subject.new('en', 'us', q: 0.9).language_tag.must_equal "en-us"
     end
 
+    it "outputs the primary tag alone when no subtag is given" do
+      subject.new('en').language_tag.must_equal 'en'
+      subject.new('en', '*').language_tag.must_equal 'en'
+    end
+
     it "if primary tag is * and subtag is * or nil, outputs *" do
       subject.new('*', nil).language_tag.must_equal '*'
       subject.new('*', '*').language_tag.must_equal '*'
@@ -119,6 +124,13 @@ describe AcceptHeaders::Language do
       b.accept?('en-us').must_equal true
     end
 
+    it "matches complete subtag prefixes case insensitively" do
+      a = subject.new('zh', 'hant')
+      a.accept?('ZH-Hant-TW').must_equal true
+      a.accept?('zh-Hans-TW').must_equal false
+      a.accept?('zh-Hantish').must_equal false
+    end
+
     it "not accepted if the primary_tag and subtag don't match" do
       a = subject.new('en', 'us')
       a.accept?('en-gb').must_equal false
@@ -156,8 +168,7 @@ describe AcceptHeaders::Language do
       a.accept?(nil).must_equal false
     end
 
-    # TODO: test *
-    it "not accepted if..." do
+    it "does not accept a wildcard as a concrete supported tag" do
       a = subject.new('en', 'us')
       a.accept?('*').must_equal false
     end
@@ -195,8 +206,7 @@ describe AcceptHeaders::Language do
         a.reject?('en-gb').must_equal false
       end
 
-      # TODO: test *
-      it "not rejected if..." do
+      it "does not reject a wildcard as a concrete supported tag" do
         a = subject.new('en', 'us', q: 0)
         a.reject?('*').must_equal false
       end

data/spec/malformed_spec.rb

@@ -0,0 +1,178 @@
+require_relative "spec_helper"
+
+class MalformedHeaderSpec < Minitest::Test
+  def test_absent_accept_header_accepts_any_media_type
+    result = AcceptHeaders::MediaType::Negotiator.new(nil).negotiate('text/html')
+
+    assert_equal 'text/html', result.media_range
+  end
+
+  def test_present_empty_accept_header_accepts_no_media_types
+    ['', " \t", 'Accept:'].each do |header|
+      negotiator = AcceptHeaders::MediaType::Negotiator.new(header)
+
+      assert_empty negotiator.list
+      assert_nil negotiator.negotiate('text/html')
+    end
+  end
+
+  def test_unqualified_media_types_are_skipped_without_raising
+    negotiator = AcceptHeaders::MediaType::Negotiator.new('nonsense, text/html')
+
+    assert_equal [{ type: 'text', subtype: 'html', q: 1.0, extensions: {} }], negotiator.list.map(&:to_h)
+  end
+
+  def test_invalidly_tagged_token_bytes_are_skipped_by_each_negotiator
+    quality_negotiators.each do |negotiator, valid_token|
+      invalid_token = "\xFF".freeze
+      assert_empty negotiator.new(invalid_token).list
+
+      header = "#{invalid_token},#{valid_token}"
+      assert_equal negotiator.new(valid_token).list.map(&:to_h), negotiator.new(header).list.map(&:to_h)
+      assert_equal Encoding::UTF_8, invalid_token.encoding
+      refute invalid_token.valid_encoding?
+    end
+  end
+
+  def test_quoted_obs_text_bytes_are_preserved_and_round_trip
+    value = (0x80..0xFF).to_a.pack('C*')
+    header = ('text/html;note="'.b + value + '"').force_encoding('UTF-8')
+    item = AcceptHeaders::MediaType::Negotiator.new(header).list.first
+
+    assert_equal value, item.extensions['note']
+    assert_equal Encoding::ASCII_8BIT, item.extensions['note'].encoding
+    assert_equal item.to_h, AcceptHeaders::MediaType::Negotiator.new(item.to_s).list.first.to_h
+  end
+
+  def test_valid_utf8_quoted_values_retain_their_encoding_and_round_trip
+    value = "日本語; café"
+    item = AcceptHeaders::MediaType::Negotiator.new("text/html;note=\"#{value}\"").list.first
+
+    assert_equal value, item.extensions['note']
+    assert_equal Encoding::UTF_8, item.extensions['note'].encoding
+    assert_equal item.to_h, AcceptHeaders::MediaType::Negotiator.new(item.to_s).list.first.to_h
+  end
+
+  def test_multibyte_headers_decode_quoted_pairs_as_http_bytes
+    {
+      [0x95, 0x5c, 0x5c] => [0x95, 0x5c],
+      [0x95, 0x5c, 0x5c, 0x61] => [0x95, 0x5c, 0x61],
+      [0x95, 0x5c, 0x61] => [0x95, 0x61],
+      [0x95, 0x5c, 0x22, 0x61] => [0x95, 0x22, 0x61]
+    }.each do |bytes, expected|
+      wire = 'text/plain;note="'.b + bytes.pack('C*') + '";q=0.8,application/json;q=0.5'
+      header = wire.dup.force_encoding('Shift_JIS').freeze
+      assert header.valid_encoding?
+      binary = AcceptHeaders::MediaType::Negotiator.new(wire)
+      tagged = AcceptHeaders::MediaType::Negotiator.new(header)
+
+      assert_equal binary.list.map(&:media_range), tagged.list.map(&:media_range)
+      assert_equal binary.list.first.extensions['note'].bytes, tagged.list.first.extensions['note'].bytes
+      assert_equal expected, tagged.list.first.extensions['note'].bytes
+      assert_equal [0.8, 0.5], tagged.list.map(&:q)
+      [wire.split(';q=').first, 'text/plain;note="other"', 'application/json'].each do |offer|
+        assert_equal binary.accept?(offer), tagged.accept?(offer)
+        assert_equal [binary.negotiate(offer)&.content_type&.bytes], [tagged.negotiate(offer)&.content_type&.bytes]
+      end
+      assert_equal wire.bytes, header.bytes
+      assert_equal Encoding::Shift_JIS, header.encoding
+    end
+  end
+
+  def test_multibyte_headers_reject_unterminated_http_quoted_pairs
+    ['"', '",application/json'].each do |suffix|
+      wire = 'text/plain;note="'.b + [0x95, 0x5c].pack('C*') + suffix
+      header = wire.dup.force_encoding('Shift_JIS').freeze
+      assert header.valid_encoding?
+
+      [wire, header].each do |input|
+        matcher = AcceptHeaders::MediaType::Negotiator.new(input)
+        assert_empty matcher.list
+        refute matcher.accept?('application/json')
+        assert_nil matcher.negotiate('text/plain')
+      end
+      assert_equal wire.bytes, header.bytes
+    end
+  end
+
+  def test_utf8_header_quoted_pairs_preserve_values_and_encoding
+    header = 'text/plain;note="日本語; café\\"x\\\\y";q=0.8'.freeze
+    tagged = AcceptHeaders::MediaType::Negotiator.new(header)
+    binary = AcceptHeaders::MediaType::Negotiator.new(header.b)
+    item = tagged.list.first
+
+    assert_equal '日本語; café"x\\y', item.extensions['note']
+    assert_equal Encoding::UTF_8, item.extensions['note'].encoding
+    assert_equal 0.8, item.q
+    assert_equal binary.list.first.extensions['note'].bytes, item.extensions['note'].bytes
+    assert_equal item.to_h, AcceptHeaders::MediaType::Negotiator.new(item.to_s).list.first.to_h
+    assert_equal item.content_type, tagged.negotiate(item.content_type).content_type
+    assert_equal Encoding::UTF_8, header.encoding
+  end
+
+  def test_invalid_media_ranges_do_not_match_partial_lines_or_non_token_characters
+    ['*/json', 'text/html/extra', 'text/ht{ml}', 'text/ht\\ml', "text/html\nnonsense", 'text /html'].each do |range|
+      assert_empty AcceptHeaders::MediaType::Negotiator.new(range).list, range
+    end
+  end
+
+  def test_media_ranges_accept_http_token_characters_and_supported_wildcards
+    ['application/x_example+json', 'application/problem+json', 'image/avif', 'text/*', '*/*', '*'].each do |range|
+      assert_equal 1, AcceptHeaders::MediaType::Negotiator.new(range).list.size, range
+    end
+  end
+
+  def test_quality_uses_the_complete_rfc_9110_qvalue_grammar
+    values = {
+      '0' => 0.0, '0.' => 0.0, '0.000' => 0.0,
+      '0.123' => 0.123, '1' => 1.0, '1.' => 1.0, '1.000' => 1.0
+    }
+
+    quality_negotiators.each do |negotiator, value|
+      values.each do |qvalue, expected|
+        assert_equal expected, negotiator.new("#{value};q=#{qvalue}").list.first.q, "#{value};q=#{qvalue}"
+      end
+    end
+  end
+
+  def test_invalid_quality_preserves_the_documented_recovery_value
+    ['', '.5', '+0.5', '01', '0.1234', '1.0000', '0.1e0', '"0.1"', '1.001', 'NaN', "0\nx"].each do |qvalue|
+      quality_negotiators.each do |negotiator, value|
+        assert_equal 0.001, negotiator.new("#{value};q=#{qvalue}").list.first.q, "#{value};q=#{qvalue}"
+      end
+    end
+  end
+
+  def test_quality_parameter_name_is_case_insensitive_and_exact
+    quality_negotiators.each do |negotiator, value|
+      assert_equal 0.4, negotiator.new("#{value};Q = 0.4").list.first.q
+      assert_equal 1.0, negotiator.new("#{value};qs=0").list.first.q
+    end
+  end
+
+  def test_quoted_parameter_contents_are_not_quality_parameters
+    header = 'text/html;note="a;q=0;b"'
+
+    assert_equal 1.0, AcceptHeaders::MediaType::Negotiator.new(header).list.first.q
+  end
+
+  def test_quality_after_escaped_quotes_is_still_parsed
+    header = 'text/html;note="a\";q=0";q=0.8'
+
+    assert_equal 0.8, AcceptHeaders::MediaType::Negotiator.new(header).list.first.q
+  end
+
+  def test_unterminated_quoted_parameters_are_skipped
+    assert_empty AcceptHeaders::MediaType::Negotiator.new('text/html;note="a;q=0').list
+  end
+
+  private
+
+  def quality_negotiators
+    {
+      AcceptHeaders::MediaType::Negotiator => 'text/html',
+      AcceptHeaders::Encoding::Negotiator => 'gzip',
+      AcceptHeaders::Language::Negotiator => 'en'
+    }
+  end
+end

data/spec/media_type/negotiator_spec.rb

@@ -34,12 +34,12 @@ describe AcceptHeaders::MediaType::Negotiator do
     end
 
     it "ignores the 'Accept:' prefix" do
-      subject.new('Accept: text/html').list.must_equal [
+      subject.new('aCcEpT: text/html').list.must_equal [
         media_type.new('text', 'html')
       ]
     end
 
-    it "supports all registered IANA media types" do
+    it "parses media types in the bundled IANA snapshot" do
       require 'csv'
       # https://www.iana.org/assignments/media-types/media-types.xhtml
       %w[application audio image message model multipart text video].each do |filename|
@@ -54,10 +54,8 @@ describe AcceptHeaders::MediaType::Negotiator do
       end
     end
 
-    it "sets media type to */* when the accept header is empty" do
-      subject.new('').list.must_equal [
-        media_type.new('*', '*')
-      ]
+    it "accepts no media types when the accept header is present but empty" do
+      assert_empty subject.new('').list
     end
 
     it "sets media type to */* when the type is only *" do
@@ -92,11 +90,47 @@ describe AcceptHeaders::MediaType::Negotiator do
       ]
     end
 
-    it "parses extensions with quoted values" do
-      subject.new('text/html;q=1;version="2";level="a;b;cc\'cd", text/html;version=\'1\';level=\'\blah;x;1;;\'').list.must_equal [
-        media_type.new('text', 'html', extensions: { 'version' => '2', 'level' => 'a;b;cc\'cd'}),
-        media_type.new('text', 'html', extensions: { 'version' => '1', 'level' => '\'\blah;x;1;;\''})
-      ]
+    it "preserves delimiters inside quoted parameter values" do
+      parsed = subject.new('text/html;version="2";level="a,b;c", application/json;q=0.8').list
+      parsed.map(&:media_range).must_equal ['text/html', 'application/json']
+      parsed.first.extensions.must_equal('version' => '2', 'level' => 'a,b;c')
+    end
+
+    it "unescapes quoted pairs without splitting escaped quotes" do
+      parsed = subject.new('text/html;note="a\\"b,c;d\\\\e"').list
+      parsed.size.must_equal 1
+      parsed.first.extensions.must_equal('note' => 'a"b,c;d\\e')
+    end
+
+    it "treats apostrophes as token characters rather than quotes" do
+      parsed = subject.new("text/html;version='1', application/json;q=0.8").list
+      parsed.map(&:media_range).must_equal ['text/html', 'application/json']
+      parsed.first.extensions.must_equal('version' => "'1'")
+    end
+
+    it "does not read quality values inside quoted parameters" do
+      parsed = subject.new('text/html;note="example;q=0.2";q=0.8').list.first
+      parsed.q.must_equal 0.8
+      parsed.extensions.must_equal('note' => 'example;q=0.2')
+    end
+
+    it "does not invent parameters from malformed values" do
+      ['text/html;note="unterminated', 'text/html;note="trailing' + "\\",
+       'text/html;note="closed"junk', "text/html;note=\"line\nbreak\"",
+       "text/html;note=\"escaped\\\nbreak\"", 'text/html;note=two words'].each do |header|
+        subject.new(header).list.must_equal []
+      end
+      parsed = subject.new('text/html;note="closed"junk, application/json').list
+      parsed.map(&:media_range).must_equal ['application/json']
+    end
+
+    it "round trips quoted parameter values and quality" do
+      original = media_type.new('text', 'html', q: 0.8, extensions: {
+        'note' => 'a,b;c"d\\e', 'empty' => '', 'version' => "'1'"
+      })
+      parsed = subject.new(original.to_s).list
+      parsed.size.must_equal 1
+      parsed.first.to_h.must_equal original.to_h
     end
 
     it "skips invalid media types" do
@@ -108,7 +142,7 @@ describe AcceptHeaders::MediaType::Negotiator do
 
   describe "#to_s" do
     it "returns a string of each media type #to_s joined by a comma" do
-      subject.new("text/html;level=1, text/plain;q=0.9").to_s.must_equal "text/html;q=1;level=1,text/plain;q=0.9"
+      subject.new("text/html;level=1, text/plain;q=0.9").to_s.must_equal "text/html;level=1;q=1,text/plain;q=0.9"
     end
   end
 
@@ -150,13 +184,14 @@ describe AcceptHeaders::MediaType::Negotiator do
       api = subject.new('application/json;q=1;version=2,application/json;q=0.9;version=1')
       api.negotiate('text/html').must_be_nil
       api.negotiate('application/xml').must_be_nil
-      api.negotiate(['application/xml', 'application/json']).must_equal media_type.new(
+      api.negotiate(['application/xml', 'application/json']).must_be_nil
+      api.negotiate(['application/json;version=1', 'application/json;version=2']).to_h.must_equal media_type.new(
         'application',
         'json',
         extensions: {
-          'version' => '1'
+          'version' => '2'
         }
-      )
+      ).to_h
 
       q0 = subject.new('application/json,application/xml;q=0')
       q0.negotiate('application/json').must_equal media_type.new(
@@ -170,11 +205,54 @@ describe AcceptHeaders::MediaType::Negotiator do
       )
     end
 
+    it "uses the most specific matching range to assign quality before choosing a representation" do
+      n = subject.new('text/html;q=0.1,text/*;q=0.9,application/json;q=0.5')
+      n.negotiate(['text/html', 'application/json']).media_range.must_equal 'application/json'
+      n.negotiate(['text/html', 'text/plain']).media_range.must_equal 'text/plain'
+    end
+
+    it "gives matching parameters precedence over a parameterless range" do
+      n = subject.new('text/plain;q=0.7,text/plain;format=fixed;q=0.4,image/jpeg;q=0.5')
+      n.negotiate(['text/plain;format=fixed', 'image/jpeg']).media_range.must_equal 'image/jpeg'
+      n.negotiate(['text/plain', 'image/jpeg']).media_range.must_equal 'text/plain'
+    end
+
+    it "treats parameters after q as media parameters" do
+      n = subject.new('application/json;q=0.9;version=2')
+      n.negotiate('application/json').must_be_nil
+      n.negotiate('application/json;version=2').extensions.must_equal('version' => '2')
+    end
+
+    it "preserves the parameters of the supported representation" do
+      n = subject.new('application/json')
+      n.negotiate('application/json;version=2').to_h.must_equal media_type.new(
+        'application', 'json', extensions: { 'version' => '2' }
+      ).to_h
+    end
+
+    it "uses supported order to break equally preferred matching representations" do
+      n = subject.new('text/*')
+      n.negotiate(['text/plain', 'text/html']).media_range.must_equal 'text/plain'
+      n.negotiate(['text/html', 'text/plain']).media_range.must_equal 'text/html'
+    end
+
+    it "allows a specific positive quality to override a wildcard exclusion" do
+      n = subject.new('text/*;q=0,text/html;q=0.5')
+      n.negotiate('text/html').media_range.must_equal 'text/html'
+      n.negotiate('text/plain').must_be_nil
+    end
+
+    it "excludes only representations matching the rejected parameters" do
+      n = subject.new('text/plain;format=fixed;q=0,text/plain;q=1')
+      n.negotiate('text/plain;format=fixed').must_be_nil
+      n.negotiate('text/plain;format=flowed').extensions.must_equal('format' => 'flowed')
+    end
+
     it "rejects matching q=0 even if it matches media ranges where q > 0" do
-      n = subject.new('application/xml;q=0;*/*')
+      n = subject.new('application/xml;q=0,*/*')
       n.negotiate('application/xml').must_be_nil
 
-      n2 = subject.new('application/xml;q=0;application/xml;q=1')
+      n2 = subject.new('application/xml;q=0,application/xml;q=1')
       n2.negotiate('application/xml').must_be_nil
     end
   end
@@ -196,10 +274,10 @@ describe AcceptHeaders::MediaType::Negotiator do
     end
 
     it "returns false when q=0 even if it matches media ranges where q > 0" do
-      n = subject.new('application/xml;q=0;*/*')
+      n = subject.new('application/xml;q=0,*/*')
       n.accept?('application/xml').must_equal false
 
-      n2 = subject.new('application/xml;q=0;application/xml;q=1')
+      n2 = subject.new('application/xml;q=0,application/xml;q=1')
       n2.accept?('application/xml').must_equal false
     end
   end