addressable 2.2.8 → 2.3.2

data/spec/addressable/uri_spec.rb

@@ -150,6 +150,14 @@ describe Addressable::URI, "when created with a scheme but no hierarchical " +
   end
 end
 
+describe Addressable::URI, "when created with an invalid host" do
+  it "should raise an error" do
+    (lambda do
+      Addressable::URI.new(:host => "<invalid>")
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
 describe Addressable::URI, "when created from nil components" do
   before do
     @uri = Addressable::URI.new
@@ -167,6 +175,10 @@ describe Addressable::URI, "when created from nil components" do
     @uri.to_s.should == ""
   end
 
+  it "should have a nil default port" do
+    @uri.default_port.should == nil
+  end
+
   it "should raise an error if the scheme is set to whitespace" do
     (lambda do
       @uri.scheme = "\t \n"
@@ -267,6 +279,10 @@ describe Addressable::URI, "when frozen" do
     @uri.normalized_port.should == nil
   end
 
+  it "returns nil for #default_port" do
+    @uri.default_port.should == nil
+  end
+
   it "returns nil for #site" do
     @uri.site.should == nil
   end
@@ -359,6 +375,7 @@ describe Addressable::URI, "when created with an authority and no port" do
 
   it "should not infer a port" do
     @uri.port.should == nil
+    @uri.default_port.should == nil
     @uri.inferred_port.should == nil
   end
 
@@ -506,6 +523,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.host.should == "ftp.is.co.za"
   end
 
+  it "should have inferred_port of 21" do
+    @uri.inferred_port.should == 21
+  end
+
   it "should have a path of '/rfc/rfc1808.txt'" do
     @uri.path.should == "/rfc/rfc1808.txt"
   end
@@ -542,6 +563,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.host.should == "www.ietf.org"
   end
 
+  it "should have inferred_port of 80" do
+    @uri.inferred_port.should == 80
+  end
+
   it "should have a path of '/rfc/rfc2396.txt'" do
     @uri.path.should == "/rfc/rfc2396.txt"
   end
@@ -588,6 +613,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.host.should == "[2001:db8::7]"
   end
 
+  it "should have inferred_port of 389" do
+    @uri.inferred_port.should == 389
+  end
+
   it "should have a path of '/c=GB'" do
     @uri.path.should == "/c=GB"
   end
@@ -646,6 +675,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.should_not be_ip_based
   end
 
+  it "should not have an inferred_port" do
+    @uri.inferred_port.should == nil
+  end
+
   it "should have a path of 'John.Doe@example.com'" do
     @uri.path.should == "John.Doe@example.com"
   end
@@ -674,6 +707,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.scheme.should == "news"
   end
 
+  it "should not have an inferred_port" do
+    @uri.inferred_port.should == nil
+  end
+
   it "should not be considered to be ip-based" do
     @uri.should_not be_ip_based
   end
@@ -710,6 +747,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.should_not be_ip_based
   end
 
+  it "should not have an inferred_port" do
+    @uri.inferred_port.should == nil
+  end
+
   it "should have a path of '+1-816-555-1212'" do
     @uri.path.should == "+1-816-555-1212"
   end
@@ -742,10 +783,18 @@ describe Addressable::URI, "when parsed from " +
     @uri.host.should == "192.0.2.16"
   end
 
-  it "should have a port of '80'" do
+  it "should have a port of 80" do
     @uri.port.should == 80
   end
 
+  it "should have a inferred_port of 80" do
+    @uri.inferred_port.should == 80
+  end
+
+  it "should have a default_port of 23" do
+    @uri.default_port.should == 23
+  end
+
   it "should be considered to be ip-based" do
     @uri.should be_ip_based
   end
@@ -779,6 +828,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.scheme.should == "urn"
   end
 
+  it "should not have an inferred_port" do
+    @uri.inferred_port.should == nil
+  end
+
   it "should not be considered to be ip-based" do
     @uri.should_not be_ip_based
   end
@@ -801,6 +854,41 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when heuristically parsed from " +
+    "'192.0.2.16:8000/path'" do
+  before do
+    @uri = Addressable::URI.heuristic_parse("192.0.2.16:8000/path")
+  end
+
+  it "should use the 'http' scheme" do
+    @uri.scheme.should == "http"
+  end
+
+  it "should have a host of '192.0.2.16'" do
+    @uri.host.should == "192.0.2.16"
+  end
+
+  it "should have a port of '8000'" do
+    @uri.port.should == 8000
+  end
+
+  it "should be considered to be ip-based" do
+    @uri.should be_ip_based
+  end
+
+  it "should have a path of '/path'" do
+    @uri.path.should == "/path"
+  end
+
+  it "should be considered to be in normal form" do
+    @uri.normalize.should be_eql(@uri)
+  end
+
+  it "should have an origin of 'http://192.0.2.16:8000'" do
+    @uri.origin.should == 'http://192.0.2.16:8000'
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://example.com'" do
   before do
@@ -1135,6 +1223,74 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when parsing IPv6 addresses" do
+  it "should not raise an error for " +
+      "'http://[3ffe:1900:4545:3:200:f8ff:fe21:67cf]/'" do
+    Addressable::URI.parse("http://[3ffe:1900:4545:3:200:f8ff:fe21:67cf]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[fe80:0:0:0:200:f8ff:fe21:67cf]/'" do
+    Addressable::URI.parse("http://[fe80:0:0:0:200:f8ff:fe21:67cf]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[fe80::200:f8ff:fe21:67cf]/'" do
+    Addressable::URI.parse("http://[fe80::200:f8ff:fe21:67cf]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[::1]/'" do
+    Addressable::URI.parse("http://[::1]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[fe80::1]/'" do
+    Addressable::URI.parse("http://[fe80::1]/")
+  end
+
+  it "should raise an error for " +
+      "'http://[<invalid>]/'" do
+    (lambda do
+      Addressable::URI.parse("http://[<invalid>]/")
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when parsing IPvFuture addresses" do
+  it "should not raise an error for " +
+      "'http://[v9.3ffe:1900:4545:3:200:f8ff:fe21:67cf]/'" do
+    Addressable::URI.parse("http://[v9.3ffe:1900:4545:3:200:f8ff:fe21:67cf]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[vff.fe80:0:0:0:200:f8ff:fe21:67cf]/'" do
+    Addressable::URI.parse("http://[vff.fe80:0:0:0:200:f8ff:fe21:67cf]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[v12.fe80::200:f8ff:fe21:67cf]/'" do
+    Addressable::URI.parse("http://[v12.fe80::200:f8ff:fe21:67cf]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[va0.::1]/'" do
+    Addressable::URI.parse("http://[va0.::1]/")
+  end
+
+  it "should not raise an error for " +
+      "'http://[v255.fe80::1]/'" do
+    Addressable::URI.parse("http://[v255.fe80::1]/")
+  end
+
+  it "should raise an error for " +
+      "'http://[v0.<invalid>]/'" do
+    (lambda do
+      Addressable::URI.parse("http://[v0.<invalid>]/")
+    end).should raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://example.com/'" do
   before do
@@ -1593,6 +1749,10 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should use port 80" do
+    @uri.inferred_port.should == 80
+  end
+
+  it "should have explicit port 80" do
     @uri.port.should == 80
   end
 
@@ -1709,9 +1869,17 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should use port 8080" do
+    @uri.inferred_port.should == 8080
+  end
+
+  it "should have explicit port 8080" do
     @uri.port.should == 8080
   end
 
+  it "should have default port 80" do
+    @uri.default_port.should == 80
+  end
+
   it "should have a path of '/'" do
     @uri.path.should == "/"
   end
@@ -2757,11 +2925,11 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should have the correct query string after hash assignment" do
-    @uri.query_values = {"?uestion mark"=>"=sign", "hello"=>"g\xC3\xBCnther"}
+    @uri.query_values = {"?uestion mark" => "=sign", "hello" => "g\xC3\xBCnther"}
     @uri.query.split("&").should include("%3Fuestion%20mark=%3Dsign")
     @uri.query.split("&").should include("hello=g%C3%BCnther")
     @uri.query_values.should == {
-      "?uestion mark"=>"=sign", "hello"=>"g\xC3\xBCnther"
+      "?uestion mark" => "=sign", "hello" => "g\xC3\xBCnther"
     }
   end
 
@@ -2770,8 +2938,9 @@ describe Addressable::URI, "when parsed from " +
     @uri.query.split("&").should include("flag%3F1")
     @uri.query.split("&").should include("fl%3Dag2")
     @uri.query.split("&").should include("flag3")
-    @uri.query_values.should == {
-      'flag?1' => true, 'fl=ag2' => true, 'flag3' => true
+    @uri.query_values(Array).sort.should == [["fl=ag2"], ["flag3"], ["flag?1"]]
+    @uri.query_values(Hash).should == {
+      'flag?1' => nil, 'fl=ag2' => nil, 'flag3' => nil
     }
   end
 
@@ -2960,7 +3129,7 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should have query_values of {'q' => true, 'x' => 'b'}" do
-    @uri.query_values.should == {'q' => true, 'x' => 'b'}
+    @uri.query_values.should == {'q' => nil, 'x' => 'b'}
   end
 end
 
@@ -3039,6 +3208,10 @@ describe Addressable::URI, "when parsed from " +
     @uri.host.should == "example.com"
   end
 
+  it "should have default_port 80" do
+    @uri.default_port.should == 80
+  end
+
   it "should use port 80" do
     @uri.inferred_port.should == 80
   end
@@ -3469,17 +3642,10 @@ describe Addressable::URI, "when parsed from '?'" do
     @uri = Addressable::URI.parse("?")
   end
 
-  it "should have the correct subscript notation query values" do
+  it "should have the correct return type" do
     @uri.query_values.should == {}
-    @uri.query_values(:notation => :subscript).should == {}
-  end
-
-  it "should have the correct dot notation query values" do
-    @uri.query_values(:notation => :dot).should == {}
-  end
-
-  it "should have the correct flat notation query values" do
-    @uri.query_values(:notation => :flat).should == {}
+    @uri.query_values(Hash).should == {}
+    @uri.query_values(Array).should == []
   end
 
   it "should have a 'null' origin" do
@@ -3496,14 +3662,14 @@ describe Addressable::URI, "when parsed from '?one=1&two=2&three=3'" do
     @uri.query_values.should == {"one" => "1", "two" => "2", "three" => "3"}
   end
 
-  it "should raise an error for invalid query value notations" do
+  it "should raise an error for invalid return type values" do
     (lambda do
-      @uri.query_values(:notation => :bogus)
+      @uri.query_values(Fixnum)
     end).should raise_error(ArgumentError)
   end
 
-  it "should have the correct flat array notation query values" do
-    @uri.query_values(:notation => :flat_array).should == [
+  it "should have the correct array query values" do
+    @uri.query_values(Array).should == [
       ["one", "1"], ["two", "2"], ["three", "3"]
     ]
   end
@@ -3522,8 +3688,8 @@ describe Addressable::URI, "when parsed from '?one=1=uno&two=2=dos'" do
     @uri.query_values.should == {"one" => "1=uno", "two" => "2=dos"}
   end
 
-  it "should have the correct flat array notation query values" do
-    @uri.query_values(:notation => :flat_array).should == [
+  it "should have the correct array query values" do
+    @uri.query_values(Array).should == [
       ["one", "1=uno"], ["two", "2=dos"]
     ]
   end
@@ -3535,17 +3701,11 @@ describe Addressable::URI, "when parsed from '?one[two][three]=four'" do
   end
 
   it "should have the correct query values" do
-    @uri.query_values.should == {"one" => {"two" => {"three" => "four"}}}
-  end
-
-  it "should have the correct flat notation query values" do
-    @uri.query_values(:notation => :flat).should == {
-      "one[two][three]" => "four"
-    }
+    @uri.query_values.should == {"one[two][three]" => "four"}
   end
 
-  it "should have the correct flat array notation query values" do
-    @uri.query_values(:notation => :flat_array).should == [
+  it "should have the correct array query values" do
+    @uri.query_values(Array).should == [
       ["one[two][three]", "four"]
     ]
   end
@@ -3556,20 +3716,14 @@ describe Addressable::URI, "when parsed from '?one.two.three=four'" do
     @uri = Addressable::URI.parse("?one.two.three=four")
   end
 
-  it "should have the correct dot notation query values" do
-    @uri.query_values(:notation => :dot).should == {
-      "one" => {"two" => {"three" => "four"}}
-    }
-  end
-
-  it "should have the correct flat notation query values" do
-    @uri.query_values(:notation => :flat).should == {
+  it "should have the correct query values" do
+    @uri.query_values.should == {
       "one.two.three" => "four"
     }
   end
 
-  it "should have the correct flat array notation query values" do
-    @uri.query_values(:notation => :flat_array).should == [
+  it "should have the correct array query values" do
+    @uri.query_values(Array).should == [
       ["one.two.three", "four"]
     ]
   end
@@ -3581,21 +3735,14 @@ describe Addressable::URI, "when parsed from " +
     @uri = Addressable::URI.parse("?one[two][three]=four&one[two][five]=six")
   end
 
-  it "should have the correct dot notation query values" do
-    @uri.query_values(:notation => :subscript).should == {
-      "one" => {"two" => {"three" => "four", "five" => "six"}}
-    }
-  end
-
-  it "should have the correct flat notation query values" do
-    @uri.query_values(:notation => :flat).should == {
-      "one[two][three]" => "four",
-      "one[two][five]" => "six"
+  it "should have the correct query values" do
+    @uri.query_values.should == {
+      "one[two][three]" => "four", "one[two][five]" => "six"
     }
   end
 
-  it "should have the correct flat array notation query values" do
-    @uri.query_values(:notation => :flat_array).should == [
+  it "should have the correct array query values" do
+    @uri.query_values(Array).should == [
       ["one[two][three]", "four"], ["one[two][five]", "six"]
     ]
   end
@@ -3607,21 +3754,14 @@ describe Addressable::URI, "when parsed from " +
     @uri = Addressable::URI.parse("?one.two.three=four&one.two.five=six")
   end
 
-  it "should have the correct dot notation query values" do
-    @uri.query_values(:notation => :dot).should == {
-      "one" => {"two" => {"three" => "four", "five" => "six"}}
-    }
-  end
-
-  it "should have the correct flat notation query values" do
-    @uri.query_values(:notation => :flat).should == {
-      "one.two.three" => "four",
-      "one.two.five" => "six"
+  it "should have the correct query values" do
+    @uri.query_values.should == {
+      "one.two.three" => "four", "one.two.five" => "six"
     }
   end
 
-  it "should have the correct flat array notation query values" do
-    @uri.query_values(:notation => :flat_array).should == [
+  it "should have the correct array query values" do
+    @uri.query_values(Array).should == [
       ["one.two.three", "four"], ["one.two.five", "six"]
     ]
   end
@@ -3635,8 +3775,8 @@ describe Addressable::URI, "when parsed from " +
     )
   end
 
-  it "should have correct flat_array notation query values" do
-    @uri.query_values(:notation => :flat_array).should ==
+  it "should have correct array query values" do
+    @uri.query_values(Array).should ==
       [['one', 'two'], ['one', 'three']]
   end
 end
@@ -3649,23 +3789,14 @@ describe Addressable::URI, "when parsed from " +
     )
   end
 
-  it "should have the correct subscript notation query values" do
-    @uri.query_values(:notation => :subscript).should == {
-      "one" => {"two" => {"three" => ["four", "five"]}}
-    }
-  end
-
-  it "should raise an error if a key is repeated in the flat notation" do
-    (lambda do
-      @uri.query_values(:notation => :flat)
-    end).should raise_error(ArgumentError)
+  it "should have correct query values" do
+    @uri.query_values(Hash).should == {"one[two][three][]" => "five"}
   end
 
-  it "should not raise an error if a key is " +
-      "repeated in the flat array notation" do
-    (lambda do
-      @uri.query_values(:notation => :flat_array)
-    end).should_not raise_error
+  it "should have correct array query values" do
+    @uri.query_values(Array).should == [
+      ["one[two][three][]", "four"], ["one[two][three][]", "five"]
+    ]
   end
 end
 
@@ -3677,9 +3808,9 @@ describe Addressable::URI, "when parsed from " +
     )
   end
 
-  it "should have the correct subscript notation query values" do
-    @uri.query_values(:notation => :subscript).should == {
-      "one" => {"two" => {"three" => ["four", "five"]}}
+  it "should have the correct query values" do
+    @uri.query_values.should == {
+      "one[two][three][0]" => "four", "one[two][three][1]" => "five"
     }
   end
 end
@@ -3692,9 +3823,9 @@ describe Addressable::URI, "when parsed from " +
     )
   end
 
-  it "should have the correct subscript notation query values" do
-    @uri.query_values(:notation => :subscript).should == {
-      "one" => {"two" => {"three" => ["five", "four"]}}
+  it "should have the correct query values" do
+    @uri.query_values.should == {
+      "one[two][three][1]" => "four", "one[two][three][0]" => "five"
     }
   end
 end
@@ -3707,9 +3838,9 @@ describe Addressable::URI, "when parsed from " +
     )
   end
 
-  it "should have the correct subscript notation query values" do
-    @uri.query_values(:notation => :subscript).should == {
-      "one" => {"two" => {"three" => ["five", "four"]}}
+  it "should have the correct query values" do
+    @uri.query_values.should == {
+      "one[two][three][2]" => "four", "one[two][three][1]" => "five"
     }
   end
 end
@@ -4780,51 +4911,58 @@ describe Addressable::URI, "when assigning query values" do
 
   it "should correctly assign {:a => 'a', :b => ['c', 'd', 'e']}" do
     @uri.query_values = {:a => "a", :b => ["c", "d", "e"]}
-    @uri.query.should == "a=a&b[0]=c&b[1]=d&b[2]=e"
+    @uri.query.should == "a=a&b=c&b=d&b=e"
   end
 
-  it "should correctly assign {'a' => {'b' => [ 'c']}}" do
-    @uri.query_values = { 'a' => {'b' => [ 'c'] } }
-    @uri.query.should == "a[b][0]=c"
+  it "should raise an error attempting to assign {'a' => {'b' => ['c']}}" do
+    (lambda do
+      @uri.query_values = { 'a' => {'b' => ['c'] } }
+    end).should raise_error(TypeError)
   end
 
-  it "should correctly assign {:b => '2', :a => {:c => '1'}}" do
-    @uri.query_values = {:b => '2', :a => { :c => '1' }}
-    @uri.query.should == "a[c]=1&b=2"
+  it "should raise an error attempting to assign " +
+      "{:b => '2', :a => {:c => '1'}}" do
+    (lambda do
+      @uri.query_values = {:b => '2', :a => {:c => '1'}}
+    end).should raise_error(TypeError)
   end
 
-  it "should correctly assign " +
+  it "should raise an error attempting to assign " +
       "{:a => 'a', :b => [{:c => 'c', :d => 'd'}, " +
       "{:e => 'e', :f => 'f'}]}" do
-    @uri.query_values = {
-      :a => "a", :b => [{:c => "c", :d => "d"}, {:e => "e", :f => "f"}]
-    }
-    @uri.query.should == "a=a&b[0][c]=c&b[0][d]=d&b[1][e]=e&b[1][f]=f"
+    (lambda do
+      @uri.query_values = {
+        :a => "a", :b => [{:c => "c", :d => "d"}, {:e => "e", :f => "f"}]
+      }
+    end).should raise_error(TypeError)
   end
 
-  it "should correctly assign " +
+  it "should raise an error attempting to assign " +
       "{:a => 'a', :b => [{:c => true, :d => 'd'}, " +
       "{:e => 'e', :f => 'f'}]}" do
-    @uri.query_values = {
-      :a => 'a', :b => [{:c => true, :d => 'd'}, {:e => 'e', :f => 'f'}]
-    }
-    @uri.query.should == "a=a&b[0][c]&b[0][d]=d&b[1][e]=e&b[1][f]=f"
+    (lambda do
+      @uri.query_values = {
+        :a => 'a', :b => [{:c => true, :d => 'd'}, {:e => 'e', :f => 'f'}]
+      }
+    end).should raise_error(TypeError)
   end
 
-  it "should correctly assign " +
+  it "should raise an error attempting to assign " +
       "{:a => 'a', :b => {:c => true, :d => 'd'}}" do
-    @uri.query_values = {
-      :a => 'a', :b => {:c => true, :d => 'd'}
-    }
-    @uri.query.should == "a=a&b[c]&b[d]=d"
+    (lambda do
+      @uri.query_values = {
+        :a => 'a', :b => {:c => true, :d => 'd'}
+      }
+    end).should raise_error(TypeError)
   end
 
-  it "should correctly assign " +
+  it "should raise an error attempting to assign " +
       "{:a => 'a', :b => {:c => true, :d => 'd'}}" do
-    @uri.query_values = {
-      :a => 'a', :b => {:c => true, :d => 'd'}
-    }
-    @uri.query.should == "a=a&b[c]&b[d]=d"
+    (lambda do
+      @uri.query_values = {
+        :a => 'a', :b => {:c => true, :d => 'd'}
+      }
+    end).should raise_error(TypeError)
   end
 
   it "should correctly assign {:a => 1, :b => 1.5}" do
@@ -4832,18 +4970,16 @@ describe Addressable::URI, "when assigning query values" do
     @uri.query.should == "a=1&b=1.5"
   end
 
-  it "should correctly assign " +
+  it "should raise an error attempting to assign " +
       "{:z => 1, :f => [2, {999.1 => [3,'4']}, ['h', 'i']], " +
       ":a => {:b => ['c', 'd'], :e => true, :y => 0.5}}" do
-    @uri.query_values = {
-      :z => 1,
-      :f => [ 2, {999.1 => [3,'4']}, ['h', 'i'] ],
-      :a => { :b => ['c', 'd'], :e => true, :y => 0.5 }
-    }
-    @uri.query.should == (
-      "a[b][0]=c&a[b][1]=d&a[e]&a[y]=0.5&f[0]=2&" +
-      "f[1][999.1][0]=3&f[1][999.1][1]=4&f[2][0]=h&f[2][1]=i&z=1"
-    )
+    (lambda do
+      @uri.query_values = {
+        :z => 1,
+        :f => [ 2, {999.1 => [3,'4']}, ['h', 'i'] ],
+        :a => { :b => ['c', 'd'], :e => true, :y => 0.5 }
+      }
+    end).should raise_error(TypeError)
   end
 
   it "should correctly assign {}" do
@@ -4872,7 +5008,7 @@ describe Addressable::URI, "when assigning query values" do
     query_string = (('a'..'z').to_a.reverse.map { |e| "#{e}=#{e}" }).join("&")
     @uri.query = query_string
     original_uri = @uri.to_s
-    @uri.query_values = @uri.query_values(:notation => :flat_array)
+    @uri.query_values = @uri.query_values(Array)
     @uri.to_s.should == original_uri
   end
 end