webmock 3.18.1 → 3.19.0

data/spec/unit/request_registry_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-
-describe WebMock::RequestRegistry do
-
-  before(:each) do
-    WebMock::RequestRegistry.instance.reset!
-    @request_pattern = WebMock::RequestPattern.new(:get, "www.example.com")
-    @request_signature = WebMock::RequestSignature.new(:get, "www.example.com")
-  end
-
-  describe "reset!" do
-    before(:each) do
-      WebMock::RequestRegistry.instance.requested_signatures.put(@request_signature)
-    end
-
-    it "should clean list of executed requests" do
-      expect(WebMock::RequestRegistry.instance.times_executed(@request_pattern)).to eq(1)
-      WebMock::RequestRegistry.instance.reset!
-      expect(WebMock::RequestRegistry.instance.times_executed(@request_pattern)).to eq(0)
-    end
-
-  end
-
-  describe "times executed" do
-
-    before(:each) do
-      @request_stub1 = WebMock::RequestStub.new(:get, "www.example.com")
-      @request_stub2 = WebMock::RequestStub.new(:get, "www.example.net")
-      @request_stub3 = WebMock::RequestStub.new(:get, "www.example.org")
-      WebMock::RequestRegistry.instance.requested_signatures.put(WebMock::RequestSignature.new(:get, "www.example.com"))
-      WebMock::RequestRegistry.instance.requested_signatures.put(WebMock::RequestSignature.new(:get, "www.example.com"))
-      WebMock::RequestRegistry.instance.requested_signatures.put(WebMock::RequestSignature.new(:get, "www.example.org"))
-    end
-
-    it "should report 0 if no request matching pattern was requested" do
-      expect(WebMock::RequestRegistry.instance.times_executed(WebMock::RequestPattern.new(:get, "www.example.net"))).to eq(0)
-    end
-
-    it "should report number of times matching pattern was requested" do
-      expect(WebMock::RequestRegistry.instance.times_executed(WebMock::RequestPattern.new(:get, "www.example.com"))).to eq(2)
-    end
-
-    it "should report number of times all matching pattern were requested" do
-      expect(WebMock::RequestRegistry.instance.times_executed(WebMock::RequestPattern.new(:get, /.*example.*/))).to eq(3)
-    end
-
-    describe "multithreading" do
-      let(:request_pattern) { WebMock::RequestPattern.new(:get, "www.example.com") }
-
-      # Reproduce a multithreading issue that causes a RuntimeError:
-      #   can't add a new key into hash during iteration.
-      it "works normally iterating on the requested signature hash while another thread is setting it" do
-        thread_injected = false
-        allow(request_pattern).to receive(:matches?).and_wrap_original do |m, *args|
-          unless thread_injected
-            thread_injected = true
-            Thread.new { WebMock::RequestRegistry.instance.requested_signatures.put(:abc) }.join(0.1)
-          end
-          m.call(*args)
-        end
-        expect(WebMock::RequestRegistry.instance.times_executed(request_pattern)).to eq(2)
-        sleep 0.1 while !WebMock::RequestRegistry.instance.requested_signatures.hash.key?(:abc)
-      end
-    end
-  end
-
-  describe "request_signatures" do
-    it "should return hash of unique request signatures with accumulated number" do
-      WebMock::RequestRegistry.instance.requested_signatures.put(WebMock::RequestSignature.new(:get, "www.example.com"))
-      WebMock::RequestRegistry.instance.requested_signatures.put(WebMock::RequestSignature.new(:get, "www.example.com"))
-      expect(WebMock::RequestRegistry.instance.requested_signatures.
-        get(WebMock::RequestSignature.new(:get, "www.example.com"))).to eq(2)
-    end
-  end
-
-  describe "to_s" do
-    it "should output string with all executed requests and numbers of executions" do
-      [
-        WebMock::RequestSignature.new(:get, "www.example.com"),
-        WebMock::RequestSignature.new(:get, "www.example.com"),
-        WebMock::RequestSignature.new(:put, "www.example.org"),
-      ].each do |s|
-        WebMock::RequestRegistry.instance.requested_signatures.put(s)
-      end
-      expect(WebMock::RequestRegistry.instance.to_s).to eq(
-      "GET http://www.example.com/ was made 2 times\nPUT http://www.example.org/ was made 1 time\n"
-      )
-    end
-
-    it "should output info if no requests were executed" do
-      expect(WebMock::RequestRegistry.instance.to_s).to eq("No requests were made.")
-    end
-  end
-
-end

