webmock 3.7.1

data/spec/unit/util/hash_counter_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe WebMock::Util::HashCounter do
+
+  it "should return 0 for non existing key" do
+    expect(WebMock::Util::HashCounter.new.get(:abc)).to eq(0)
+  end
+
+  it "should increase the returned value on every put with the same key" do
+    counter = WebMock::Util::HashCounter.new
+    counter.put(:abc)
+    expect(counter.get(:abc)).to eq(1)
+    counter.put(:abc)
+    expect(counter.get(:abc)).to eq(2)
+  end
+
+  it "should only increase value for given key provided to put" do
+    counter = WebMock::Util::HashCounter.new
+    counter.put(:abc)
+    expect(counter.get(:abc)).to eq(1)
+    expect(counter.get(:def)).to eq(0)
+  end
+
+  describe "each" do
+    it "should provide elements in order of the last modified" do
+      counter = WebMock::Util::HashCounter.new
+      counter.put(:a)
+      counter.put(:b)
+      counter.put(:c)
+      counter.put(:b)
+      counter.put(:a)
+      counter.put(:d)
+
+      elements = []
+      counter.each {|k,v| elements << [k,v]}
+      expect(elements).to eq([[:c, 1], [:b, 2], [:a, 2], [:d, 1]])
+    end
+  end
+end

data/spec/unit/util/hash_keys_stringifier_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe WebMock::Util::HashKeysStringifier do
+
+  it "should recursively stringify all symbol keys" do
+    hash = {
+      a: {
+        b: [
+          {
+            c: [{d: "1"}]
+          }
+        ]
+      }
+    }
+    stringified = {
+      'a' => {
+        'b' => [
+          {
+            'c' => [{'d' => "1"}]
+          }
+        ]
+      }
+    }
+    expect(WebMock::Util::HashKeysStringifier.stringify_keys!(hash, deep: true)).to eq(stringified)
+  end
+
+end

data/spec/unit/util/headers_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe WebMock::Util::Headers do
+
+  it "should decode_userinfo_from_header handles basic auth" do
+    authorization_header = "Basic dXNlcm5hbWU6c2VjcmV0"
+    userinfo = WebMock::Util::Headers.decode_userinfo_from_header(authorization_header)
+    expect(userinfo).to eq("username:secret")
+  end
+
+  describe "sorted_headers_string" do
+
+    it "should return nice string for hash with string values" do
+      expect(WebMock::Util::Headers.sorted_headers_string({"a" => "b"})).to eq("{'A'=>'b'}")
+    end
+
+    it "should return nice string for hash with array values" do
+      expect(WebMock::Util::Headers.sorted_headers_string({"a" => ["b", "c"]})).to eq("{'A'=>['b', 'c']}")
+    end
+
+    it "should return nice string for hash with array values and string values" do
+      expect(WebMock::Util::Headers.sorted_headers_string({"a" => ["b", "c"], "d" => "e"})).to eq("{'A'=>['b', 'c'], 'D'=>'e'}")
+    end
+
+
+  end
+
+end

data/spec/unit/util/json_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe WebMock::Util::JSON do
+  describe ".parse" do
+    it "should parse json without parsing dates" do
+      expect(WebMock::Util::JSON.parse("\"a\":\"2011-01-01\"")).to eq(
+        {"a" => "2011-01-01"}
+      )
+    end
+
+    it "can parse json with multibyte characters" do
+      expect(WebMock::Util::JSON.parse(
+        "{\"name\":\"山田太郎\"\,\"job\":\"会社員\"}"
+      )).to eq({"name" => "山田太郎", "job" => "会社員"})
+    end
+
+    it "rescues ArgumentError's from YAML.load" do
+      allow(YAML).to receive(:load).and_raise(ArgumentError)
+      expect {
+        WebMock::Util::JSON.parse("Bad JSON")
+      }.to raise_error WebMock::Util::JSON::ParseError
+    end
+  end
+
+  describe ".convert_json_to_yaml" do
+    it "parses multibyte characters" do
+      expect(WebMock::Util::JSON.convert_json_to_yaml(
+        "{\"name\":\"山田太郎\"\,\"job\":\"会社員\"}"
+      )).to eq "{\"name\": \"山田太郎\", \"job\": \"会社員\"}"
+    end
+  end
+end

