http_stub 0.25.1 → 0.26.0

data/spec/lib/http_stub/configurer/request/http/basic_spec.rb

@@ -1,15 +1,91 @@
 describe HttpStub::Configurer::Request::Http::Basic do
 
-  let(:http_request)  { instance_double(Net::HTTPRequest) }
+  let(:request_method) { :get }
+  let(:path)           { "some/path" }
+  let(:args)           { { method: request_method, path: path } }
 
-  let(:basic_request) { HttpStub::Configurer::Request::Http::Basic.new(http_request) }
+  let(:basic_request) { described_class.new(args) }
 
   describe "#to_http_request" do
 
-    it "returns the provided HTTP request" do
-      expect(basic_request.to_http_request).to eql(http_request)
+    subject { basic_request.to_http_request }
+
+    it "returns a HTTP request of the provided type" do
+      expect(subject).to be_a(Net::HTTP::Get)
+    end
+
+    it "returns a request with the provided path prefixed with http_stub scoping" do
+      expect(subject.path).to eql("/http_stub/#{path}")
+    end
+
+    context "when headers are provided" do
+
+      let(:args) { { method: request_method, path: path, headers: headers } }
+
+      context "whose names are symbols" do
+
+        let(:headers) { (1..3).each_with_object({}) { |i, result| result["header#{i}".to_sym] = "value#{i}" } }
+
+        it "returns a request with the provided headers with names converted to strings" do
+          expect(request_headers).to include(headers.stringify_keys)
+        end
+
+      end
+
+      context "whose names are strings" do
+
+        let(:headers) { (1..3).each_with_object({}) { |i, result| result["header#{i}"] = "value#{i}" } }
+
+        it "returns a request with the provided headers" do
+          expect(request_headers).to include(headers)
+        end
+
+      end
+
+    end
+
+    context "when headers are not provided" do
+
+      it "returns a request with default headers" do
+        expect(request_headers).to_not be_empty
+      end
+
+    end
+
+    context "when parameters are provided" do
+
+      let(:parameters) { (1..3).each_with_object({}) { |i, result| result["parameter#{i}"] = "value#{i}" } }
+
+      let(:args) { { method: request_method, path: path, parameters: parameters } }
+
+      it "returns a request with the provided parameters" do
+        expect(request_parameters).to eql(parameters)
+      end
+
+    end
+
+    context "when parameters are not provided" do
+
+      let(:args) { { method: request_method, path: path } }
+
+      it "returns a request without parameters" do
+        expect(subject.body).to eql(nil)
+      end
+
+    end
+
+    it "returns a request with the provided path prefixed with http_stub scoping" do
+      expect(subject.path).to eql("/http_stub/#{path}")
     end
 
   end
 
+  def request_headers
+    subject.to_hash.each_with_object({}) { |(key, value), result| result[key] = value.first }
+  end
+
+  def request_parameters
+    URI.decode_www_form(subject.body).to_h
+  end
+
 end

data/spec/lib/http_stub/configurer/request/http/factory_spec.rb

@@ -2,21 +2,55 @@ describe HttpStub::Configurer::Request::Http::Factory do
 
   describe "::multipart" do
 
-    let(:model)             { double("HttpStub::Configurer::Request::SomeModel") }
+    let(:model) { double("HttpStub::Configurer::Request::SomeModel") }
+    let(:path)  { "some/model/path" }
+
     let(:multipart_request) { instance_double(HttpStub::Configurer::Request::Http::Multipart) }
 
-    subject { HttpStub::Configurer::Request::Http::Factory.multipart(model) }
+    subject { described_class.multipart(path, model) }
 
     before(:example) do
       allow(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).and_return(multipart_request)
     end
 
+    it "creates a multipart request with the provided path" do
+      expect(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).with(hash_including(path: path))
+
+      subject
+    end
+
     it "creates a multipart request with the provided model" do
-      expect(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).with(model)
+      expect(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).with(hash_including(model: model))
 
       subject
     end
 
+    context "when headers are provided" do
+
+      let(:headers) { (1..3).each_with_object({}) { |i, result| result["header#{i}"] = "value#{i}" } }
+
+      subject { described_class.multipart(path, model, headers) }
+
+      it "creates a multipart request with the provided headers" do
+        expect(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).with(hash_including(headers: headers))
+
+        subject
+      end
+
+    end
+
+    context "when no headers are provided" do
+
+      subject { described_class.multipart(path, model) }
+
+      it "creates a multipart request with the empty headers" do
+        expect(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).with(hash_including(headers: {}))
+
+        subject
+      end
+
+    end
+
     it "returns the created request" do
       expect(subject).to eql(multipart_request)
     end
