addressable 2.6.0 → 2.8.5

data/spec/addressable/uri_spec.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# coding: utf-8
 # Copyright (C) Bob Aman
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,6 +20,7 @@ require "spec_helper"
 require "addressable/uri"
 require "uri"
 require "ipaddr"
+require "yaml"
 
 if !"".respond_to?("force_encoding")
   class String
@@ -65,116 +65,116 @@ end
 
 describe Addressable::URI, "when created with a non-numeric port number" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:port => "bogus")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
 describe Addressable::URI, "when created with a invalid encoded port number" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:port => "%eb")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    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
+    expect do
       Addressable::URI.new(:scheme => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string user" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:user => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string password" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:password => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string userinfo" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:userinfo => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string host" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:host => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string authority" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:authority => :bogus)
-    end).to raise_error(TypeError)
+    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
+    expect do
       Addressable::URI.new(:path => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string query" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:query => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a non-string fragment" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:fragment => :bogus)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when created with a scheme but no hierarchical " +
     "segment" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.parse("http:")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   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
+      expect do
         Addressable::URI.parse("http://local\"host/")
-      end).to raise_error(Addressable::URI::InvalidURIError)
+      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
+    expect do
       Addressable::URI.parse("ht%0atp://localhost/")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should not unescape newline in path" do
@@ -199,47 +199,47 @@ describe Addressable::URI, "newline normalization" do
 
   it "should not accept newline in hostname" do
     uri = Addressable::URI.parse("http://localhost/")
-    expect(lambda do
+    expect do
       uri.host = "local\nhost"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    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
+    expect do
       Addressable::URI.parse("::http")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
 describe Addressable::URI, "when created with an invalid host" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:host => "<invalid>")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   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
+    expect do
       Addressable::URI.new(
         :host => Addressable::URI::CharacterClasses::SUB_DELIMS.gsub(/\\/, '')
       )
-    end).not_to raise_error
+    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
+    expect do
       Addressable::URI.new(
         :host => Addressable::URI::CharacterClasses::UNRESERVED.gsub(/\\/, '')
       )
-    end).not_to raise_error
+    end.not_to raise_error
   end
 end
 
@@ -269,83 +269,83 @@ describe Addressable::URI, "when created from nil components" do
   end
 
   it "should raise an error if the scheme is set to whitespace" do
-    expect(lambda do
+    expect do
       @uri.scheme = "\t \n"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'\t \n'/)
   end
 
   it "should raise an error if the scheme is set to all digits" do
-    expect(lambda do
+    expect do
       @uri.scheme = "123"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'123'/)
   end
 
   it "should raise an error if the scheme begins with a digit" do
-    expect(lambda do
+    expect do
       @uri.scheme = "1scheme"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'1scheme'/)
   end
 
   it "should raise an error if the scheme begins with a plus" do
-    expect(lambda do
+    expect do
       @uri.scheme = "+scheme"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'\+scheme'/)
   end
 
   it "should raise an error if the scheme begins with a dot" do
-    expect(lambda do
+    expect do
       @uri.scheme = ".scheme"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'\.scheme'/)
   end
 
   it "should raise an error if the scheme begins with a dash" do
-    expect(lambda do
+    expect do
       @uri.scheme = "-scheme"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'-scheme'/)
   end
 
   it "should raise an error if the scheme contains an illegal character" do
-    expect(lambda do
+    expect do
       @uri.scheme = "scheme!"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'scheme!'/)
   end
 
   it "should raise an error if the scheme contains whitespace" do
-    expect(lambda do
+    expect do
       @uri.scheme = "sch eme"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError, /'sch eme'/)
   end
 
   it "should raise an error if the scheme contains a newline" do
