addressable 2.3.7 → 2.7.0

data/spec/addressable/uri_spec.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 # coding: utf-8
-# Copyright (C) 2006-2013 Bob Aman
+# Copyright (C) Bob Aman
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
 #    you may not use this file except in compliance with the License.
@@ -18,6 +20,7 @@ require "spec_helper"
 
 require "addressable/uri"
 require "uri"
+require "ipaddr"
 
 if !"".respond_to?("force_encoding")
   class String
@@ -68,6 +71,14 @@ describe Addressable::URI, "when created with a non-numeric port number" do
   end
 end
 
+describe Addressable::URI, "when created with a invalid encoded port number" do
+  it "should raise an error" do
+    expect(lambda do
+      Addressable::URI.new(:port => "%eb")
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
 describe Addressable::URI, "when created with a non-string scheme" do
   it "should raise an error" do
     expect(lambda do
@@ -116,14 +127,6 @@ describe Addressable::URI, "when created with a non-string authority" do
   end
 end
 
-describe Addressable::URI, "when created with a non-string authority" do
-  it "should raise an error" do
-    expect(lambda do
-      Addressable::URI.new(:authority => :bogus)
-    end).to raise_error(TypeError)
-  end
-end
-
 describe Addressable::URI, "when created with a non-string path" do
   it "should raise an error" do
     expect(lambda do
@@ -157,6 +160,51 @@ describe Addressable::URI, "when created with a scheme but no hierarchical " +
   end
 end
 
+describe Addressable::URI, "quote handling" do
+  describe 'in host name' do
+    it "should raise an error for single quote" do
+      expect(lambda do
+        Addressable::URI.parse("http://local\"host/")
+      end).to raise_error(Addressable::URI::InvalidURIError)
+    end
+  end
+end
+
+describe Addressable::URI, "newline normalization" do
+  it "should not accept newlines in scheme" do
+    expect(lambda do
+      Addressable::URI.parse("ht%0atp://localhost/")
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should not unescape newline in path" do
+    uri = Addressable::URI.parse("http://localhost/%0a").normalize
+    expect(uri.to_s).to eq("http://localhost/%0A")
+  end
+
+  it "should not unescape newline in hostname" do
+    uri = Addressable::URI.parse("http://local%0ahost/").normalize
+    expect(uri.to_s).to eq("http://local%0Ahost/")
+  end
+
+  it "should not unescape newline in username" do
+    uri = Addressable::URI.parse("http://foo%0abar@localhost/").normalize
+    expect(uri.to_s).to eq("http://foo%0Abar@localhost/")
+  end
+
+  it "should not unescape newline in username" do
+    uri = Addressable::URI.parse("http://example:foo%0abar@example/").normalize
+    expect(uri.to_s).to eq("http://example:foo%0Abar@example/")
+  end
+
+  it "should not accept newline in hostname" do
+    uri = Addressable::URI.parse("http://localhost/")
+    expect(lambda do
+      uri.host = "local\nhost"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
 describe Addressable::URI, "when created with ambiguous path" do
   it "should raise an error" do
     expect(lambda do
@@ -173,6 +221,28 @@ describe Addressable::URI, "when created with an invalid host" do
   end
 end
 
+describe Addressable::URI, "when created with a host consisting of " +
+    "sub-delims characters" do
+  it "should not raise an error" do
+    expect(lambda do
+      Addressable::URI.new(
+        :host => Addressable::URI::CharacterClasses::SUB_DELIMS.gsub(/\\/, '')
+      )
+    end).not_to raise_error
+  end
+end
+
+describe Addressable::URI, "when created with a host consisting of " +
+    "unreserved characters" do
+  it "should not raise an error" do
+    expect(lambda do
+      Addressable::URI.new(
+        :host => Addressable::URI::CharacterClasses::UNRESERVED.gsub(/\\/, '')
+      )
+    end).not_to raise_error
+  end
+end
+
 describe Addressable::URI, "when created from nil components" do
   before do
     @uri = Addressable::URI.new
@@ -210,6 +280,48 @@ describe Addressable::URI, "when created from nil components" do
     end).to raise_error(Addressable::URI::InvalidURIError)
   end
 
+  it "should raise an error if the scheme begins with a digit" do
+    expect(lambda do
+      @uri.scheme = "1scheme"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if the scheme begins with a plus" do
+    expect(lambda do
+      @uri.scheme = "+scheme"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if the scheme begins with a dot" do
+    expect(lambda do
+      @uri.scheme = ".scheme"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if the scheme begins with a dash" do
+    expect(lambda do
+      @uri.scheme = "-scheme"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if the scheme contains an illegal character" do
+    expect(lambda do
+      @uri.scheme = "scheme!"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if the scheme contains whitespace" do
+    expect(lambda do
+      @uri.scheme = "sch eme"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should raise an error if the scheme contains a newline" do
+    expect(lambda do
+      @uri.scheme = "sch\neme"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
   it "should raise an error if set into an invalid state" do
     expect(lambda do
       @uri.user = "user"
@@ -291,6 +403,10 @@ describe Addressable::URI, "when initialized from individual components" do
     expect(@uri.normalized_host).to eq("example.com")
   end
 
+  it "returns 'com' for #tld" do
+    expect(@uri.tld).to eq("com")
+  end
+
   it "returns 'user:password@example.com:8080' for #authority" do
     expect(@uri.authority).to eq("user:password@example.com:8080")
   end
@@ -841,6 +957,10 @@ describe Addressable::URI, "when frozen" do
     expect(@uri.normalize.query).to eq("a=1")
   end
 
+  it "returns '/%70a%74%68?a=%31' for #request_uri" do
+    expect(@uri.request_uri).to eq("/%70a%74%68?a=%31")
+  end
+
   it "returns '1%323' for #fragment" do
     expect(@uri.fragment).to eq("1%323")
   end
@@ -955,6 +1075,30 @@ describe Addressable::URI, "when created with a host with trailing dots" do
   end
 end
 
+describe Addressable::URI, "when created with a host with a backslash" do
+  it "should raise an error" do
+    expect(lambda do
+      Addressable::URI.new(:authority => "example\\example")
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when created with a host with a slash" do
+  it "should raise an error" do
+    expect(lambda do
+      Addressable::URI.new(:authority => "example/example")
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
+describe Addressable::URI, "when created with a host with a space" do
+  it "should raise an error" do
+    expect(lambda do
+      Addressable::URI.new(:authority => "example example")
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+end
+
 describe Addressable::URI, "when created with both a userinfo and a user" do
   it "should raise an error" do
     expect(lambda do
@@ -1025,6 +1169,26 @@ describe Addressable::URI, "when parsed from an Addressable::URI object" do
     expect(original_uri.host).to eq('example.com')
     expect(original_uri.to_s).to eq('http://example.com/')
   end
+
+  it "should not have unexpected side-effects" do
+    original_uri = Addressable::URI.parse("http://example.com/")
+    new_uri = Addressable::URI.parse(original_uri)
+    new_uri.origin = 'https://www.example.com:8080'
+    expect(new_uri.host).to eq('www.example.com')
+    expect(new_uri.to_s).to eq('https://www.example.com:8080/')
+    expect(original_uri.host).to eq('example.com')
+    expect(original_uri.to_s).to eq('http://example.com/')
+  end
+
+  it "should not have unexpected side-effects" do
+    original_uri = Addressable::URI.parse("http://example.com/")
+    new_uri = Addressable::URI.heuristic_parse(original_uri)
+    new_uri.origin = 'https://www.example.com:8080'
+    expect(new_uri.host).to eq('www.example.com')
+    expect(new_uri.to_s).to eq('https://www.example.com:8080/')
+    expect(original_uri.host).to eq('example.com')
+    expect(original_uri.to_s).to eq('http://example.com/')
+  end
 end
 
 describe Addressable::URI, "when parsed from something that looks " +
@@ -1037,6 +1201,15 @@ describe Addressable::URI, "when parsed from something that looks " +
   end
 end
 
+describe Addressable::URI, "when parsed from a standard library URI object" do
+  it "should parse without error" do
+    uri = Addressable::URI.parse(URI.parse("http://example.com/"))
+    expect(lambda do
+      Addressable::URI.parse(uri)
+    end).not_to raise_error
+  end
+end
+
 describe Addressable::URI, "when parsed from ''" do
   before do
     @uri = Addressable::URI.parse("")
@@ -1628,7 +1801,7 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should have the same hash as http://EXAMPLE.com after assignment" do
-    @uri.host = "EXAMPLE.com"
+    @uri.origin = "http://EXAMPLE.com"
     expect(@uri.hash).to eq(Addressable::URI.parse("http://EXAMPLE.com").hash)
   end
 
@@ -1636,6 +1809,24 @@ describe Addressable::URI, "when parsed from " +
     expect(@uri.hash).not_to eq(Addressable::URI.parse("http://EXAMPLE.com").hash)
   end
 
+  it "should not allow origin assignment without scheme" do
+    expect(lambda do
+      @uri.origin = "example.com"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should not allow origin assignment without host" do
+    expect(lambda do
+      @uri.origin = "http://"
+    end).to raise_error(Addressable::URI::InvalidURIError)
+  end
+
+  it "should not allow origin assignment with bogus type" do
+    expect(lambda do
+      @uri.origin = :bogus
+    end).to raise_error(TypeError)
+  end
+
   # Section 6.2.3 of RFC 3986
   it "should be equivalent to http://example.com/" do
     expect(@uri).to eq(Addressable::URI.parse("http://example.com/"))
@@ -1786,15 +1977,29 @@ end
 
 # Section 5.1.2 of RFC 2616
 describe Addressable::URI, "when parsed from " +
-    "'http://www.w3.org/pub/WWW/TheProject.html'" do
+    "'HTTP://www.w3.org/pub/WWW/TheProject.html'" do
   before do
-    @uri = Addressable::URI.parse("http://www.w3.org/pub/WWW/TheProject.html")
+    @uri = Addressable::URI.parse("HTTP://www.w3.org/pub/WWW/TheProject.html")
   end
 
   it "should have the correct request URI" do
     expect(@uri.request_uri).to eq("/pub/WWW/TheProject.html")
   end
 
+  it "should have the correct request URI after assignment" do
+    @uri.request_uri = "/pub/WWW/TheProject.html?"
+    expect(@uri.request_uri).to eq("/pub/WWW/TheProject.html?")
+    expect(@uri.path).to eq("/pub/WWW/TheProject.html")
+    expect(@uri.query).to eq("")
+  end
+
+  it "should have the correct request URI after assignment" do
+    @uri.request_uri = "/some/where/else.html"
+    expect(@uri.request_uri).to eq("/some/where/else.html")
+    expect(@uri.path).to eq("/some/where/else.html")
+    expect(@uri.query).to eq(nil)
+  end
+
   it "should have the correct request URI after assignment" do
     @uri.request_uri = "/some/where/else.html?query?string"
     expect(@uri.request_uri).to eq("/some/where/else.html?query?string")
@@ -1823,7 +2028,7 @@ describe Addressable::URI, "when parsed from " +
 
   it "should correctly convert to a hash" do
     expect(@uri.to_hash).to eq({
-      :scheme => "http",
+      :scheme => "HTTP",
       :user => nil,
       :password => nil,
       :host => "www.w3.org",
@@ -1886,6 +2091,12 @@ describe Addressable::URI, "when assigning IPv6 address" do
     expect(uri.to_s).to eq('http://[3ffe:1900:4545:3:200:f8ff:fe21:67cf]/')
   end
 
+  it "should allow to set bare IPv6 address as hostname with IPAddr object" do
+    uri = Addressable::URI.parse("http://[::1]/")
+    uri.hostname = IPAddr.new('3ffe:1900:4545:3:200:f8ff:fe21:67cf')
+    expect(uri.to_s).to eq('http://[3ffe:1900:4545:3:200:f8ff:fe21:67cf]/')
+  end
+
   it "should not allow to set bare IPv6 address as host" do
     uri = Addressable::URI.parse("http://[::1]/")
     skip "not checked"
@@ -2167,6 +2378,80 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when parsed from " +
+    "'HTTP://EXAMPLE.COM/'" do
+  before do
+    @uri = Addressable::URI.parse("HTTP://EXAMPLE.COM/")
+  end
+
+  it "should be equivalent to http://example.com" do
+    expect(@uri).to eq(Addressable::URI.parse("http://example.com"))
+  end
+
+  it "should correctly convert to a hash" do
+    expect(@uri.to_hash).to eq({
+      :scheme => "HTTP",
+      :user => nil,
+      :password => nil,
+      :host => "EXAMPLE.COM",
+      :port => nil,
+      :path => "/",
+      :query => nil,
+      :fragment => nil
+    })
+  end
+
+  it "should be identical to its duplicate" do
+    expect(@uri).to eq(@uri.dup)
+  end
+
+  it "should have an origin of 'http://example.com'" do
+    expect(@uri.origin).to eq('http://example.com')
+  end
+
+  it "should have a tld of 'com'" do
+    expect(@uri.tld).to eq('com')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://www.example.co.uk/'" do
+  before do
+    @uri = Addressable::URI.parse("http://www.example.co.uk/")
+  end
+
+  it "should have an origin of 'http://www.example.co.uk'" do
+    expect(@uri.origin).to eq('http://www.example.co.uk')
+  end
+
+  it "should have a tld of 'co.uk'" do
+    expect(@uri.tld).to eq('co.uk')
+  end
+
+  it "should have a domain of 'example.co.uk'" do
+    expect(@uri.domain).to eq('example.co.uk')
+  end
+end
+
+describe Addressable::URI, "when parsed from " +
+    "'http://sub_domain.blogspot.com/'" do
+  before do
+    @uri = Addressable::URI.parse("http://sub_domain.blogspot.com/")
+  end
+
+  it "should have an origin of 'http://sub_domain.blogspot.com'" do
+    expect(@uri.origin).to eq('http://sub_domain.blogspot.com')
+  end
+
+  it "should have a tld of 'com'" do
+    expect(@uri.tld).to eq('com')
+  end
+
+  it "should have a domain of 'blogspot.com'" do
+    expect(@uri.domain).to eq('blogspot.com')
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://example.com/~smith/'" do
   before do
@@ -2808,6 +3093,23 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when parsed from " +
+    "'/..//example.com'" do
+  before do
+    @uri = Addressable::URI.parse("/..//example.com")
+  end
+
+  it "should become invalid when normalized" do
+    expect(lambda do
+      @uri.normalize
+    end).to raise_error(Addressable::URI::InvalidURIError, /authority/)
+  end
+
+  it "should have a path of '/..//example.com'" do
+    expect(@uri.path).to eq("/..//example.com")
+  end
+end
+
 describe Addressable::URI, "when parsed from '/a/b/c/./../../g'" do
   before do
     @uri = Addressable::URI.parse("/a/b/c/./../../g")
@@ -3564,15 +3866,6 @@ describe Addressable::URI, "when parsed from " +
     expect(@uri.to_str).to eq(
       "ftp://user:pass@example.com/path/to/resource?query=x#fragment"
     )
-    @uri.scheme = "bogus!"
-    expect(@uri.scheme).to eq("bogus!")
-    expect(@uri.normalized_scheme).to eq("bogus%21")
-    expect(@uri.normalize.to_s).to eq(
-      "bogus%21://user:pass@example.com/path/to/resource?query=x#fragment"
-    )
-    expect(@uri.normalize.to_str).to eq(
-      "bogus%21://user:pass@example.com/path/to/resource?query=x#fragment"
-    )
   end
 
   it "should have the correct site segment after assignment" do
@@ -3641,12 +3934,31 @@ describe Addressable::URI, "when parsed from " +
     expect(@uri.authority).to eq("user:pass@newexample.com")
   end
 
+  it "should have the correct host after assignment" do
+    @uri.hostname = "newexample.com"
+    expect(@uri.host).to eq("newexample.com")
+    expect(@uri.hostname).to eq("newexample.com")
+    expect(@uri.authority).to eq("user:pass@newexample.com")
+  end
+
+  it "should raise an error if assigning a bogus object to the hostname" do
+    expect(lambda do
+      @uri.hostname = Object.new
+    end).to raise_error(TypeError)
+  end
+
   it "should have the correct port after assignment" do
     @uri.port = 8080
     expect(@uri.port).to eq(8080)
     expect(@uri.authority).to eq("user:pass@example.com:8080")
   end
 
+  it "should have the correct origin after assignment" do
+    @uri.origin = "http://newexample.com"
+    expect(@uri.host).to eq("newexample.com")
+    expect(@uri.authority).to eq("newexample.com")
+  end
+
   it "should have the correct path after assignment" do
     @uri.path = "/newpath/to/resource"
     expect(@uri.path).to eq("/newpath/to/resource")
@@ -3991,6 +4303,26 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when parsed from 'http://example/?b=1&a=2&c=3'" do
+  before do
+    @uri = Addressable::URI.parse("http://example/?b=1&a=2&c=3")
+  end
+
+  it "should have a sorted normalized query of 'a=2&b=1&c=3'" do
+    expect(@uri.normalized_query(:sorted)).to eq("a=2&b=1&c=3")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'http://example/?&a&&c&'" do
+  before do
+    @uri = Addressable::URI.parse("http://example/?&a&&c&")
+  end
+
+  it "should have a compacted normalized query of 'a&c'" do
+    expect(@uri.normalized_query(:compacted)).to eq("a&c")
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://example.com/sound%2bvision'" do
   before do
@@ -4105,7 +4437,7 @@ describe Addressable::URI, "when parsed from " +
     expect(lambda do
       # This would create an invalid URI
       @uri.authority = nil
-    end).to raise_error
+    end).to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
@@ -4508,7 +4840,7 @@ describe Addressable::URI, "when parsed from '?one=1&two=2&three=3'" do
 
   it "should raise an error for invalid return type values" do
     expect(lambda do
-      @uri.query_values(Fixnum)
+      @uri.query_values(Integer)
     end).to raise_error(ArgumentError)
   end
 
@@ -5194,6 +5526,31 @@ describe Addressable::URI, "when given the path '/one/two/'" do
   end
 end
 
+describe Addressable::URI, "when given the tld " do
+  it "'uk' should have a tld of 'uk'" do
+    uri = Addressable::URI.parse("http://example.com")
+    uri.tld = "uk"
+
+    expect(uri.tld).to eq("uk")
+  end
+
+  context "which " do
+    let (:uri) { Addressable::URI.parse("http://www.comrade.net/path/to/source/") }
+
+    it "contains a subdomain" do
+      uri.tld = "co.uk"
+
+      expect(uri.to_s).to eq("http://www.comrade.co.uk/path/to/source/")
+    end
+
+    it "is part of the domain" do
+      uri.tld = "com"
+
+      expect(uri.to_s).to eq("http://www.comrade.com/path/to/source/")
+    end
+  end
+end
+
 describe Addressable::URI, "when given the path " +
     "'c:\\windows\\My Documents 100%20\\foo.txt'" do
   before do
@@ -5313,7 +5670,7 @@ describe Addressable::URI, "when parsing a non-String object" do
   it "should raise a TypeError for objects than cannot be converted" do
     expect(lambda do
       Addressable::URI.parse(42)
-    end).to raise_error(TypeError, "Can't convert Fixnum into String.")
+    end).to raise_error(TypeError)
   end
 
   it "should correctly parse heuristically anything with a 'to_str' method" do
@@ -5323,7 +5680,7 @@ describe Addressable::URI, "when parsing a non-String object" do
   it "should raise a TypeError for objects than cannot be converted" do
     expect(lambda do
       Addressable::URI.heuristic_parse(42)
-    end).to raise_error(TypeError, "Can't convert Fixnum into String.")
+    end).to raise_error(TypeError)
   end
 end
 
@@ -5369,7 +5726,25 @@ describe Addressable::URI, "when form encoding a non-Array object" do
   it "should raise a TypeError for objects than cannot be converted" do
     expect(lambda do
       Addressable::URI.form_encode(42)
-    end).to raise_error(TypeError, "Can't convert Fixnum into Array.")
+    end).to raise_error(TypeError)
+  end
+end
+
+# See https://tools.ietf.org/html/rfc6749#appendix-B
+describe Addressable::URI, "when form encoding the example value from OAuth 2" do
+  it "should result in correct values" do
+    expect(Addressable::URI.form_encode(
+      {"value" => " %&+£€"}
+    )).to eq("value=+%25%26%2B%C2%A3%E2%82%AC")
+  end
+end
+
+# See https://tools.ietf.org/html/rfc6749#appendix-B
+describe Addressable::URI, "when form unencoding the example value from OAuth 2" do
+  it "should result in correct values" do
+    expect(Addressable::URI.form_unencode(
+      "value=+%25%26%2B%C2%A3%E2%82%AC"
+    )).to eq([["value", " %&+£€"]])
   end
 end
 
@@ -5419,7 +5794,7 @@ describe Addressable::URI, "when form unencoding a non-String object" do
   it "should raise a TypeError for objects than cannot be converted" do
     expect(lambda do
       Addressable::URI.form_unencode(42)
-    end).to raise_error(TypeError, "Can't convert Fixnum into String.")
+    end).to raise_error(TypeError)
   end
 end
 
@@ -5431,7 +5806,7 @@ describe Addressable::URI, "when normalizing a non-String object" do
   it "should raise a TypeError for objects than cannot be converted" do
     expect(lambda do
       Addressable::URI.normalize_component(42)
-    end).to raise_error(TypeError, "Can't convert Fixnum into String.")
+    end).to raise_error(TypeError)
   end
 
   it "should raise a TypeError for objects than cannot be converted" do
@@ -5697,6 +6072,136 @@ describe Addressable::URI, "when given the input " +
   end
 end
 
+describe Addressable::URI, "when given the input " +
+    "'http://prefix\\.example.com/'" do
+  before do
+    @input = "http://prefix\\.example.com/"
+  end
+
+  it "should heuristically parse to 'http://prefix/.example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.authority).to eq("prefix")
+    expect(@uri.to_s).to eq("http://prefix/.example.com/")
+  end
+
+  it "should heuristically parse to 'http://prefix/.example.com/' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    expect(@uri.to_s).to eq("http://prefix/.example.com/")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http://p:\\/'" do
+  before do
+    @input = "http://p:\\/"
+  end
+
+  it "should heuristically parse to 'http://p//'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.authority).to eq("p")
+    expect(@uri.to_s).to eq("http://p//")
+  end
+
+  it "should heuristically parse to 'http://p//' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    expect(@uri.to_s).to eq("http://p//")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http://p://'" do
+  before do
+    @input = "http://p://"
+  end
+
+  it "should heuristically parse to 'http://p//'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.authority).to eq("p")
+    expect(@uri.to_s).to eq("http://p//")
+  end
+
+  it "should heuristically parse to 'http://p//' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    expect(@uri.to_s).to eq("http://p//")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http://p://p'" do
+  before do
+    @input = "http://p://p"
+  end
+
+  it "should heuristically parse to 'http://p//p'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.authority).to eq("p")
+    expect(@uri.to_s).to eq("http://p//p")
+  end
+
+  it "should heuristically parse to 'http://p//p' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    expect(@uri.to_s).to eq("http://p//p")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http://prefix .example.com/'" do
+  before do
+    @input = "http://prefix .example.com/"
+  end
+
+  # Justification here being that no browser actually tries to resolve this.
+  # They all treat this as a web search.
+  it "should heuristically parse to 'http://prefix%20.example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.authority).to eq("prefix%20.example.com")
+    expect(@uri.to_s).to eq("http://prefix%20.example.com/")
+  end
+
+  it "should heuristically parse to 'http://prefix%20.example.com/' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    expect(@uri.to_s).to eq("http://prefix%20.example.com/")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'  http://www.example.com/  '" do
+  before do
+    @input = "  http://www.example.com/  "
+  end
+
+  it "should heuristically parse to 'http://prefix%20.example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.scheme).to eq("http")
+    expect(@uri.path).to eq("/")
+    expect(@uri.to_s).to eq("http://www.example.com/")
+  end
+end
+
+describe Addressable::URI, "when given the input " +
+    "'http://prefix%2F.example.com/'" do
+  before do
+    @input = "http://prefix%2F.example.com/"
+  end
+
+  it "should heuristically parse to 'http://prefix%2F.example.com/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.authority).to eq("prefix%2F.example.com")
+    expect(@uri.to_s).to eq("http://prefix%2F.example.com/")
+  end
+
+  it "should heuristically parse to 'http://prefix%2F.example.com/' " +
+      "even with a scheme hint of 'ftp'" do
+    @uri = Addressable::URI.heuristic_parse(@input, {:scheme => 'ftp'})
+    expect(@uri.to_s).to eq("http://prefix%2F.example.com/")
+  end
+end
+
 describe Addressable::URI, "when given the input " +
     "'/path/to/resource'" do
   before do
@@ -5783,6 +6288,18 @@ describe Addressable::URI, "when given the input " +
   end
 end
 
+describe Addressable::URI, "when given the input which "\
+  "start with digits and has specified port" do
+  before do
+    @input = "7777.example.org:8089"
+  end
+
+  it "should heuristically parse to 'http://7777.example.org:8089'" do
+    uri = Addressable::URI.heuristic_parse(@input)
+    expect(uri.to_s).to eq("http://7777.example.org:8089")
+  end
+end
+
 describe Addressable::URI, "when given the input " +
     "'feed:///example.com'" do
   before do
@@ -5795,6 +6312,18 @@ describe Addressable::URI, "when given the input " +
   end
 end
 
+describe Addressable::URI, "when given the input " +
+    "'file://localhost/path/to/resource/'" do
+  before do
+    @input = "file://localhost/path/to/resource/"
+  end
+
+  it "should heuristically parse to 'file:///path/to/resource/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("file:///path/to/resource/")
+  end
+end
+
 describe Addressable::URI, "when given the input " +
     "'file://path/to/resource/'" do
   before do
@@ -5807,6 +6336,18 @@ describe Addressable::URI, "when given the input " +
   end
 end
 
+describe Addressable::URI, "when given the input " +
+    "'file://///path/to/resource/'" do
+  before do
+    @input = "file:///////path/to/resource/"
+  end
+
+  it "should heuristically parse to 'file:////path/to/resource/'" do
+    @uri = Addressable::URI.heuristic_parse(@input)
+    expect(@uri.to_s).to eq("file:////path/to/resource/")
+  end
+end
+
 describe Addressable::URI, "when given the input " +
     "'feed://http://example.com'" do
   before do
@@ -5831,6 +6372,44 @@ describe Addressable::URI, "when given the input " +
   end
 end
 
+describe Addressable::URI, "when given the input: 'user@domain.com'" do
+  before do
+    @input = "user@domain.com"
+  end
+
+  context "for heuristic parse" do
+    it "should remain 'mailto:user@domain.com'" do
+      uri = Addressable::URI.heuristic_parse("mailto:#{@input}")
+      expect(uri.to_s).to eq("mailto:user@domain.com")
+    end
+
+    it "should have a scheme of 'mailto'" do
+      uri = Addressable::URI.heuristic_parse(@input)
+      expect(uri.to_s).to   eq("mailto:user@domain.com")
+      expect(uri.scheme).to eq("mailto")
+    end
+
+    it "should remain 'acct:user@domain.com'" do
+      uri = Addressable::URI.heuristic_parse("acct:#{@input}")
+      expect(uri.to_s).to eq("acct:user@domain.com")
+    end
+
+    context "HTTP" do
+      before do
+        @uri = Addressable::URI.heuristic_parse("http://#{@input}/")
+      end
+
+      it "should remain 'http://user@domain.com/'" do
+        expect(@uri.to_s).to eq("http://user@domain.com/")
+      end
+
+      it "should have the username 'user' for HTTP basic authentication" do
+        expect(@uri.user).to eq("user")
+      end
+    end
+  end
+end
+
 describe Addressable::URI, "when assigning query values" do
   before do
     @uri = Addressable::URI.new