@@ -25,47 +59,52 @@ describe HttpStub::Configurer::Request::Http::Factory do
 
   describe "::get" do
 
-    let(:path)          { "/some/get/path" }
-    let(:get_request)   { instance_double(Net::HTTP::Get) }
+    let(:path) { "/some/get/path" }
+
     let(:basic_request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
 
-    subject { HttpStub::Configurer::Request::Http::Factory.get(path) }
+    subject { described_class.get(path) }
 
-    before(:example) do
-      allow(Net::HTTP::Get).to receive(:new).and_return(get_request)
-      allow(HttpStub::Configurer::Request::Http::Basic).to receive(:new).and_return(basic_request)
+    before(:example) { allow(HttpStub::Configurer::Request::Http::Basic).to receive(:new).and_return(basic_request) }
+
+    it "creates a basic GET request" do
+      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(method: :get))
+
+      subject
+    end
+
+    it "creates a basic request with the provided path" do
+      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(path: path))
+
+      subject
     end
 
-    context "when the path is absolute" do
+    context "when headers are provided" do
 
-      let(:path) { "/some/absolute/get/path" }
+      let(:headers) { (1..3).each_with_object({}) { |i, result| result["header#{i}"] = "value#{i}" } }
 
-      it "creates a GET request with the provided path" do
-        expect(Net::HTTP::Get).to receive(:new).with(path)
+      subject { described_class.get(path, headers) }
+
+      it "creates a basic request with the provided headers" do
+        expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(headers: headers))
 
         subject
       end
 
     end
 
-    context "when the path is relative" do
+    context "when no headers are provided" do
 
-      let(:path) { "some/relative/get/path" }
+      subject { described_class.get(path) }
 
-      it "creates a GET request with the path prefixed by '/'" do
-        expect(Net::HTTP::Get).to receive(:new).with("/#{path}")
+      it "creates a basic request with empty headers" do
+        expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(headers: {}))
 
         subject
       end
 
     end
 
-    it "creates a basic request wrapping the GET request" do
-      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(get_request)
-
-      subject
-    end
-
     it "returns the created basic request" do
       expect(subject).to eql(basic_request)
     end
@@ -74,31 +113,34 @@ describe HttpStub::Configurer::Request::Http::Factory do
 
   describe "::post" do
 
-    let(:path)          { "/some/post/path" }
-    let(:post_request)  { instance_double(Net::HTTP::Post).as_null_object }
+    let(:path) { "/some/post/path" }
+
     let(:basic_request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
 
-    subject { HttpStub::Configurer::Request::Http::Factory.post(path) }
+    subject { described_class.post(path) }
 
-    before(:example) do
-      allow(Net::HTTP::Post).to receive(:new).and_return(post_request)
-      allow(HttpStub::Configurer::Request::Http::Basic).to receive(:new).and_return(basic_request)
+    before(:example) { allow(HttpStub::Configurer::Request::Http::Basic).to receive(:new).and_return(basic_request) }
+
+    it "creates a basic POST request" do
+      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(method: :post))
+
+      subject
     end
 
-    it "creates a POST request with the provided path" do
-      expect(Net::HTTP::Post).to receive(:new).with(path)
+    it "creates a basic request with the provided path" do
+      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(path: path))
 
       subject
     end
 
     context "when parameters are provided" do
 
-      let(:parameters) { (1..3).each_with_object({}) { |i, result| result["key#{i}"] = "value#{i}" } }
+      let(:parameters) { (1..3).each_with_object({}) { |i, result| result["parameter#{i}"] = "value#{i}" } }
 
-      subject { HttpStub::Configurer::Request::Http::Factory.post(path, parameters) }
+      subject { described_class.post(path, parameters) }
 
-      it "establishes the provided parameters as the form data in the POST request" do
-        expect(post_request).to receive(:set_form_data).with(parameters)
+      it "creates a basic request with the provided parameters" do
+        expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(parameters: parameters))
 
         subject
       end
@@ -107,22 +149,16 @@ describe HttpStub::Configurer::Request::Http::Factory do
 
     context "when no parameters are provided" do
 
-      subject { HttpStub::Configurer::Request::Http::Factory.post(path) }
+      subject { described_class.post(path) }
 
-      it "establishes empty form data in the POST request" do
-        expect(post_request).to receive(:set_form_data).with({})
+      it "creates a basic POST request with empty parameters" do
+        allow(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(parameters: {}))
 
         subject
       end
 
     end
 