-    expect(lambda do
+    expect do
       @uri.scheme = "sch\neme"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should raise an error if set into an invalid state" do
-    expect(lambda do
+    expect do
       @uri.user = "user"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should raise an error if set into an invalid state" do
-    expect(lambda do
+    expect do
       @uri.password = "pass"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should raise an error if set into an invalid state" do
-    expect(lambda do
+    expect do
       @uri.scheme = "http"
       @uri.fragment = "fragment"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should raise an error if set into an invalid state" do
-    expect(lambda do
+    expect do
       @uri.fragment = "fragment"
       @uri.scheme = "http"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
@@ -999,6 +999,72 @@ describe Addressable::URI, "when frozen" do
   end
 end
 
+describe Addressable::URI, "when normalized and then deeply frozen" do
+  before do
+    @uri = Addressable::URI.parse(
+      "http://user:password@example.com:8080/path?query=value#fragment"
+    ).normalize!
+
+    @uri.instance_variables.each do |var|
+      @uri.instance_variable_set(var, @uri.instance_variable_get(var).freeze)
+    end
+
+    @uri.freeze
+  end
+
+  it "#normalized_scheme should not error" do
+    expect { @uri.normalized_scheme }.not_to raise_error
+  end
+
+  it "#normalized_user should not error" do
+    expect { @uri.normalized_user }.not_to raise_error
+  end
+
+  it "#normalized_password should not error" do
+    expect { @uri.normalized_password }.not_to raise_error
+  end
+
+  it "#normalized_userinfo should not error" do
+    expect { @uri.normalized_userinfo }.not_to raise_error
+  end
+
+  it "#normalized_host should not error" do
+    expect { @uri.normalized_host }.not_to raise_error
+  end
+
+  it "#normalized_authority should not error" do
+    expect { @uri.normalized_authority }.not_to raise_error
+  end
+
+  it "#normalized_port should not error" do
+    expect { @uri.normalized_port }.not_to raise_error
+  end
+
+  it "#normalized_site should not error" do
+    expect { @uri.normalized_site }.not_to raise_error
+  end
+
+  it "#normalized_path should not error" do
+    expect { @uri.normalized_path }.not_to raise_error
+  end
+
+  it "#normalized_query should not error" do
+    expect { @uri.normalized_query }.not_to raise_error
+  end
+
+  it "#normalized_fragment should not error" do
+    expect { @uri.normalized_fragment }.not_to raise_error
+  end
+
+  it "should be frozen" do
+    expect(@uri).to be_frozen
+  end
+
+  it "should not allow destructive operations" do
+    expect { @uri.normalize! }.to raise_error(RuntimeError)
+  end
+end
+
 describe Addressable::URI, "when created from string components" do
   before do
     @uri = Addressable::URI.new(
@@ -1015,31 +1081,31 @@ describe Addressable::URI, "when created from string components" do
   end
 
   it "should raise an error if invalid components omitted" do
-    expect(lambda do
+    expect do
       @uri.omit(:bogus)
-    end).to raise_error(ArgumentError)
-    expect(lambda do
+    end.to raise_error(ArgumentError)
+    expect do
       @uri.omit(:scheme, :bogus, :path)
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 end
 
 describe Addressable::URI, "when created with a nil host but " +
     "non-nil authority components" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:user => "user", :password => "pass", :port => 80)
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
 describe Addressable::URI, "when created with both an authority and a user" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(
         :user => "user", :authority => "user@example.com:80"
       )
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 end
 
@@ -1077,33 +1143,33 @@ end
 
 describe Addressable::URI, "when created with a host with a backslash" do
   it "should raise an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.new(:authority => "example\\example")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    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
+    expect do
       Addressable::URI.new(:authority => "example/example")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    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
+    expect do
       Addressable::URI.new(:authority => "example example")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    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
+    expect do
       Addressable::URI.new(:user => "user", :userinfo => "user:pass")
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 end
 
@@ -1195,18 +1261,18 @@ describe Addressable::URI, "when parsed from something that looks " +
     "like a URI object" do
   it "should parse without error" do
     uri = Addressable::URI.parse(Fake::URI::HTTP.new("http://example.com/"))
-    expect(lambda do
+    expect do
       Addressable::URI.parse(uri)
-    end).not_to raise_error
+    end.not_to raise_error
   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
+    expect do
       Addressable::URI.parse(uri)
-    end).not_to raise_error
+    end.not_to raise_error
   end
 end
 
@@ -1366,9 +1432,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should not allow request URI assignment" do
-    expect(lambda do
+    expect do
       @uri.request_uri = "/"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should have a query of 'objectClass?one'" do
@@ -1390,9 +1456,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if omission would create an invalid URI" do
-    expect(lambda do
+    expect do
       @uri.omit(:authority, :path)
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should have an origin of 'ldap://[2001:db8::7]'" do
@@ -1778,9 +1844,9 @@ describe Addressable::URI, "when parsed from " +
 
   it "should not be roughly equal to the string " +
       "'http://example.com:bogus/'" do
-    expect(lambda do
+    expect do
       expect(@uri === "http://example.com:bogus/").to eq(false)
-    end).not_to raise_error
+    end.not_to raise_error
   end
 
   it "should result in itself when joined with itself" do
@@ -1810,21 +1876,21 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should not allow origin assignment without scheme" do
-    expect(lambda do
+    expect do
       @uri.origin = "example.com"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should not allow origin assignment without host" do
-    expect(lambda do
+    expect do
       @uri.origin = "http://"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should not allow origin assignment with bogus type" do
-    expect(lambda do
+    expect do
       @uri.origin = :bogus
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   # Section 6.2.3 of RFC 3986
@@ -1880,9 +1946,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "when joined with a bogus object a TypeError should be raised" do
-    expect(lambda do
+    expect do
       @uri.join(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should have the correct username after assignment" do
@@ -2015,15 +2081,15 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if the site value is set to something bogus" do
-    expect(lambda do
+    expect do
       @uri.site = 42
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise an error if the request URI is set to something bogus" do
-    expect(lambda do
+    expect do
       @uri.request_uri = 42
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should correctly convert to a hash" do
@@ -2072,9 +2138,9 @@ describe Addressable::URI, "when parsing IPv6 addresses" do
 
   it "should raise an error for " +
       "'http://[<invalid>]/'" do
-    expect(lambda do
+    expect do
       Addressable::URI.parse("http://[<invalid>]/")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
@@ -2100,9 +2166,9 @@ describe Addressable::URI, "when assigning IPv6 address" do
   it "should not allow to set bare IPv6 address as host" do
     uri = Addressable::URI.parse("http://[::1]/")
     skip "not checked"
-    expect(lambda do
+    expect do
       uri.host = '3ffe:1900:4545:3:200:f8ff:fe21:67cf'
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
@@ -2134,9 +2200,9 @@ describe Addressable::URI, "when parsing IPvFuture addresses" do
 
   it "should raise an error for " +
       "'http://[v0.<invalid>]/'" do
-    expect(lambda do
+    expect do
       Addressable::URI.parse("http://[v0.<invalid>]/")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
@@ -2480,9 +2546,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should not raise an exception when normalized" do
-    expect(lambda do
+    expect do
       @uri.normalize
-    end).not_to raise_error
+    end.not_to raise_error
   end
 
   it "should be considered to be in normal form" do
@@ -2534,9 +2600,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should not raise an exception when normalized" do
-    expect(lambda do
+    expect do
       @uri.normalize
-    end).not_to raise_error
+    end.not_to raise_error
   end
 
   it "should be considered to be in normal form" do
@@ -2559,9 +2625,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should not raise an exception when normalized" do
-    expect(lambda do
+    expect do
       @uri.normalize
-    end).not_to raise_error
+    end.not_to raise_error
   end
 
   it "should be considered to be in normal form" do
@@ -2597,9 +2663,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if encoding with an unexpected return type" do
-    expect(lambda do
+    expect do
       Addressable::URI.normalized_encode(@uri, Integer)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "if percent encoded should be 'http://example.com/C%25CC%25A7'" do
@@ -2615,9 +2681,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if encoding with an unexpected return type" do
-    expect(lambda do
+    expect do
       Addressable::URI.encode(@uri, Integer)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should be identical to its duplicate" do
@@ -2752,9 +2818,9 @@ describe Addressable::URI, "when parsed from " +
 
   it "should not be roughly equal to the string " +
       "'http://example.com:bogus/'" do
-    expect(lambda do
+    expect do
       expect(@uri === "http://example.com:bogus/").to eq(false)
-    end).not_to raise_error
+    end.not_to raise_error
   end
 
   it "should result in itself when joined with itself" do
@@ -2956,6 +3022,20 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when parsed with empty port" do
+  subject(:uri) do
+    Addressable::URI.parse("//example.com:")
+  end
+
+  it "should not infer a port" do
+    expect(uri.port).to be(nil)
+  end
+
+  it "should have a site value of '//example.com'" do
+    expect(uri.site).to eq("//example.com")
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://example.com/%2E/'" do
   before do
@@ -3100,9 +3180,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should become invalid when normalized" do
-    expect(lambda do
+    expect do
       @uri.normalize
-    end).to raise_error(Addressable::URI::InvalidURIError, /authority/)
+    end.to raise_error(Addressable::URI::InvalidURIError, /authority/)
   end
 
   it "should have a path of '/..//example.com'" do
@@ -3340,12 +3420,12 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if routing is attempted" do
-    expect(lambda do
+    expect do
       @uri.route_to("http://example.com/")
-    end).to raise_error(ArgumentError, /relative\/path\/to\/resource/)
-    expect(lambda do
+    end.to raise_error(ArgumentError, /relative\/path\/to\/resource/)
+    expect do
       @uri.route_from("http://example.com/")
-    end).to raise_error(ArgumentError, /relative\/path\/to\/resource/)
+    end.to raise_error(ArgumentError, /relative\/path\/to\/resource/)
   end
 
   it "when joined with 'another/relative/path' should be " +
@@ -3942,9 +4022,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if assigning a bogus object to the hostname" do
-    expect(lambda do
+    expect do
       @uri.hostname = Object.new
-    end).to raise_error
+    end.to raise_error(TypeError)
   end
 
   it "should have the correct port after assignment" do
@@ -4023,9 +4103,9 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if query values are set to a bogus type" do
-    expect(lambda do
+    expect do
       @uri.query_values = "bogus"
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should have the correct fragment after assignment" do
@@ -4097,39 +4177,39 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should fail to merge with bogus values" do
-    expect(lambda do
+    expect do
       @uri.merge(:port => "bogus")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should fail to merge with bogus values" do
-    expect(lambda do
+    expect do
       @uri.merge(:authority => "bar@baz:bogus")
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should fail to merge with bogus parameters" do
-    expect(lambda do
+    expect do
       @uri.merge(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should fail to merge with bogus parameters" do
-    expect(lambda do
+    expect do
       @uri.merge("http://example.com/")
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should fail to merge with both authority and subcomponents" do
-    expect(lambda do
+    expect do
       @uri.merge(:authority => "foo:bar@baz:42", :port => "42")
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should fail to merge with both userinfo and subcomponents" do
-    expect(lambda do
+    expect do
       @uri.merge(:userinfo => "foo:bar", :user => "foo")
-    end).to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should be identical to its duplicate" do
@@ -4262,6 +4342,36 @@ describe Addressable::URI, "when parsed from " +
   end
 end
 
+describe Addressable::URI, "when parsed from 'https://example.com/?q=a+b'" do
+  before do
+    @uri = Addressable::URI.parse("https://example.com/?q=a+b")
+  end
+
+  it "should have query_values of {'q' => 'a b'}" do
+    expect(@uri.query_values).to eq("q" => "a b")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'example.com?q=a+b'" do
+  before do
+    @uri = Addressable::URI.parse("example.com?q=a+b")
+  end
+
+  it "should have query_values of {'q' => 'a b'}" do
+    expect(@uri.query_values).to eq("q" => "a b")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'mailto:?q=a+b'" do
+  before do
+    @uri = Addressable::URI.parse("mailto:?q=a+b")
+  end
+
+  it "should have query_values of {'q' => 'a+b'}" do
+    expect(@uri.query_values).to eq("q" => "a+b")
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://example.com/?q=a%2bb'" do
   before do
@@ -4303,6 +4413,46 @@ 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/?a=1&a=1'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?a=1&a=1")
+  end
+
+  it "should have a compacted normalized query of 'a=1'" do
+    expect(@uri.normalized_query(:compacted)).to eq("a=1")
+  end
+end
+
+describe Addressable::URI, "when parsed from 'http://example.com/?a=1&a=2'" do
+  before do
+    @uri = Addressable::URI.parse("http://example.com/?a=1&a=2")
+  end
+
+  it "should have a compacted normalized query of 'a=1&a=2'" do
+    expect(@uri.normalized_query(:compacted)).to eq("a=1&a=2")
+  end
+end
+
 describe Addressable::URI, "when parsed from " +
     "'http://example.com/sound%2bvision'" do
   before do
@@ -4414,10 +4564,10 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error after nil assignment of authority segment" do
-    expect(lambda do
+    expect do
       # This would create an invalid URI
       @uri.authority = nil
-    end).to raise_error
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 end
 
@@ -4646,12 +4796,12 @@ describe Addressable::URI, "when parsed from " +
   end
 
   it "should raise an error if routing is attempted" do
-    expect(lambda do
+    expect do
       @uri.route_to("http://example.com/")
-    end).to raise_error(ArgumentError, /\/\/example.com\//)
-    expect(lambda do
+    end.to raise_error(ArgumentError, /\/\/example.com\//)
+    expect do
       @uri.route_from("http://example.com/")
-    end).to raise_error(ArgumentError, /\/\/example.com\//)
+    end.to raise_error(ArgumentError, /\/\/example.com\//)
   end
 
   it "should have a 'null' origin" do
@@ -4745,9 +4895,9 @@ end
 describe Addressable::URI, "when parsed from " +
     "'http://under_score.example.com/'" do
   it "should not cause an error" do
-    expect(lambda do
+    expect do
       Addressable::URI.parse("http://under_score.example.com/")
-    end).not_to raise_error
+    end.not_to raise_error
   end
 end
 
@@ -4819,9 +4969,9 @@ describe Addressable::URI, "when parsed from '?one=1&two=2&three=3'" do
   end
 
   it "should raise an error for invalid return type values" do
-    expect(lambda do
-      @uri.query_values(Fixnum)
-    end).to raise_error(ArgumentError)
+    expect do
+      @uri.query_values(Integer)
+    end.to raise_error(ArgumentError)
   end
 
   it "should have the correct array query values" do
@@ -5422,9 +5572,9 @@ describe Addressable::URI, "with a base uri of 'http://a/b/c/d;p?q'" do
   end
 
   it "when joined with a bogus object a TypeError should be raised" do
-    expect(lambda do
+    expect do
       Addressable::URI.join(@uri, 42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
@@ -5451,9 +5601,9 @@ end
 
 describe Addressable::URI, "when converting a bogus path" do
   it "should raise a TypeError" do
-    expect(lambda do
+    expect do
       Addressable::URI.convert_path(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
@@ -5515,18 +5665,18 @@ describe Addressable::URI, "when given the tld " do
   end
 
   context "which " do
-    let (:uri) { Addressable::URI.parse("http://comrade.net/path/to/source/") }
+    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://comrade.co.uk/path/to/source/")
+      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://comrade.com/path/to/source/")
+      expect(uri.to_s).to eq("http://www.comrade.com/path/to/source/")
     end
   end
 end
@@ -5648,9 +5798,9 @@ describe Addressable::URI, "when parsing a non-String object" do
   end
 
   it "should raise a TypeError for objects than cannot be converted" do
-    expect(lambda do
+    expect do
       Addressable::URI.parse(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should correctly parse heuristically anything with a 'to_str' method" do
@@ -5658,9 +5808,9 @@ describe Addressable::URI, "when parsing a non-String object" do
   end
 
   it "should raise a TypeError for objects than cannot be converted" do
-    expect(lambda do
+    expect do
       Addressable::URI.heuristic_parse(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
@@ -5704,9 +5854,9 @@ end
 
 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
+    expect do
       Addressable::URI.form_encode(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
@@ -5772,9 +5922,9 @@ describe Addressable::URI, "when form unencoding a non-String object" do
   end
 
   it "should raise a TypeError for objects than cannot be converted" do
-    expect(lambda do
+    expect do
       Addressable::URI.form_unencode(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
@@ -5784,15 +5934,15 @@ describe Addressable::URI, "when normalizing a non-String object" do
   end
 
   it "should raise a TypeError for objects than cannot be converted" do
-    expect(lambda do
+    expect do
       Addressable::URI.normalize_component(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise a TypeError for objects than cannot be converted" do
-    expect(lambda do
+    expect do
       Addressable::URI.normalize_component("component", 42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
@@ -5804,6 +5954,26 @@ describe Addressable::URI, "when normalizing a path with an encoded slash" do
   end
 end
 
+describe Addressable::URI, "when normalizing a path with special unicode" do
+  it "does not stop at or ignore null bytes" do
+    expect(Addressable::URI.parse("/path%00segment/").normalize.path).to eq(
+      "/path%00segment/"
+    )
+  end
+
+  it "does apply NFC unicode normalization" do
+    expect(Addressable::URI.parse("/%E2%84%A6").normalize.path).to eq(
+      "/%CE%A9"
+    )
+  end
+
+  it "does not apply NFKC unicode normalization" do
+    expect(Addressable::URI.parse("/%C2%AF%C2%A0").normalize.path).to eq(
+      "/%C2%AF%C2%A0"
+    )
+  end
+end
+
 describe Addressable::URI, "when normalizing a partially encoded string" do
   it "should result in correct percent encoded sequence" do
     expect(Addressable::URI.normalize_component(
@@ -5864,6 +6034,18 @@ describe Addressable::URI, "when normalizing a string but leaving some character
   end
 end
 
+describe Addressable::URI, "when encoding IP literals" do
+  it "should work for IPv4" do
+    input = "http://127.0.0.1/"
+    expect(Addressable::URI.encode(input)).to eq(input)
+  end
+
+  it "should work for IPv6" do
+    input = "http://[fe80::200:f8ff:fe21:67cf]/"
+    expect(Addressable::URI.encode(input)).to eq(input)
+  end
+end
+
 describe Addressable::URI, "when encoding a string with existing encodings to upcase" do
   it "should result in correct percent encoded sequence" do
     expect(Addressable::URI.encode_component("JK%4c", "0-9A-IKM-Za-z%", "L")).to eq("%4AK%4C")
@@ -5911,6 +6093,11 @@ describe Addressable::URI, "when unencoding a multibyte string" do
     expect(Addressable::URI.unencode_component("ski=%BA%DAɫ")).to eq("ski=\xBA\xDAɫ")
   end
 
+  it "should not fail with UTF-8 incompatible string" do
+    url = "/M%E9/\xE9?p=\xFC".b
+    expect(Addressable::URI.unencode_component(url)).to eq("/M\xE9/\xE9?p=\xFC")
+  end
+
   it "should result in correct percent encoded sequence as a URI" do
     expect(Addressable::URI.unencode(
       "/path?g%C3%BCnther", ::Addressable::URI
@@ -5936,41 +6123,41 @@ end
 
 describe Addressable::URI, "when unencoding a bogus object" do
   it "should raise a TypeError" do
-    expect(lambda do
+    expect do
       Addressable::URI.unencode_component(42)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise a TypeError" do
-    expect(lambda do
+    expect do
       Addressable::URI.unencode("/path?g%C3%BCnther", Integer)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
 describe Addressable::URI, "when encoding a bogus object" do
   it "should raise a TypeError" do
-    expect(lambda do
+    expect do
       Addressable::URI.encode(Object.new)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise a TypeError" do
-    expect(lambda do
+    expect do
       Addressable::URI.normalized_encode(Object.new)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise a TypeError" do
-    expect(lambda do
+    expect do
       Addressable::URI.encode_component("günther", Object.new)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise a TypeError" do
-    expect(lambda do
+    expect do
       Addressable::URI.encode_component(Object.new)
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 end
 
@@ -5986,9 +6173,9 @@ describe Addressable::URI, "when given the input " +
   end
 
   it "should not raise error when frozen" do
-    expect(lambda do
+    expect do
       Addressable::URI.heuristic_parse(@input).freeze.to_s
-    end).not_to raise_error
+    end.not_to raise_error
   end
 end
 
@@ -6352,6 +6539,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
@@ -6363,54 +6588,54 @@ describe Addressable::URI, "when assigning query values" do
   end
 
   it "should raise an error attempting to assign {'a' => {'b' => ['c']}}" do
-    expect(lambda do
+    expect do
       @uri.query_values = { 'a' => {'b' => ['c'] } }
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise an error attempting to assign " +
       "{:b => '2', :a => {:c => '1'}}" do
-    expect(lambda do
+    expect do
       @uri.query_values = {:b => '2', :a => {:c => '1'}}
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise an error attempting to assign " +
       "{:a => 'a', :b => [{:c => 'c', :d => 'd'}, " +
       "{:e => 'e', :f => 'f'}]}" do
-    expect(lambda do
+    expect do
       @uri.query_values = {
         :a => "a", :b => [{:c => "c", :d => "d"}, {:e => "e", :f => "f"}]
       }
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise an error attempting to assign " +
       "{:a => 'a', :b => [{:c => true, :d => 'd'}, " +
       "{:e => 'e', :f => 'f'}]}" do
-    expect(lambda do
+    expect do
       @uri.query_values = {
         :a => 'a', :b => [{:c => true, :d => 'd'}, {:e => 'e', :f => 'f'}]
       }
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise an error attempting to assign " +
       "{:a => 'a', :b => {:c => true, :d => 'd'}}" do
-    expect(lambda do
+    expect do
       @uri.query_values = {
         :a => 'a', :b => {:c => true, :d => 'd'}
       }
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should raise an error attempting to assign " +
       "{:a => 'a', :b => {:c => true, :d => 'd'}}" do
-    expect(lambda do
+    expect do
       @uri.query_values = {
         :a => 'a', :b => {:c => true, :d => 'd'}
       }
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should correctly assign {:a => 1, :b => 1.5}" do
@@ -6421,13 +6646,13 @@ describe Addressable::URI, "when assigning query values" do
   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
-    expect(lambda do
+    expect do
       @uri.query_values = {
         :z => 1,
         :f => [ 2, {999.1 => [3,'4']}, ['h', 'i'] ],
         :a => { :b => ['c', 'd'], :e => true, :y => 0.5 }
       }
-    end).to raise_error(TypeError)
+    end.to raise_error(TypeError)
   end
 
   it "should correctly assign {}" do
@@ -6477,7 +6702,7 @@ describe Addressable::URI, "when assigning path values" do
     @uri.path = "acct:bob@sporkmonger.com"
     expect(@uri.path).to eq("acct:bob@sporkmonger.com")
     expect(@uri.normalize.to_str).to eq("acct%2Fbob@sporkmonger.com")
-    expect(lambda { @uri.to_s }).to raise_error(
+    expect { @uri.to_s }.to raise_error(
       Addressable::URI::InvalidURIError
     )
   end
@@ -6495,26 +6720,26 @@ describe Addressable::URI, "when assigning path values" do
   end
 
   it "should not allow relative paths to be assigned on absolute URIs" do
-    expect(lambda do
+    expect do
       @uri.scheme = "http"
       @uri.host = "example.com"
       @uri.path = "acct:bob@sporkmonger.com"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should not allow relative paths to be assigned on absolute URIs" do
-    expect(lambda do
+    expect do
       @uri.path = "acct:bob@sporkmonger.com"
       @uri.scheme = "http"
       @uri.host = "example.com"
-    end).to raise_error(Addressable::URI::InvalidURIError)
+    end.to raise_error(Addressable::URI::InvalidURIError)
   end
 
   it "should not allow relative paths to be assigned on absolute URIs" do
-    expect(lambda do
+    expect do
       @uri.path = "uuid:0b3ecf60-3f93-11df-a9c3-001f5bfffe12"
       @uri.scheme = "urn"
-    end).not_to raise_error
+    end.not_to raise_error
   end
 end
 
@@ -6543,3 +6768,73 @@ describe Addressable::URI, "when initializing a subclass of Addressable::URI" do
     expect(@uri.class).to eq(@uri.join('path').class)
   end
 end
+
+describe Addressable::URI, "support serialization roundtrip" do
+  before do
+    @uri = Addressable::URI.new(
+      :scheme => "http",
+      :user => "user",
+      :password => "password",
+      :host => "example.com",
+      :port => 80,
+      :path => "/path",
+      :query => "query=value",
+      :fragment => "fragment"
+    )
+  end
+
+  it "is in a working state after being serialized with Marshal" do
+    @uri = Addressable::URI.parse("http://example.com")
+    cloned_uri = Marshal.load(Marshal.dump(@uri))
+    expect(cloned_uri.normalized_scheme).to be == @uri.normalized_scheme
+  end
+
+  it "is in a working state after being serialized with YAML" do
+    @uri = Addressable::URI.parse("http://example.com")
+    cloned_uri = if YAML.respond_to?(:unsafe_load)
+      YAML.unsafe_load(YAML.dump(@uri))
+    else
+      YAML.load(YAML.dump(@uri))
+    end
+    expect(cloned_uri.normalized_scheme).to be == @uri.normalized_scheme
+  end
+end
+
+describe Addressable::URI, "when initialized in a non-main `Ractor`" do
+  it "should have the same value as if used in the main `Ractor`" do
+    pending("Ruby 3.0+ for `Ractor` support") unless defined?(Ractor)
+    main = Addressable::URI.parse("http://example.com")
+    expect(
+      Ractor.new { Addressable::URI.parse("http://example.com") }.take
+    ).to eq(main)
+  end
+end
+
+describe Addressable::URI, "when deferring validation" do
+  subject(:deferred) { uri.instance_variable_get(:@validation_deferred) }
+
+  let(:uri) { Addressable::URI.parse("http://example.com") }
+
+  it "defers validation within the block" do
+    uri.defer_validation do
+      expect(deferred).to be true
+    end
+  end
+
+  it "always resets deferral afterward" do
+    expect { uri.defer_validation { raise "boom" } }.to raise_error("boom")
+    expect(deferred).to be false
+  end
+
+  it "returns nil" do
+    res = uri.defer_validation {}
+    expect(res).to be nil
+  end
+end
+
+describe Addressable::URI, "YAML safe loading" do
+  it "doesn't serialize anonymous objects" do
+    url = Addressable::URI.parse("http://example.com/")
+    expect(YAML.dump(url)).to_not include("!ruby/object {}")
+  end
+end