webmock 3.14.0 → 3.24.0

data/spec/unit/util/query_mapper_spec.rb

@@ -1,157 +0,0 @@
-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,371 +0,0 @@
-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
-
-    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
-
-    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

data/spec/unit/util/version_checker_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-module WebMock
-  describe VersionChecker do
-    it 'prints a warning if the major version is too low' do
-      checker = VersionChecker.new('foo', '0.7.3', '1.0.0', '1.1')
-      expect(Kernel).to receive(:warn).with("\e[31mYou are using foo 0.7.3. WebMock supports version >= 1.0.0, < 1.2.\e[0m")
-      checker.check_version!
-    end
-
-    it 'prints a warning if the minor version is too low' do
-      checker = VersionChecker.new('foo', '1.0.99', '1.1.3', '1.2')
-      expect(Kernel).to receive(:warn).with("\e[31mYou are using foo 1.0.99. WebMock supports version >= 1.1.3, < 1.3.\e[0m")
-      checker.check_version!
-    end
-
-    it 'prints a warning if the patch version is too low' do
-      checker = VersionChecker.new('foo', '1.0.8', '1.0.10', '1.2')
-      expect(Kernel).to receive(:warn).with("\e[31mYou are using foo 1.0.8. WebMock supports version >= 1.0.10, < 1.3.\e[0m")
-      checker.check_version!
-    end
-
-    it 'prints a warning if the patch version is too low and max version is not specified' do
-      checker = VersionChecker.new('foo', '1.0.8', '1.0.10')
-      expect(Kernel).to receive(:warn).with("\e[31mYou are using foo 1.0.8. WebMock supports version >= 1.0.10.\e[0m")
-      checker.check_version!
-    end
-
-    it 'prints a warning if the major version is too high' do
-      checker = VersionChecker.new('foo', '2.0.0', '1.0.0', '1.1')
-      expect(Kernel).to receive(:warn).with(/may not work with this version/)
-      checker.check_version!
-    end
-
-    it 'prints a warning if the minor version is too high' do
-      checker = VersionChecker.new('foo', '1.2.0', '1.0.0', '1.1')
-      expect(Kernel).to receive(:warn).with(/may not work with this version/)
-      checker.check_version!
-    end
-
-    it 'does not raise an error or print a warning when the major version is between the min and max' do
-      checker = VersionChecker.new('foo', '2.0.0', '1.0.0', '3.0')
-      expect(Kernel).not_to receive(:warn)
-      checker.check_version!
-    end
-
-    it 'does not raise an error or print a warning when the min_patch is 0.6.5, the max_minor is 0.7 and the version is 0.7.3' do
-      checker = VersionChecker.new('foo', '0.7.3', '0.6.5', '0.7')
-      expect(Kernel).not_to receive(:warn)
-      checker.check_version!
-    end
-
-    it 'does not raise an error or print a warning when the min_patch is 0.6.5, the max_minor is not specified and the version is 0.8.3' do
-      checker = VersionChecker.new('foo', '0.8.3', '0.6.5')
-      expect(Kernel).not_to receive(:warn)
-      checker.check_version!
-    end
-
-    it "prints warning if version is unsupported" do
-      checker = VersionChecker.new('foo', '2.0.0', '1.0.0', '3.0', ['2.0.0'])
-      expect(Kernel).to receive(:warn).with(%r{You are using foo 2.0.0. WebMock does not support this version. WebMock supports versions >= 1.0.0, < 3.1, except versions 2.0.0.})
-      checker.check_version!
-    end
-  end
-end

data/spec/unit/webmock_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe "WebMock" do
-
-  describe ".version" do
-    it "should report version" do
-      expect(WebMock.version).to eq(WebMock::VERSION)
-    end
-
-    it "should not require safe_yaml" do
-      expect(defined?SafeYAML).to eq(nil)
-    end
-
-    it "should alias enable_net_connect! to allow_net_connect!" do
-      expect(WebMock.method(:enable_net_connect!)).to eq(WebMock.method(:allow_net_connect!))
-    end
-
-    it "should alias disallow_net_connect! to disable_net_connect!" do
-      expect(WebMock.method(:disallow_net_connect!)).to eq(WebMock.method(:disable_net_connect!))
-    end
-  end
-
-  describe ".net_connect_allowed?" do
-    context 'enabled globally' do
-      before do
-        WebMock.enable_net_connect!
-      end
-
-      context 'without arguments' do
-        it 'returns WebMock::Config.instance.allow_net_connect' do
-          expect(WebMock.net_connect_allowed?).to eql(true)
-        end
-      end
-    end
-
-    context 'disabled with allowed remote string' do
-      before do
-        WebMock.disable_net_connect!(allow: "http://192.168.64.2:20031")
-      end
-
-      context 'without arguments' do
-        it 'returns WebMock::Config.instance.allow_net_connect' do
-          expect(WebMock.net_connect_allowed?).to eql(false)
-        end
-      end
-    end
-
-    context 'disabled globally' do
-      before do
-        WebMock.disable_net_connect!
-      end
-
-      context 'without arguments' do
-        it 'returns WebMock::Config.instance.allow_net_connect' do
-          expect(WebMock.net_connect_allowed?).to eql(false)
-        end
-      end
-    end
-  end
-end

data/test/http_request.rb

@@ -1,24 +0,0 @@
-require 'ostruct'
-
-module HttpRequestTestHelper
-  def http_request(method, uri, options = {})
-    begin
-      uri = URI.parse(uri)
-    rescue
-      uri = Addressable::URI.heuristic_parse(uri)
-    end
-    response = nil
-    clazz = ::Net::HTTP.const_get("#{method.to_s.capitalize}")
-    req = clazz.new("#{uri.path}#{uri.query ? '?' : ''}#{uri.query}", options[:headers])
-    req.basic_auth uri.user, uri.password if uri.user
-    http = ::Net::HTTP.new(uri.host, uri.port)
-    http.use_ssl = true if uri.scheme == "https"
-    response = http.start {|http|
-      http.request(req, options[:body])
-    }
-    OpenStruct.new({
-      body: response.body,
-      headers: response,
-      status: response.code })
-  end
-end