-    it "creates a basic request wrapping the POST request" do
-      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(post_request)
-
-      subject
-    end
-
     it "returns the created basic request" do
       expect(subject).to eql(basic_request)
     end
@@ -131,29 +167,52 @@ describe HttpStub::Configurer::Request::Http::Factory do
 
   describe "::delete" do
 
-    let(:path)           { "/some/delete/path" }
-    let(:delete_request) { instance_double(Net::HTTP::Delete) }
-    let(:basic_request)  { instance_double(HttpStub::Configurer::Request::Http::Basic) }
+    let(:path) { "/some/delete/path" }
+
+    let(:basic_request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
 
-    subject { HttpStub::Configurer::Request::Http::Factory.delete(path) }
+    subject { described_class.delete(path) }
 
-    before(:example) do
-      allow(Net::HTTP::Delete).to receive(:new).and_return(delete_request)
-      allow(HttpStub::Configurer::Request::Http::Basic).to receive(:new).and_return(basic_request)
-    end
+    before(:example) { allow(HttpStub::Configurer::Request::Http::Basic).to receive(:new).and_return(basic_request) }
 
-    it "creates a DELETE request with the provided path" do
-      expect(Net::HTTP::Delete).to receive(:new).with(path)
+    it "creates a basic DELETE request" do
+      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(method: :delete))
 
       subject
     end
 
-    it "creates a basic request wrapping the DELETE request" do
-      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(delete_request)
+    it "creates a basic request with the provided path" do
+      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(path: path))
 
       subject
     end
 
+    context "when headers are provided" do
+
+      let(:headers) { (1..3).each_with_object({}) { |i, result| result["header#{i}"] = "value#{i}" } }
+
+      subject { described_class.delete(path, headers) }
+
+      it "creates a basic request with the provided headers" do
+        expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(headers: headers))
+
+        subject
+      end
+
+    end
+
+    context "when no headers are provided" do
+
+      subject { described_class.delete(path) }
+
+      it "creates a basic request with empty headers" do
+        expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(headers: {}))
+
+        subject
+      end
+
+    end
+
     it "returns the created basic request" do
       expect(subject).to eql(basic_request)
     end

data/spec/lib/http_stub/configurer/request/http/multipart_spec.rb

@@ -13,9 +13,12 @@ describe HttpStub::Configurer::Request::Http::Multipart do
 
   let(:payload)        { { key: "value" } }
   let(:response_files) { [] }
+
+  let(:path)  { "some/model/path" }
   let(:model) { HttpStub::Configurer::Request::SomeModel.new(payload: payload, response_files: response_files) }
+  let(:args)  { { path: path , model: model } }
 
-  let(:multipart_request) { HttpStub::Configurer::Request::Http::Multipart.new(model) }
+  let(:multipart_request) { HttpStub::Configurer::Request::Http::Multipart.new(args) }
 
   describe "#to_http_request" do
 
@@ -34,14 +37,16 @@ describe HttpStub::Configurer::Request::Http::Multipart do
       expect(subject).to eql(http_multipart_request)
     end
 
-    it "creates a HTTP request with a path to the pluralized name for the model" do
-      expect(Net::HTTP::Post::Multipart).to receive(:new).with("/http_stub/some_models", anything)
+    it "creates a HTTP request with the provided path prefixed with http_stub scoping" do
+      expect(Net::HTTP::Post::Multipart).to receive(:new).with("/http_stub/some/model/path", anything, anything)
 
       subject
     end
 
     it "creates a HTTP request with a payload parameter containing the JSON representation of the payload" do
-      expect(Net::HTTP::Post::Multipart).to receive(:new).with(anything, hash_including(payload: payload.to_json))
+      expect(Net::HTTP::Post::Multipart).to(
+        receive(:new).with(anything, hash_including(payload: payload.to_json), anything)
+      )
 
       subject
     end
@@ -63,7 +68,9 @@ describe HttpStub::Configurer::Request::Http::Multipart do
           )
           result.tap { |hash| hash["response_file_#{response_file.id}"] = upload_file }
         end
-        expect(Net::HTTP::Post::Multipart).to receive(:new).with(anything, hash_including(expected_upload_parameters))
+        expect(Net::HTTP::Post::Multipart).to(
+          receive(:new).with(anything, hash_including(expected_upload_parameters), anything)
+        )
 
         subject
       end
@@ -73,7 +80,33 @@ describe HttpStub::Configurer::Request::Http::Multipart do
     context "when the payload contains no response files" do
 
       it "creates a HTTP request with no upload parameters" do