data/spec/unit/request_signature_snippet_spec.rb

@@ -1,89 +0,0 @@
-require "spec_helper"
-
-RSpec.describe WebMock::RequestSignatureSnippet do
-  it("is real"){expect{subject}.not_to(raise_error)}
-
-  subject { WebMock::RequestSignatureSnippet.new(request_signature) }
-
-  let(:uri) { "http://example.com" }
-  let(:method) { "GET" }
-
-  let(:request_signature) { WebMock::RequestSignature.new(method, uri) }
-  let(:request_signature_body) { {"key" => "different value"}.to_json }
-
-  let(:request_pattern) {
-    WebMock::RequestPattern.new(
-      method, uri, {body: request_signature_body}
-    )
-  }
-
-  before :each do
-    request_signature.headers = {"Content-Type" => "application/json"}
-    request_signature.body = request_signature_body
-  end
-
-  describe "#stubbing_instructions" do
-    context "with stubbing instructions turned off" do
-      before :each do
-        WebMock.hide_stubbing_instructions!
-      end
-
-      it "returns nil" do
-        expect(subject.stubbing_instructions).to be nil
-      end
-
-      after :each do
-        WebMock.show_stubbing_instructions!
-      end
-    end
-
-    context "with stubbing instructions turned on" do
-      it "returns a stub snippet" do
-        expect(subject.stubbing_instructions).to include(
-          "You can stub this request with the following snippet:"
-        )
-      end
-    end
-  end
-
-  describe "#request_stubs" do
-    before :each do
-      WebMock.stub_request(:get, "https://www.example.com").with(body: {"a" => "b"})
-    end
-
-    context "when showing the body diff is turned off" do
-      before :each do
-        WebMock.hide_body_diff!
-      end
-
-      it "returns does not show the body diff" do
-        result = subject.request_stubs
-        result.sub!("registered request stubs:\n\n", "")
-        expect(result).to eq(
-          "stub_request(:get, \"https://www.example.com/\").\n  with(\n    body: {\"a\"=>\"b\"})"
-        )
-      end
-
-      after :each do
-        WebMock.show_body_diff!
-      end
-    end
-
-    context "when showing the body diff is turned on" do
-      it "shows the body diff" do
-        result = subject.request_stubs
-        result.sub!("registered request stubs:\n\n", "")
-        expect(result).to eq(
-          "stub_request(:get, \"https://www.example.com/\").\n  with(\n    body: {\"a\"=>\"b\"})\n\nBody diff:\n [[\"-\", \"key\", \"different value\"], [\"+\", \"a\", \"b\"]]\n"
-        )
-      end
-    end
-
-    context "with no request stubs" do
-      it "returns nil" do
-        WebMock.reset!
-        expect(subject.request_stubs).to be nil
-      end
-    end
-  end
-end

data/spec/unit/request_signature_spec.rb

