webmock 1.8.6 → 3.14.0

data/spec/unit/util/hash_keys_stringifier_spec.rb

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

data/spec/unit/util/headers_spec.rb

@@ -5,21 +5,21 @@ 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)
-    userinfo.should == "username:secret"
+    expect(userinfo).to eq("username:secret")
   end
 
   describe "sorted_headers_string" do
 
     it "should return nice string for hash with string values" do
-      WebMock::Util::Headers.sorted_headers_string({"a" => "b"}).should == "{'A'=>'b'}"
+      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
-      WebMock::Util::Headers.sorted_headers_string({"a" => ["b", "c"]}).should == "{'A'=>['b', 'c']}"
+      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
-      WebMock::Util::Headers.sorted_headers_string({"a" => ["b", "c"], "d" => "e"}).should == "{'A'=>['b', 'c'], 'D'=>'e'}"
+      expect(WebMock::Util::Headers.sorted_headers_string({"a" => ["b", "c"], "d" => "e"})).to eq("{'A'=>['b', 'c'], 'D'=>'e'}")
     end
 
 

data/spec/unit/util/json_spec.rb

@@ -1,7 +1,33 @@
+# encoding: utf-8
 require 'spec_helper'
 
 describe WebMock::Util::JSON do
-  it "should parse json without parsing dates" do
-    WebMock::Util::JSON.parse("\"a\":\"2011-01-01\"").should == {"a" => "2011-01-01"}
+  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
+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

@@ -1,6 +1,5 @@
 require 'spec_helper'
 