-        expect(Net::HTTP::Post::Multipart).to receive(:new).with(anything, payload: payload.to_json)
+        expect(Net::HTTP::Post::Multipart).to receive(:new).with(anything, { payload: payload.to_json }, anything)
+
+        subject
+      end
+
+    end
+
+    context "when headers are provided" do
+
+      let(:headers) { (1..3).each_with_object({}) { |i, result| result["header#{i}"] = "value#{i}" } }
+
+      let(:args) { { path: path, headers: headers, model: model } }
+
+      it "creates a HTTP request with the provided headers" do
+        expect(Net::HTTP::Post::Multipart).to receive(:new).with(anything, anything, headers)
+
+        subject
+      end
+
+    end
+
+    context "when no headers are provided" do
+
+      let(:args) { { path: path, model: model } }
+
+      it "creates a HTTP request with empty headers" do
+        expect(Net::HTTP::Post::Multipart).to receive(:new).with(anything, anything, {})
 
         subject
       end

data/spec/lib/http_stub/configurer/request/stub_spec.rb

@@ -1,51 +1,25 @@
 describe HttpStub::Configurer::Request::Stub do
 
   let(:fixture)          { HttpStub::StubFixture.new }
-  let(:stub_response)    { instance_double(HttpStub::Configurer::Request::StubResponse).as_null_object }
-  let(:trigger_builders) { [] }
+  let(:stub_response)    { instance_double(HttpStub::Configurer::Request::StubResponse) }
+  let(:stub_triggers)    { instance_double(HttpStub::Configurer::Request::Triggers) }
 
-  let(:stub) do
-    HttpStub::Configurer::Request::Stub.new(fixture.configurer_payload.merge(triggers: trigger_builders))
-  end
-
-  before(:example) { allow(HttpStub::Configurer::Request::StubResponse).to receive(:new).and_return(stub_response) }
-
-  shared_context "triggers one stub" do
-
-    let(:trigger_payload) { HttpStub::StubFixture.new.configurer_payload }
-    let(:trigger_files)   { [] }
-    let(:trigger) do
-      instance_double(HttpStub::Configurer::Request::Stub,
-                      payload: trigger_payload, response_files: trigger_files)
-    end
-    let(:trigger_builders) do
-      [ instance_double(HttpStub::Configurer::DSL::StubBuilder, build: trigger) ]
-    end
-
-  end
-
-  shared_context "triggers many stubs" do
-
-    let(:trigger_payloads) { (1..3).map { HttpStub::StubFixture.new.configurer_payload } }
-    let(:triggers_files)   { trigger_payloads.map { [] } }
-    let(:triggers) do
-      trigger_payloads.zip(triggers_files).map do |payload, files|
-        instance_double(HttpStub::Configurer::Request::Stub, payload: payload, response_files: files)
-      end
-    end
-    let(:trigger_builders) do
-      triggers.map do |trigger|
-        instance_double(HttpStub::Configurer::DSL::StubBuilder, build: trigger)
-      end
-    end
+  let(:stub) { HttpStub::Configurer::Request::Stub.new(fixture.configurer_payload) }
 
+  before(:example) do
+    allow(HttpStub::Configurer::Request::StubResponse).to receive(:new).and_return(stub_response)
+    allow(HttpStub::Configurer::Request::Triggers).to receive(:new).and_return(stub_triggers)
   end
 
   describe "#payload" do
 
     subject { stub.payload }
 
-    before(:example) { allow(HttpStub::Configurer::Request::ControllableValue).to receive(:format) }
+    before(:example) do
+      allow(HttpStub::Configurer::Request::ControllableValue).to receive(:format)
+      allow(stub_response).to receive(:payload)
+      allow(stub_triggers).to receive(:payload)
+    end
 
     context "when request headers" do
 
@@ -127,21 +101,18 @@ describe HttpStub::Configurer::Request::Stub do
 
     it "creates a stub response with the provided response options" do
       expect(HttpStub::Configurer::Request::StubResponse).to(
-        receive(:new).with(anything, fixture.response.symbolized).and_return(stub_response)
+        receive(:new).with(anything, fixture.configurer_payload[:response]).and_return(stub_response)
       )
 
       subject
     end
 
-    context "when many triggers are provided" do
-      include_context "triggers many stubs"
-
-      it "builds the request object for each trigger" do
-        trigger_builders.each { |trigger_builder| expect(trigger_builder).to receive(:build) }
-
-        subject
-      end
+    it "creates stub triggers with the provided triggers options" do
+      expect(HttpStub::Configurer::Request::Triggers).to(
+        receive(:new).with(fixture.configurer_payload[:triggers]).and_return(stub_triggers)
+      )
 