@@ -1,175 +0,0 @@
-require 'spec_helper'
-
-describe WebMock::RequestSignature do
-
-  describe "initialization" do
-
-    it "assign the uri to be the normalized uri" do
-      expect(WebMock::Util::URI).to receive(:normalize_uri).and_return("www.example.kom")
-      signature = WebMock::RequestSignature.new(:get, "www.example.com")
-      expect(signature.uri).to eq("www.example.kom")
-    end
-
-    it "assigns the uri without normalization if uri is already a URI" do
-      expect(WebMock::Util::URI).not_to receive(:normalize_uri)
-      uri = Addressable::URI.parse("www.example.com")
-      signature = WebMock::RequestSignature.new(:get, uri)
-      expect(signature.uri).to eq(uri)
-    end
-
-    it "assigns normalized headers" do
-      allow(WebMock::Util::Headers).to receive(:normalize_headers).with({'A' => 'a'}.freeze).and_return('B' => 'b')
-      expect(
-        WebMock::RequestSignature.new(:get, "www.example.com", headers: {'A' => 'a'}).headers
-      ).to eq({'B' => 'b'})
-    end
-
-    it "assign the body" do
-      expect(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc").body).to eq("abc")
-    end
-
-    it "symbolizes the method" do
-      expect(WebMock::RequestSignature.new('get', "www.example.com", body: "abc").method).to eq(:get)
-    end
-  end
-
-  describe "#to_s" do
-    it "describes itself" do
-      expect(WebMock::RequestSignature.new(:get, "www.example.com",
-        body: "abc", headers: {'A' => 'a', 'B' => 'b'}).to_s).to eq(
-      "GET http://www.example.com/ with body 'abc' with headers {'A'=>'a', 'B'=>'b'}"
-      )
-    end
-  end
-
-  describe "#hash" do
-    it "reporst same hash for two signatures with the same values" do
-      signature1 = WebMock::RequestSignature.new(:get, "www.example.com",
-        body: "abc", headers: {'A' => 'a', 'B' => 'b'})
-      signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
-        body: "abc", headers: {'A' => 'a', 'B' => 'b'})
-      expect(signature1.hash).to eq(signature2.hash)
-    end
-
-    it "reports different hash for two signatures with different method" do
-      signature1 = WebMock::RequestSignature.new(:get, "www.example.com")
-      signature2 = WebMock::RequestSignature.new(:put, "www.example.com")
-      expect(signature1.hash).not_to eq(signature2.hash)
-    end
-
-    it "reports different hash for two signatures with different uri" do
-      signature1 = WebMock::RequestSignature.new(:get, "www.example.com")
-      signature2 = WebMock::RequestSignature.new(:get, "www.example.org")
-      expect(signature1.hash).not_to eq(signature2.hash)
-    end
-
-    it "reports different hash for two signatures with different body" do
-      signature1 = WebMock::RequestSignature.new(:get, "www.example.com", body: "abc")
-      signature2 = WebMock::RequestSignature.new(:get, "www.example.com", body: "def")
-      expect(signature1.hash).not_to eq(signature2.hash)
-    end
-
-    it "reports different hash for two signatures with different headers" do
-      signature1 = WebMock::RequestSignature.new(:get, "www.example.com",
-        headers: {'A' => 'a'})
-      signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
-        headers: {'A' => 'A'})
-      expect(signature1.hash).not_to eq(signature2.hash)
-    end
-  end
-
-  [:==, :eql?].each do |method|
-    describe method do
-      it "is true for two signatures with the same values" do
-        signature1 = WebMock::RequestSignature.new(:get, "www.example.com",
-          body: "abc", headers: {'A' => 'a', 'B' => 'b'})
-        signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
-          body: "abc", headers: {'A' => 'a', 'B' => 'b'})
-
-        expect(signature1.send(method, signature2)).to be_truthy
-      end
-
-      it "is false for two signatures with different method" do
-        signature1 = WebMock::RequestSignature.new(:get, "www.example.com")
-        signature2 = WebMock::RequestSignature.new(:put, "www.example.com")
-        expect(signature1.send(method, signature2)).to be_falsey
-      end
-
-      it "is false for two signatures with different uri" do
-        signature1 = WebMock::RequestSignature.new(:get, "www.example.com")
-        signature2 = WebMock::RequestSignature.new(:get, "www.example.org")
-        expect(signature1.send(method, signature2)).to be_falsey
-      end
-
-      it "is false for two signatures with different body" do
-        signature1 = WebMock::RequestSignature.new(:get, "www.example.com", body: "abc")
-        signature2 = WebMock::RequestSignature.new(:get, "www.example.com", body: "def")
-        expect(signature1.send(method, signature2)).to be_falsey
-      end
-
-      it "is false for two signatures with different headers" do
-        signature1 = WebMock::RequestSignature.new(:get, "www.example.com",
-          headers: {'A' => 'a'})
-        signature2 = WebMock::RequestSignature.new(:get, "www.example.com",
-          headers: {'A' => 'A'})
-        expect(signature1.send(method, signature2)).to be_falsey
-      end
-    end
-  end
-
-  subject { WebMock::RequestSignature.new(:get, "www.example.com") }
-
-  describe "#url_encoded?" do
-    it "returns true if the headers are urlencoded" do
-      subject.headers = { "Content-Type" => "application/x-www-form-urlencoded" }
-      expect(subject.url_encoded?).to be true
-    end
-
-    it "returns true if the headers are urlencoded with a specified charset" do
-      subject.headers = { "Content-Type" => "application/x-www-form-urlencoded; charset=UTF-8" }
-      expect(subject.url_encoded?).to be true
-    end
-
-    it "returns false if the headers are NOT urlencoded" do
-      subject.headers = { "Content-Type" => "application/made-up-format" }
-      expect(subject.url_encoded?).to be false
-    end
-
-    it "returns false when no content type header is present" do
-      subject.headers = { "Some-Header" => "some-value" }
-      expect(subject.url_encoded?).to be false
-    end
-
-    it "returns false when no headers are set" do
-      subject.headers = nil
-      expect(subject.url_encoded?).to be false
-    end
-  end
-
-  describe "#json_headers?" do
-    it "returns true if the headers are json" do
-      subject.headers = { "Content-Type" => "application/json" }
-      expect(subject.json_headers?).to be true
-    end
-
-    it "returns true if the headers are json with a specified charset" do
-      subject.headers = { "Content-Type" => "application/json; charset=UTF-8" }
-      expect(subject.json_headers?).to be true
-    end
-
-    it "returns false if the headers are NOT json" do
-      subject.headers = { "Content-Type" => "application/made-up-format" }
-      expect(subject.json_headers?).to be false
-    end
-
-    it "returns false when no content type header is present" do
-      subject.headers = { "Some-Header" => "some-value" }
-      expect(subject.json_headers?).to be false
-    end
-
-    it "returns false when no headers are set" do
-      subject.headers = nil
-      expect(subject.json_headers?).to be false
-    end
-  end
-end

