webmock 3.7.1

data/spec/unit/request_registry_spec.rb

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

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

@@ -0,0 +1,155 @@
+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
+      expect(WebMock::Util::Headers).to receive(:normalize_headers).with('A' => 'a').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 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 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 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 headers are set" do
+      subject.headers = nil
+      expect(subject.json_headers?).to be false
+    end
+  end
+end

data/spec/unit/request_stub_spec.rb

@@ -0,0 +1,199 @@
+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 "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