+      subject
     end
 
     context "builds a hash that" do
@@ -180,30 +151,10 @@ describe HttpStub::Configurer::Request::Stub do
         expect(subject).to include(response: "response payload")
       end
 
-      context "when a trigger is added" do
-        include_context "triggers one stub"
-
-        it "has a triggers entry containing the stub trigger payload" do
-          expect(subject).to include(triggers: [ trigger_payload ])
-        end
-
-      end
-
-      context "when many triggers are added" do
-        include_context "triggers many stubs"
-
-        it "has a triggers entry containing the stub trigger payloads" do
-          expect(subject).to include(triggers: trigger_payloads)
-        end
-
-      end
-
-      context "when no triggers are added" do
-
-        it "has a triggers entry containing an empty hash" do
-          expect(subject).to include(triggers: [])
-        end
+      it "has an entry containing the triggers payload" do
+        allow(stub_triggers).to receive(:payload).and_return("triggers payload")
 
+        expect(subject).to include(triggers: "triggers payload")
       end
 
     end
@@ -212,66 +163,57 @@ describe HttpStub::Configurer::Request::Stub do
 
   describe "#response_files" do
 
-    subject { stub.response_files }
+    let(:stub_response_file)      { nil }
+    let(:triggers_response_files) { [] }
 
-    context "when the response contains a file" do
-
-      let(:response_file) { instance_double(HttpStub::Configurer::Request::StubResponseFile) }
+    subject { stub.response_files }
 
-      before(:example) { allow(stub_response).to receive(:file).and_return(response_file) }
+    before(:example) do
+      allow(stub_response).to receive(:file).and_return(stub_response_file)
+      allow(stub_triggers).to receive(:response_files).and_return(triggers_response_files)
+    end
 
-      context "and the triggers contain files" do
-        include_context "triggers many stubs"
+    context "when the response contains a file" do
 
-        let(:triggers_files) do
-          trigger_payloads.map { (1..3).map { instance_double(HttpStub::Configurer::Request::StubResponseFile) } }
-        end
+      let(:stub_response_file) { instance_double(HttpStub::Configurer::Request::StubResponseFile) }
 
-        it "returns the stub response's file and the triggers files" do
-          expect(subject).to eql(([ response_file ] + triggers_files).flatten)
-        end
+      let(:triggers_response_files) { [] }
 
+      it "includes the stub response's file" do
+        expect(subject).to include(stub_response_file)
       end
 
-      context "and the triggers contain no files" do
-        include_context "triggers many stubs"
+    end
 
-        let(:triggers_files) { trigger_payloads.map { (1..3).map { [] } } }
+    context "when the triggers contain files" do
 
-        it "returns the stub response's file" do
-          expect(subject).to eql([ response_file ])
-        end
+      let(:triggers_response_files) do
+        (1..3).map { instance_double(HttpStub::Configurer::Request::StubResponseFile) }
+      end
 
+      it "includes the triggers files" do
+        expect(subject).to include(*triggers_response_files)
       end
 
     end
 
-    context "when the response body does not contain a file" do
-
-      before(:example) { allow(stub_response).to receive(:file).and_return(nil) }
-
-      context "and the triggers contain files" do
-        include_context "triggers many stubs"
-
-        let(:triggers_files) do
-          trigger_payloads.map { (1..3).map { instance_double(HttpStub::Configurer::Request::StubResponseFile) } }
-        end
-
-        it "returns the stub response's file and the triggers files" do
-          expect(subject).to eql(triggers_files.flatten)
-        end
+    context "when both the response and triggers contain files" do
 
+      let(:stub_response_file)      { instance_double(HttpStub::Configurer::Request::StubResponseFile) }
+      let(:triggers_response_files) do
+        (1..3).map { instance_double(HttpStub::Configurer::Request::StubResponseFile) }
       end
 
-      context "and no triggers contain a file" do
-        include_context "triggers many stubs"
+      it "is all the files" do
+        expect(subject).to eql(([ stub_response_file ] + triggers_response_files).flatten)
+      end
 
-        let(:triggers_files) { trigger_payloads.map { (1..3).map { [] } } }
+    end
 
-        it "returns a empty array" do
-          expect(subject).to eql([])
-        end
+    context "when neither the response or triggers contain files" do
 
+      it "returns an empty array" do
+        expect(subject).to eql([])
       end
 
     end