-
 URIS_WITHOUT_PATH_OR_PARAMS =
 [
   "www.example.com",
@@ -47,14 +46,14 @@ URIS_WITH_AUTH =
 
 URIS_WITH_PATH_AND_PARAMS =
 [
-  "www.example.com/my path/?a=my param&b=c",
-  "www.example.com/my%20path/?a=my%20param&b=c",
-  "www.example.com:80/my path/?a=my param&b=c",
-  "www.example.com:80/my%20path/?a=my%20param&b=c",
-  "http://www.example.com/my path/?a=my param&b=c",
-  "http://www.example.com/my%20path/?a=my%20param&b=c",
-  "http://www.example.com:80/my path/?a=my param&b=c",
-  "http://www.example.com:80/my%20path/?a=my%20param&b=c",
+  "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 =
@@ -65,7 +64,6 @@ URIS_WITH_DIFFERENT_PORT =
   "http://www.example.com:88/"
 ].sort
 
-
 URIS_FOR_HTTPS =
 [
   "https://www.example.com",
@@ -74,6 +72,49 @@ URIS_FOR_HTTPS =
   "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
 
@@ -81,40 +122,71 @@ describe WebMock::Util::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|
-        WebMock::Util::URI.variations_of_uri_as_strings(uri).sort.should == URIS_WITH_PATH_AND_PARAMS
+        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|
-        WebMock::Util::URI.variations_of_uri_as_strings(uri).sort.should == URIS_WITHOUT_PATH_BUT_WITH_PARAMS
+        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|
-        WebMock::Util::URI.variations_of_uri_as_strings(uri).sort.should == URIS_WITHOUT_PATH_OR_PARAMS
+        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|
-        WebMock::Util::URI.variations_of_uri_as_strings(uri).sort.should == URIS_WITH_AUTH
+        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|
-        WebMock::Util::URI.variations_of_uri_as_strings(uri).sort.should == URIS_WITH_DIFFERENT_PORT
+        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|
-        WebMock::Util::URI.variations_of_uri_as_strings(uri).sort.should == URIS_FOR_HTTPS
+        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
 
+    it "should find all variations of uris with https, basic auth, a non-standard port and a path" do
+      uri = "https://~%8A:pass@www.example.com:9000/foo"
+      variations = [
+        "https://~%8A:pass@www.example.com:9000/foo",
+        "https://~\x8A:pass@www.example.com:9000/foo".force_encoding(Encoding::ASCII_8BIT)
+      ]
+
+      expect(WebMock::Util::URI.variations_of_uri_as_strings(uri)).to eq(variations)
+    end
+
   end
 
   describe "normalized uri equality" do
@@ -122,7 +194,7 @@ describe WebMock::Util::URI 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|
-          WebMock::Util::URI.normalize_uri(uri_a).should ===  WebMock::Util::URI.normalize_uri(uri_b)
+          expect(WebMock::Util::URI.normalize_uri(uri_a)).to be ===  WebMock::Util::URI.normalize_uri(uri_b)
         end
       end
     end
@@ -130,7 +202,7 @@ describe WebMock::Util::URI do
     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|
-          WebMock::Util::URI.normalize_uri(uri_a).should ===  WebMock::Util::URI.normalize_uri(uri_b)
+          expect(WebMock::Util::URI.normalize_uri(uri_a)).to be ===  WebMock::Util::URI.normalize_uri(uri_b)
         end
       end
     end
@@ -138,7 +210,7 @@ describe WebMock::Util::URI do
     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|
-          WebMock::Util::URI.normalize_uri(uri_a).should ===  WebMock::Util::URI.normalize_uri(uri_b)
+          expect(WebMock::Util::URI.normalize_uri(uri_a)).to be ===  WebMock::Util::URI.normalize_uri(uri_b)
         end
       end
     end
@@ -146,7 +218,7 @@ describe WebMock::Util::URI do
     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|
-          WebMock::Util::URI.normalize_uri(uri_a).should ===  WebMock::Util::URI.normalize_uri(uri_b)
+          expect(WebMock::Util::URI.normalize_uri(uri_a)).to be ===  WebMock::Util::URI.normalize_uri(uri_b)
         end
       end
     end
@@ -154,7 +226,7 @@ describe WebMock::Util::URI do
     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|
-          WebMock::Util::URI.normalize_uri(uri_a).should ===  WebMock::Util::URI.normalize_uri(uri_b)
+          expect(WebMock::Util::URI.normalize_uri(uri_a)).to be ===  WebMock::Util::URI.normalize_uri(uri_b)
         end
       end
     end
@@ -162,7 +234,7 @@ describe WebMock::Util::URI do
     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|
-          WebMock::Util::URI.normalize_uri(uri_a).should ===  WebMock::Util::URI.normalize_uri(uri_b)
+          expect(WebMock::Util::URI.normalize_uri(uri_a)).to be ===  WebMock::Util::URI.normalize_uri(uri_b)
         end
       end
     end
@@ -170,19 +242,61 @@ describe WebMock::Util::URI do
     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)
-      uri.query_values.should == {"a"=>["b", "c"]}
+      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)
-      uri.query_values.should == {"a"=>{"d"=>"b", "e"=>"c", "b"=>{"c"=>"1"}}}
+      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)
-      uri.query_values.should == {"one"=>{"two"=>{"three" => ["four", "five"]}}}
+      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
 
@@ -191,45 +305,45 @@ describe WebMock::Util::URI 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)
-      stripped_uri.should ==  "http://example.com/foo/bar"
+      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)
-      stripped_uri.should ==  "http://example.com"
+      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)
-      stripped_uri.should ==  "https://example.com"
+      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)
-      stripped_uri.should == "https://example.com/foo/bar"
+      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"
-      WebMock::Util::URI.strip_default_port_from_uri_string(uri).should == uri
+      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"
-      WebMock::Util::URI.strip_default_port_from_uri_string(uri).should == uri
+      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"
-      WebMock::Util::URI.strip_default_port_from_uri_string(uri).should == uri
+      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/"
-      WebMock::Util::URI.strip_default_port_from_uri_string(uri).should == uri
+      expect(WebMock::Util::URI.strip_default_port_from_uri_string(uri)).to eq(uri)
     end
 
   end
@@ -239,17 +353,17 @@ describe WebMock::Util::URI do
 
     it "should encode unsafe chars in userinfo does not encode userinfo safe punctuation" do
       userinfo = "user;&=+$,:secret"
-      WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo).should == userinfo
+      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"
-      WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo).should == userinfo
+      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'
-      WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo).should == safe_userinfo
+      expect(WebMock::Util::URI.encode_unsafe_chars_in_userinfo(userinfo)).to eq(safe_userinfo)
     end
 
   end