data/spec/unit/request_stub_spec.rb

@@ -1,234 +0,0 @@
-require 'spec_helper'
-
-describe WebMock::RequestStub do
-
-  before(:each) do
-    @request_stub = WebMock::RequestStub.new(:get, "www.example.com")
-  end
-
-  it "should have request pattern with method and uri" do
-    expect(@request_stub.request_pattern.to_s).to eq("GET http://www.example.com/")
-  end
-
-  it "should have response" do
-    expect(@request_stub.response).to be_a(WebMock::Response)
-  end
-
-  describe "with" do
-
-    it "should assign body to request pattern" do
-      @request_stub.with(body: "abc")
-      expect(@request_stub.request_pattern.to_s).to eq(WebMock::RequestPattern.new(:get, "www.example.com", body: "abc").to_s)
-    end
-
-    it "should assign normalized headers to request pattern" do
-      @request_stub.with(headers: {'A' => 'a'})
-      expect(@request_stub.request_pattern.to_s).to eq(
-        WebMock::RequestPattern.new(:get, "www.example.com", headers: {'A' => 'a'}).to_s
-      )
-    end
-
-    it "should assign given block to request profile" do
-      @request_stub.with { |req| req.body == "abc" }
-      expect(@request_stub.request_pattern.matches?(WebMock::RequestSignature.new(:get, "www.example.com", body: "abc"))).to be_truthy
-    end
-
-  end
-
-  describe "to_return" do
-
-    it "should assign response with provided options" do
-      @request_stub.to_return(body: "abc", status: 500)
-      expect(@request_stub.response.body).to eq("abc")
-      expect(@request_stub.response.status).to eq([500, ""])
-    end
-
-    it "should assign responses with provided options" do
-      @request_stub.to_return([{body: "abc"}, {body: "def"}])
-      expect([@request_stub.response.body, @request_stub.response.body]).to eq(["abc", "def"])
-    end
-
-  end
-
-  describe "to_return_json" do
-
-    it "should raise if a block is given" do
-      expect {
-        @request_stub.to_return_json(body: "abc", status: 500) { puts "don't call me" }
-      }.to raise_error(ArgumentError, '#to_return_json does not support passing a block')
-    end
-
-    it "should assign responses normally" do
-      @request_stub.to_return_json([{body: "abc"}, {body: "def"}])
-      expect([@request_stub.response.body, @request_stub.response.body]).to eq(["abc", "def"])
-    end
-
-    it "should json-ify a Hash body" do
-      @request_stub.to_return_json(body: {abc: "def"}, status: 500)
-      expect(@request_stub.response.body).to eq({abc: "def"}.to_json)
-      expect(@request_stub.response.status).to eq([500, ""])
-    end
-
-    it "should apply the content_type header" do
-      @request_stub.to_return_json(body: {abc: "def"}, status: 500)
-      expect(@request_stub.response.headers).to eq({"Content-Type"=>"application/json"})
-    end
-
-    it "should preserve existing headers" do
-      @request_stub.to_return_json(headers: {"A" => "a"}, body: "")
-      expect(@request_stub.response.headers).to eq({"A"=>"a", "Content-Type"=>"application/json"})
-    end
-
-    it "should allow callsites to override content_type header" do
-      @request_stub.to_return_json(headers: {content_type: 'application/super-special-json'})
-      expect(@request_stub.response.headers).to eq({"Content-Type"=>"application/super-special-json"})
-    end
-  end
-
-  describe "then" do
-    it "should return stub without any modifications, acting as syntactic sugar" do
-      expect(@request_stub.then).to eq(@request_stub)
-    end
-  end
-
-  describe "response" do
-
-    it "should return responses in a sequence passed as array" do
-      @request_stub.to_return([{body: "abc"}, {body: "def"}])
-      expect(@request_stub.response.body).to eq("abc")
-      expect(@request_stub.response.body).to eq("def")
-    end
-
-    it "should repeat returning last response" do
-      @request_stub.to_return([{body: "abc"}, {body: "def"}])
-      @request_stub.response
-      @request_stub.response
-      expect(@request_stub.response.body).to eq("def")
-    end
-
-    it "should return responses in a sequence passed as comma separated params" do
-      @request_stub.to_return({body: "abc"}, {body: "def"})
-      expect(@request_stub.response.body).to eq("abc")
-      expect(@request_stub.response.body).to eq("def")
-    end
-
-    it "should return responses declared in multiple to_return declarations" do
-      @request_stub.to_return({body: "abc"}).to_return({body: "def"})
-      expect(@request_stub.response.body).to eq("abc")
-      expect(@request_stub.response.body).to eq("def")
-    end
-
-  end
-
-  describe "to_raise" do
-
-    it "should assign response with exception to be thrown" do
-      @request_stub.to_raise(ArgumentError)
-      expect {
-        @request_stub.response.raise_error_if_any
-      }.to raise_error(ArgumentError, "Exception from WebMock")
-    end
-
-    it "should assign sequence of responses with response with exception to be thrown" do
-      @request_stub.to_return(body: "abc").then.to_raise(ArgumentError)
-      expect(@request_stub.response.body).to eq("abc")
-      expect {
-        @request_stub.response.raise_error_if_any
-      }.to raise_error(ArgumentError, "Exception from WebMock")
-    end
-
-    it "should assign a list responses to be thrown in a sequence" do
-      @request_stub.to_raise(ArgumentError, IndexError)
-      expect {
-        @request_stub.response.raise_error_if_any
-      }.to raise_error(ArgumentError, "Exception from WebMock")
-      expect {
-        @request_stub.response.raise_error_if_any
-      }.to raise_error(IndexError, "Exception from WebMock")
-    end
-
-    it "should raise exceptions declared in multiple to_raise declarations" do
-       @request_stub.to_raise(ArgumentError).then.to_raise(IndexError)
-        expect {
-          @request_stub.response.raise_error_if_any
-        }.to raise_error(ArgumentError, "Exception from WebMock")
-        expect {
-          @request_stub.response.raise_error_if_any
-        }.to raise_error(IndexError, "Exception from WebMock")
-    end
-
-  end
-
-  describe "to_timeout" do
-
-     it "should assign response with timeout" do
-       @request_stub.to_timeout
-       expect(@request_stub.response.should_timeout).to be_truthy
-     end
-
-     it "should assign sequence of responses with response with timeout" do
-       @request_stub.to_return(body: "abc").then.to_timeout
-       expect(@request_stub.response.body).to eq("abc")
-       expect(@request_stub.response.should_timeout).to be_truthy
-     end
-
-     it "should allow multiple timeouts to be declared" do
-       @request_stub.to_timeout.then.to_timeout.then.to_return(body: "abc")
-       expect(@request_stub.response.should_timeout).to be_truthy
-       expect(@request_stub.response.should_timeout).to be_truthy
-       expect(@request_stub.response.body).to eq("abc")
-     end
-
-   end
-
-
-  describe "times" do
-
-    it "should give error if declared before any response declaration is declared" do
-      expect {
-        @request_stub.times(3)
-       }.to raise_error("Invalid WebMock stub declaration. times(N) can be declared only after response declaration.")
-    end
-
-    it "should repeat returning last declared response declared number of times" do
-      @request_stub.to_return({body: "abc"}).times(2).then.to_return({body: "def"})
-      expect(@request_stub.response.body).to eq("abc")
-      expect(@request_stub.response.body).to eq("abc")
-      expect(@request_stub.response.body).to eq("def")
-    end
-
-    it "should repeat raising last declared exception declared number of times" do
-      @request_stub.to_return({body: "abc"}).times(2).then.to_return({body: "def"})
-      expect(@request_stub.response.body).to eq("abc")
-      expect(@request_stub.response.body).to eq("abc")
-      expect(@request_stub.response.body).to eq("def")
-    end
-
-    it "should repeat returning last declared sequence of responses declared number of times" do
-      @request_stub.to_return({body: "abc"}, {body: "def"}).times(2).then.to_return({body: "ghj"})
-      expect(@request_stub.response.body).to eq("abc")
-      expect(@request_stub.response.body).to eq("def")
-      expect(@request_stub.response.body).to eq("abc")
-      expect(@request_stub.response.body).to eq("def")
-      expect(@request_stub.response.body).to eq("ghj")
-    end
-
-    it "should return self" do
-      expect(@request_stub.to_return({body: "abc"}).times(1)).to eq(@request_stub)
-    end
-
-    it "should raise error if argument is not integer" do
-      expect {
-         @request_stub.to_return({body: "abc"}).times("not number")
-      }.to raise_error("times(N) accepts integers >= 1 only")
-    end
-
-    it "should raise error if argument is < 1" do
-      expect {
-        @request_stub.to_return({body: "abc"}).times(0)
-      }.to raise_error("times(N) accepts integers >= 1 only")
-    end
-
-  end
-
-end