data/spec/unit/util/query_mapper_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe WebMock::Util::QueryMapper do
+  subject { described_class }
+
+  context '#query_to_values' do
+    it 'should raise on invalid notation' do
+      query = 'a=&b=c'
+      expect { subject.query_to_values(query, {notation: 'foo'}) }.to raise_error(
+        ArgumentError,
+        'Invalid notation. Must be one of: [:flat, :dot, :subscript, :flat_array].'
+      )
+    end
+
+    it 'should parse hash queries' do
+      # {"one" => {"two" => {"three" => ["four", "five"]}}}
+      query = 'one%5Btwo%5D%5Bthree%5D%5B%5D=four&one%5Btwo%5D%5Bthree%5D%5B%5D=five'
+      hsh = subject.query_to_values(query)
+      expect(hsh['one']['two']['three']).to eq(%w(four five))
+    end
+
+    it 'should parse one nil value queries' do
+      # {'a' => nil, 'b' => 'c'}
+      query = 'a=&b=c'
+      hsh = subject.query_to_values(query)
+      expect(hsh['a']).to be_empty
+      expect(hsh['b']).to eq('c')
+    end
+
+    it 'should parse array queries' do
+      # {"one" => ["foo", "bar"]}
+      query = 'one%5B%5D=foo&one%5B%5D=bar'
+      hsh = subject.query_to_values(query)
+      expect(hsh['one']).to eq(%w(foo bar))
+    end
+
+    it 'should parse string queries' do
+      # {"one" => "two", "three" => "four"}
+      query = 'one=two&three=four'
+      hsh = subject.query_to_values(query)
+      expect(hsh).to  eq({'one' => 'two', 'three' => 'four'})
+    end
+
+    it 'should parse nested queries' do
+      # [{"b"=>[{"c"=>[{"d"=>["1", {"e"=>"2"}]}]}]}]
+      query = 'a%5B%5D%5Bb%5D%5B%5D%5Bc%5D%5B%5D%5Bd%5D%5B%5D=1&a%5B%5D%5Bb%5D%5B%5D%5Bc%5D%5B%5D%5Bd%5D%5B%5D%5Be%5D=2'
+      hsh = subject.query_to_values(query)
+      expect(hsh['a'][0]['b'][0]['c'][0]['d'][0]).to eq('1')
+      expect(hsh['a'][0]['b'][0]['c'][0]['d'][1]['e']).to eq('2')
+    end
+
+    it "should parse nested repeated correctly" do
+      query = "a[][b][]=one&a[][b][]=two"
+      hsh = subject.query_to_values(query)
+      expect(hsh['a']).to be_a(Array)
+      expect(hsh['a'][0]).to eq({"b" => ['one']})
+      expect(hsh['a'][1]).to eq({"b" => ['two']})
+    end
+
+    it "should parse nested non-repeated correctly" do
+      query = "a[][b][]=one&a[][c][]=two"
+      hsh = subject.query_to_values(query)
+      expect(hsh['a']).to be_a(Array)
+      expect(hsh['a'][0]['b']).to eq(['one'])
+      expect(hsh['a'][0]['c']).to eq(['two'])
+    end
+
+    it 'should not attempt to mutate its query argument' do
+      query = "a=foo".freeze
+      hsh = subject.query_to_values(query)
+      expect(hsh['a']).to eq('foo')
+    end
+
+    it "should parse hash query with key starting with non word character" do
+      query = "a[$in]=1".freeze
+      hsh = subject.query_to_values(query)
+      expect(hsh).to eql({'a' => {'$in' => '1'}})
+    end
+  end
+
+  context '#to_query' do
+    it 'should transform nil value' do
+      expect(subject.to_query('a', nil)).to eq('a')
+    end
+    it 'should transform string value' do
+      expect(subject.to_query('a', 'b')).to eq('a=b')
+    end
+    it 'should transform hash value' do
+      expect(subject.to_query('a', {'key' => 'value'})).to eq('a[key]=value')
+    end
+    it 'should transform hash value with keys that are symbols' do
+      expect(subject.to_query('a', {key: 'value'})).to eq('a[key]=value')
+    end
+    it 'should transform array value' do
+      expect(subject.to_query('a', ['b', 'c'])).to eq('a[0]=b&a[1]=c')
+    end
+    it 'should transform boolean values' do
+      expect(subject.to_query('a', true)).to eq('a=true')
+      expect(subject.to_query('a', false)).to eq('a=false')
+    end
+  end
+
+  context '#values_to_query' do
+    it 'converts values to a query string' do
+      query = "key=value&other_key=other_value"
+      values = [['key','value'],['other_key','other_value']]
+      expect(subject.values_to_query values).to eq query
+    end
+
+    it 'converts values with missing keys to a query string' do
+      query = "=value"
+      values = { '' => 'value' }
+      expect(subject.values_to_query values).to eq query
+    end
+
+    it 'converts values with nil keys to a query string' do
+      query = "=value"
+      values = { nil => 'value' }
+      expect(subject.values_to_query values).to eq query
+    end
+  end
+
+  it 'converts array values, vice versa' do
+    query = "one%5B%5D=1&one%5B%5D=2" # one[]=1&one[]=2
+    values = {"one" => ["1","2"]}
+    expect(subject.values_to_query values).to eq query
+    expect(subject.query_to_values query).to eq values
+  end
+
+  it 'converts hash values, vice versa' do
+    query = "one%5Ba%5D=1&one%5Bb%5D=2" # one[a]=1&one[b]=2
+    values = {"one" => {"a" => "1", "b" => "2"}}
+    expect(subject.values_to_query values).to eq query
+    expect(subject.query_to_values query).to eq values
+  end
+
+  it 'converts complex nested hashes, vice versa' do
+    query = "one%5B%5D[foo]=bar&one%5B%5D[zoo]=car" # one[][foo]=bar&one[][zoo]=car
+    values = {"one" => [{"foo" => "bar", "zoo" => "car"}]}
+    expect(subject.values_to_query values).to eq query
+    expect(subject.query_to_values query).to eq values
+  end
+
+  it 'converts complex nested array of hashes, vice versa' do
+    query = "one%5B%5D[foo]=bar&one%5B%5D[foo]=bar&one%5B%5D[zoo]=car" # one[][foo]=bar&one[][foo]=bar&one[][zoo]=car
+    values = {"one" => [{"foo" => "bar"}, {"foo" => "bar", "zoo" => "car"}]}
+    expect(subject.values_to_query values).to eq query
+    expect(subject.query_to_values query).to eq values
+  end
+
+  it 'converts an empty array to ?' do
+    query = "one%5B%5D"
+    values = {"one" => []}
+    expect(subject.values_to_query values).to eq query
+    expect(subject.query_to_values query).to eq values
+  end
+end

data/spec/unit/util/uri_spec.rb

@@ -0,0 +1,361 @@
+require 'spec_helper'
+
+URIS_WITHOUT_PATH_OR_PARAMS =
+[
+  "www.example.com",
+  "www.example.com/",
+  "www.example.com:80",
+  "www.example.com:80/",
+  "http://www.example.com",
+  "http://www.example.com/",
+  "http://www.example.com:80",
+  "http://www.example.com:80/"
+].sort
+
+URIS_WITHOUT_PATH_BUT_WITH_PARAMS =
+[
+  "www.example.com?a=b",
+  "www.example.com/?a=b",
+  "www.example.com:80?a=b",
+  "www.example.com:80/?a=b",
+  "http://www.example.com?a=b",
+  "http://www.example.com/?a=b",
+  "http://www.example.com:80?a=b",
+  "http://www.example.com:80/?a=b"
+].sort
+
+URIS_WITH_AUTH =
+[
+  "a b:pass@www.example.com",
+  "a b:pass@www.example.com/",
+  "a b:pass@www.example.com:80",
+  "a b:pass@www.example.com:80/",
+  "http://a b:pass@www.example.com",
+  "http://a b:pass@www.example.com/",
+  "http://a b:pass@www.example.com:80",
+  "http://a b:pass@www.example.com:80/",
+  "a%20b:pass@www.example.com",
+  "a%20b:pass@www.example.com/",
+  "a%20b:pass@www.example.com:80",
+  "a%20b:pass@www.example.com:80/",
+  "http://a%20b:pass@www.example.com",
+  "http://a%20b:pass@www.example.com/",
+  "http://a%20b:pass@www.example.com:80",
+  "http://a%20b:pass@www.example.com:80/"
+].sort
+
+URIS_WITH_PATH_AND_PARAMS =
+[
+  "www.example.com/my path/?a=my param&b=c d",
+  "www.example.com/my%20path/?a=my%20param&b=c%20d",
+  "www.example.com:80/my path/?a=my param&b=c d",
+  "www.example.com:80/my%20path/?a=my%20param&b=c%20d",
+  "http://www.example.com/my path/?a=my param&b=c d",
+  "http://www.example.com/my%20path/?a=my%20param&b=c%20d",
+  "http://www.example.com:80/my path/?a=my param&b=c d",
+  "http://www.example.com:80/my%20path/?a=my%20param&b=c%20d",
+  ].sort
+
+URIS_WITH_DIFFERENT_PORT =
+[
+  "www.example.com:88",
+  "www.example.com:88/",
+  "http://www.example.com:88",
+  "http://www.example.com:88/"
+].sort
+
+URIS_FOR_HTTPS =
+[
+  "https://www.example.com",
+  "https://www.example.com/",
+  "https://www.example.com:443",
+  "https://www.example.com:443/"
+].sort
+
+URIS_FOR_LOCALHOST =
+[
+  "localhost",
+  "localhost/",
+  "localhost:80",
+  "localhost:80/",
+  "http://localhost",
+  "http://localhost/",
+  "http://localhost:80",
+  "http://localhost:80/"
+].sort
+
+URIS_WITH_SCHEME =
+[
+  "http://www.example.com",
+  "http://www.example.com/",
+  "http://www.example.com:80",
+  "http://www.example.com:80/"
+].sort
+
+URIS_WITH_COLON_IN_PATH =
+[
+  [
+    "https://example.com/a/b:80",
+    "https://example.com:443/a/b:80",
+  ].sort,
+  [
+    "https://example.com:443/a/b:443",
+    "https://example.com/a/b:443",
+  ].sort,
+  [
+    "http://example.com/a/b:443",
+    "example.com/a/b:443",
+    "http://example.com:80/a/b:443",
+    "example.com:80/a/b:443",
+  ].sort,
+  [
+    "http://example.com/a/b:80",
+    "example.com/a/b:80",
+    "http://example.com:80/a/b:80",
+    "example.com:80/a/b:80",
+  ].sort
+]
+
+describe WebMock::Util::URI do
+
+  describe "reporting variations of uri" do
+
+    it "should find all variations of the same uri for all variations of uri with params and path" do
+      URIS_WITH_PATH_AND_PARAMS.each do |uri|
+        expect(WebMock::Util::URI.variations_of_uri_as_strings(uri).sort).to eq(URIS_WITH_PATH_AND_PARAMS)
+      end
+    end
+
+    it "should find all variations of the same uri for all variations of uri with params but without path" do
+      URIS_WITHOUT_PATH_BUT_WITH_PARAMS.each do |uri|
+        expect(WebMock::Util::URI.variations_of_uri_as_strings(uri).sort).to eq(URIS_WITHOUT_PATH_BUT_WITH_PARAMS)
+      end
+    end
+
+    it "should find all variations of the same uri for all variations of uri without params or path" do
+      URIS_WITHOUT_PATH_OR_PARAMS.each do |uri|
+        expect(WebMock::Util::URI.variations_of_uri_as_strings(uri).sort).to eq(URIS_WITHOUT_PATH_OR_PARAMS)
+      end
+    end
+
+    it "should find all variations of the same uri for all variations of uri with auth" do
+      URIS_WITH_AUTH.each do |uri|
+        expect(WebMock::Util::URI.variations_of_uri_as_strings(uri).sort).to eq(URIS_WITH_AUTH)
+      end
+    end
+
+    it "should find all variations of the same uri for all variations of uri with different port" do
+      URIS_WITH_DIFFERENT_PORT.each do |uri|
+        expect(WebMock::Util::URI.variations_of_uri_as_strings(uri).sort).to eq(URIS_WITH_DIFFERENT_PORT)
+      end
+    end
+
+    it "should find all variations of the same uri for all variations of https uris" do
+      URIS_FOR_HTTPS.each do |uri|
+        expect(WebMock::Util::URI.variations_of_uri_as_strings(uri).sort).to eq(URIS_FOR_HTTPS)
+      end
+    end
+
+    it "should find all variations of the same uri for all variations of host names uris without a period" do
+      URIS_FOR_LOCALHOST.each do |uri|
+        expect(WebMock::Util::URI.variations_of_uri_as_strings(uri).sort).to eq(URIS_FOR_LOCALHOST)
+      end
+    end
+
+    it "should find all variations of the same uri with scheme for all variations when only_with_scheme is true" do
+      URIS_WITHOUT_PATH_OR_PARAMS.each do |uri|
+        variations_of_uri_with_scheme = WebMock::Util::URI.variations_of_uri_as_strings(uri, only_with_scheme: true)
+        expect(variations_of_uri_with_scheme.sort).to eq(URIS_WITH_SCHEME)
+      end
+    end
+
+    it "should not replace :80 or :443 in path" do
+      URIS_WITH_COLON_IN_PATH.each do |uris|
+        uris.each do |uri|
+          expect(WebMock::Util::URI.variations_of_uri_as_strings(uri).sort).to eq(uris)
+        end
+      end
+    end
+
+  end
+
+  describe "normalized uri equality" do
+
+    it "should successfully compare all variations of the same uri with path and params" do
+      URIS_WITH_PATH_AND_PARAMS.each do |uri_a|
+        URIS_WITH_PATH_AND_PARAMS.each do |uri_b|
+          expect(WebMock::Util::URI.normalize_uri(uri_a)).to be ===  WebMock::Util::URI.normalize_uri(uri_b)
+        end
+      end
+    end
+
+    it "should successfully compare all variations of the same uri with path but with params" do
+      URIS_WITHOUT_PATH_BUT_WITH_PARAMS.each do |uri_a|
+        URIS_WITHOUT_PATH_BUT_WITH_PARAMS.each do |uri_b|
+          expect(WebMock::Util::URI.normalize_uri(uri_a)).to be ===  WebMock::Util::URI.normalize_uri(uri_b)
+        end
+      end
+    end
+
+    it "should successfully compare all variations of the same uri without path or params" do
+      URIS_WITHOUT_PATH_OR_PARAMS.each do |uri_a|
+        URIS_WITHOUT_PATH_OR_PARAMS.each do |uri_b|
+          expect(WebMock::Util::URI.normalize_uri(uri_a)).to be ===  WebMock::Util::URI.normalize_uri(uri_b)
+        end
+      end
+    end
+
+    it "should successfully compare all variations of the same uri with authority" do
+      URIS_WITH_AUTH.each do |uri_a|
+        URIS_WITH_AUTH.each do |uri_b|
+          expect(WebMock::Util::URI.normalize_uri(uri_a)).to be ===  WebMock::Util::URI.normalize_uri(uri_b)
+        end
+      end
+    end
+
+    it "should successfully compare all variations of the same uri custom port" do
+      URIS_WITH_DIFFERENT_PORT.each do |uri_a|
+        URIS_WITH_DIFFERENT_PORT.each do |uri_b|
+          expect(WebMock::Util::URI.normalize_uri(uri_a)).to be ===  WebMock::Util::URI.normalize_uri(uri_b)
+        end
+      end
+    end
+
+    it "should successfully compare all variations of the same https uri" do
+      URIS_FOR_HTTPS.each do |uri_a|
+        URIS_FOR_HTTPS.each do |uri_b|
+          expect(WebMock::Util::URI.normalize_uri(uri_a)).to be ===  WebMock::Util::URI.normalize_uri(uri_b)
+        end
+      end
+    end
+
+    it "should successfully handle array parameters" do
+      uri_string = 'http://www.example.com:80/path?a[]=b&a[]=c'
+      uri = WebMock::Util::URI.normalize_uri(uri_string)
+      expect(WebMock::Util::QueryMapper.query_to_values(uri.query)).to eq({"a"=>["b", "c"]})
+    end
+
+    it "should successfully handle hash parameters" do
+      uri_string = 'http://www.example.com:80/path?a[d]=b&a[e]=c&a[b][c]=1'
+      uri = WebMock::Util::URI.normalize_uri(uri_string)
+      expect(WebMock::Util::QueryMapper.query_to_values(uri.query)).to eq({"a"=>{"d"=>"b", "e"=>"c", "b"=>{"c"=>"1"}}})
+    end
+
+    it "should successfully handle nested hash parameters" do
+      uri_string = 'http://www.example.com:80/path?one[two][three][]=four&one[two][three][]=five'
+      uri = WebMock::Util::URI.normalize_uri(uri_string)
+      expect(WebMock::Util::QueryMapper.query_to_values(uri.query)).to eq({"one"=>{"two"=>{"three" => ["four", "five"]}}})
+    end
+
+    it "should successfully handle mixed array and hash parameters" do
+      # derived from an elasticsearch query:
+      # load => {
+      #   :include => [
+      #     { :staff => :email },
+      #     :business_name
+      #   ]
+      # }
+      uri_string = "http://www.example.com:80/path?load[include][][staff]=email&load[include][]=business_name"
+      uri = WebMock::Util::URI.normalize_uri(uri_string)
+      expect(WebMock::Util::QueryMapper.query_to_values(uri.query)).to eq({"load"=>{"include"=>[{"staff"=>"email"},"business_name"]}})
+    end
+
+    context "when query notation is set to :flat_array" do
+      before :all do
+        WebMock::Config.instance.query_values_notation = :flat_array
+      end
+
+      it "should successfully handle repeated paramters" do
+        uri_string = "http://www.example.com:80/path?target=host1&target=host2"
+        uri = WebMock::Util::URI.normalize_uri(uri_string)
+        expect(WebMock::Util::QueryMapper.query_to_values(uri.query, notation: WebMock::Config.instance.query_values_notation)).to eq([['target', 'host1'], ['target', 'host2']])
+      end
+    end
+  end
+
+  describe "sorting query values" do
+
+    context "when query values is a Hash" do
+      it "returns an alphabetically sorted hash" do
+        sorted_query = WebMock::Util::URI.sort_query_values({"b"=>"one", "a"=>"two"})
+        expect(sorted_query).to eq({"a"=>"two", "b"=>"one"})
+      end
+    end
+
+    context "when query values is an Array" do
+      it "returns an alphabetically sorted array" do
+        sorted_query = WebMock::Util::URI.sort_query_values([["b","two"],["a","one_b"],["a","one_a"]])
+        expect(sorted_query).to eq([["a","one_a"],["a","one_b"],["b","two"]])
+      end
+    end
+  end
+
+  describe "stripping default port" do
+
+    it "should strip_default_port_from_uri strips 80 from http with path" do
+      uri = "http://example.com:80/foo/bar"
+      stripped_uri = WebMock::Util::URI.strip_default_port_from_uri_string(uri)
+      expect(stripped_uri).to eq("http://example.com/foo/bar")
+    end
+
+    it "should strip_default_port_from_uri strips 80 from http without path" do
+      uri = "http://example.com:80"
+      stripped_uri = WebMock::Util::URI.strip_default_port_from_uri_string(uri)
+      expect(stripped_uri).to eq("http://example.com")
+    end
+
+    it "should strip_default_port_from_uri strips 443 from https without path" do
+      uri = "https://example.com:443"
+      stripped_uri = WebMock::Util::URI.strip_default_port_from_uri_string(uri)
+      expect(stripped_uri).to eq("https://example.com")
+    end
+
+    it "should strip_default_port_from_uri strips 443 from https" do
+      uri = "https://example.com:443/foo/bar"
+      stripped_uri = WebMock::Util::URI.strip_default_port_from_uri_string(uri)
+      expect(stripped_uri).to eq("https://example.com/foo/bar")
+    end
+
+    it "should strip_default_port_from_uri does not strip 8080 from http" do
+      uri = "http://example.com:8080/foo/bar"
+      expect(WebMock::Util::URI.strip_default_port_from_uri_string(uri)).to eq(uri)
+    end
+
+    it "should strip_default_port_from_uri does not strip 443 from http" do
+      uri = "http://example.com:443/foo/bar"
+      expect(WebMock::Util::URI.strip_default_port_from_uri_string(uri)).to eq(uri)
+    end
+
+    it "should strip_default_port_from_uri does not strip 80 from query string" do
+      uri = "http://example.com/?a=:80&b=c"
+      expect(WebMock::Util::URI.strip_default_port_from_uri_string(uri)).to eq(uri)
+    end
+
+    it "should strip_default_port_from_uri does not modify strings that do not start with http or https" do
+      uri = "httpz://example.com:80/"
+      expect(WebMock::Util::URI.strip_default_port_from_uri_string(uri)).to eq(uri)
+    end
+
+  end
+
+
+  describe "encoding userinfo" do
+
+    it "should encode unsafe chars in userinfo does not encode userinfo safe punctuation" do
+      userinfo = "user;&=+$,:secret"
+      expect(WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)).to eq(userinfo)
+    end
+
+    it "should encode unsafe chars in userinfo does not encode rfc 3986 unreserved characters" do
+      userinfo = "-.!~*'()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:secret"
+      expect(WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)).to eq(userinfo)
+    end
+
+    it "should encode unsafe chars in userinfo does encode other characters" do
+      userinfo, safe_userinfo = 'us#rn@me:sec//ret?"', 'us%23rn%40me:sec%2F%2Fret%3F%22'
+      expect(WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)).to eq(safe_userinfo)
+    end
+
+  end
+
+end