http_stub 0.14.2 → 0.15.0

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

@@ -0,0 +1,148 @@
+describe HttpStub::Configurer::Request::Http::Factory do
+
+  describe "::stub" do
+
+    let(:model)             { instance_double(HttpStub::Configurer::Request::Stub) }
+    let(:multipart_request) { instance_double(HttpStub::Configurer::Request::Http::Multipart) }
+
+    subject { HttpStub::Configurer::Request::Http::Factory.stub(model) }
+
+    before(:example) do
+      allow(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).and_return(multipart_request)
+    end
+
+    it "creates a multipart request for the stubs endpoint with the provided model" do
+      expect(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).with("/stubs", model)
+
+      subject
+    end
+
+    it "returns the created request" do
+      expect(subject).to eql(multipart_request)
+    end
+
+  end
+
+  describe "::stub_activator" do
+
+    let(:model)             { instance_double(HttpStub::Configurer::Request::StubActivator) }
+    let(:multipart_request) { instance_double(HttpStub::Configurer::Request::Http::Multipart) }
+
+    subject { HttpStub::Configurer::Request::Http::Factory.stub_activator(model) }
+
+    before(:example) do
+      allow(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).and_return(multipart_request)
+    end
+
+    it "creates a multipart request for the stub activators endpoint with the provided model" do
+      expect(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).with("/stubs/activators", model)
+
+      subject
+    end
+
+    it "returns the created request" do
+      expect(subject).to eql(multipart_request)
+    end
+
+  end
+
+  describe "::get" do
+
+    let(:path)          { "some/get/path" }
+    let(:get_request)   { instance_double(Net::HTTP::Get) }
+    let(:basic_request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
+
+    subject { HttpStub::Configurer::Request::Http::Factory.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)
+    end
+
+    it "creates a GET request with the provided path" do
+      expect(Net::HTTP::Get).to receive(:new).with(path)
+
+      subject
+    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
+
+  end
+
+  describe "::post" do
+
+    let(:path)          { "some/post/path" }
+    let(:post_request)  { instance_double(Net::HTTP::Post).as_null_object }
+    let(:basic_request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
+
+    subject { HttpStub::Configurer::Request::Http::Factory.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)
+    end
+
+    it "creates a POST request with the provided path" do
+      expect(Net::HTTP::Post).to receive(:new).with(path)
+
+      subject
+    end
+
+    it "establishes an empty body in the POST request" do
+      expect(post_request).to receive(:body=).with("")
+
+      subject
+    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
+
+  end
+
+  describe "::delete" do
+
+    let(:path)           { "some/get/path" }
+    let(:delete_request) { instance_double(Net::HTTP::Delete) }
+    let(:basic_request)  { instance_double(HttpStub::Configurer::Request::Http::Basic) }
+
+    subject { HttpStub::Configurer::Request::Http::Factory.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
+
+    it "creates a DELETE request with the provided path" do
+      expect(Net::HTTP::Delete).to receive(:new).with(path)
+
+      subject
+    end
+
+    it "creates a basic request wrapping the DELETE request" do
+      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(delete_request)
+
+      subject
+    end
+
+    it "returns the created basic request" do
+      expect(subject).to eql(basic_request)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,74 @@
+describe HttpStub::Configurer::Request::Http::Multipart do
+
+  let(:path)              { "/a/request/path" }
+  let(:payload)           { { key: "value" } }
+  let(:response_files)    { [] }
+  let(:model) { instance_double(HttpStub::Configurer::Request::Stub, payload: payload, response_files: response_files) }
+  let(:multipart_request) { HttpStub::Configurer::Request::Http::Multipart.new(path, model) }
+
+  describe "#to_http_request" do
+
+    subject { multipart_request.to_http_request }
+
+    it "creates a HTTP multipart request" do
+      expect(Net::HTTP::Post::Multipart).to receive(:new)
+
+      subject
+    end
+
+    it "returns the created HTTP multipart request" do
+      http_multipart_request = instance_double(Net::HTTP::Post::Multipart)
+      allow(Net::HTTP::Post::Multipart).to receive(:new).and_return(http_multipart_request)
+
+      expect(subject).to eql(http_multipart_request)
+    end
+
+    it "creates a HTTP request with the provided path" do
+      expect(Net::HTTP::Post::Multipart).to receive(:new).with(path, 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))
+
+      subject
+    end
+
+    context "when the payload contains response files" do
+
+      let(:response_files) do
+        (1..3).map do |i|
+          instance_double(HttpStub::Configurer::Request::StubResponseFile,
+                          id: "id#{i}", path: "file/path/#{i}", type: "file-type-#{i}", name: "file_name_#{i}")
+        end
+      end
+
+      it "creates a HTTP request with an upload parameter for each file keyed on the file ID" do
+        expected_upload_parameters = response_files.reduce({}) do |result, response_file|
+          upload_file = instance_double(UploadIO)
+          expect(UploadIO).to(
+            receive(:new).with(response_file.path, response_file.type, response_file.name).and_return(upload_file)
+          )
+          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))
+
+        subject
+      end
+
+    end
+
+    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)
+
+        subject
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,119 @@
+describe HttpStub::Configurer::Request::StubActivatorBuilder do
+
+  let(:stub_fixture) { HttpStub::StubFixture.new }
+
+  let(:response_defaults) { {} }
+  let(:stub)              { instance_double(HttpStub::Configurer::Request::Stub) }
+  let(:stub_builder)      { instance_double(HttpStub::Configurer::Request::StubBuilder, build: stub) }
+
+  let(:builder) { HttpStub::Configurer::Request::StubActivatorBuilder.new(response_defaults) }
+
+  before(:example) { allow(HttpStub::Configurer::Request::StubBuilder).to receive(:new).and_return(stub_builder) }
+
+  describe "constructor" do
+
+    subject { builder }
+
+    it "creates a stub builder with the provided response defaults" do
+      expect(HttpStub::Configurer::Request::StubBuilder).to receive(:new).with(response_defaults)
+
+      subject
+    end
+
+  end
+
+  describe "#match_requests" do
+
+    let(:request_payload) { stub_fixture.request.configurer_payload }
+
+    it "delegates to a stub builder" do
+      expect(stub_builder).to receive(:match_requests).with(stub_fixture.request.uri, request_payload)
+
+      builder.match_requests(stub_fixture.request.uri, request_payload)
+    end
+
+  end
+
+  describe "#respond_with" do
+
+    let(:response_payload) { stub_fixture.response.configurer_payload }
+
+    it "delegates to a stub builder" do
+      expect(stub_builder).to receive(:respond_with).with(response_payload)
+
+      builder.respond_with(response_payload)
+    end
+
+  end
+
+  describe "#trigger" do
+
+    context "when one triggered stub is provided" do
+
+      let(:trigger_builder) { instance_double(HttpStub::Configurer::Request::StubBuilder) }
+
+      it "delegates to a stub builder" do
+        expect(stub_builder).to receive(:trigger).with(trigger_builder)
+
+        builder.trigger(trigger_builder)
+      end
+
+    end
+
+    context "when many triggered stubs are provided" do
+
+      let(:trigger_builders) { (1..3).map { instance_double(HttpStub::Configurer::Request::StubBuilder) } }
+
+      it "delegates to a stub builder" do
+        expect(stub_builder).to receive(:trigger).with(trigger_builders)
+
+        builder.trigger(trigger_builders)
+      end
+
+    end
+
+  end
+
+  describe "#build" do
+
+    let(:stub_activator) { instance_double(HttpStub::Configurer::Request::StubActivator) }
+
+    subject { builder.build }
+
+    before(:example) { allow(HttpStub::Configurer::Request::StubActivator).to receive(:new).and_return(stub_activator) }
+
+    context "when a path on which the activator is activated is established" do
+
+      let(:activation_uri) { "http://some/activation/uri" }
+
+      before(:example) { builder.on(activation_uri) }
+
+      it "creates a stub activator that includes the activation uri" do
+        expect(HttpStub::Configurer::Request::StubActivator).to(
+          receive(:new).with(hash_including(activation_uri: activation_uri))
+        )
+
+        subject
+      end
+
+      it "builds the stub" do
+        expect(stub_builder).to receive(:build)
+
+        subject
+      end
+
+      it "creates a stub activator that includes the built stub" do
+        expect(HttpStub::Configurer::Request::StubActivator).to receive(:new).with(hash_including(stub: stub))
+
+        subject
+      end
+
+      it "returns the created stub activator" do
+        expect(subject).to eql(stub_activator)
+      end
+
+    end
+
+  end
+
+end

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

@@ -1,41 +1,43 @@
 describe HttpStub::Configurer::Request::StubActivator do
 
-  describe "#initialize" do
+  let(:activation_uri) { "some/activation/uri" }
+  let(:stub)           { instance_double(HttpStub::Configurer::Request::Stub) }
 
-    context "when provided a payload" do
+  let(:stub_activator) { HttpStub::Configurer::Request::StubActivator.new(activation_uri: activation_uri, stub: stub) }
 
-      let(:payload) { { payload_key: "payload value" } }
+  describe "#payload" do
 
-      let(:request) { HttpStub::Configurer::Request::StubActivator.new(payload) }
+    let(:stub_payload) { { stub_payload_key: "stub payload value " } }
 
-      it "creates a HTTP POST request" do
-        expect(request.method).to eql("POST")
-      end
+    subject { stub_activator.payload }
 
-      it "submits the request to '/stubs/activators'" do
-        expect(request.path).to eql("/stubs/activators")
-      end
+    before(:example) { allow(stub).to receive(:payload).and_return(stub_payload) }
 
-      it "sets the content type to json" do
-        expect(request.content_type).to eql("application/json")
-      end
-
-      it "sets the body to the JSON representation of the provided payload" do
-        expect(request.body).to eql(payload.to_json)
-      end
+    it "returns a hash containing the activation uri" do
+      expect(subject).to include(activation_uri: activation_uri)
+    end
 
+    it "returns a hash containing the stub payload" do
+      expect(subject).to include(stub_payload)
     end
 
   end
 
-  describe "#activation_uri" do
+  describe "#response_files" do
+
+    it "delegates to the stub" do
+      stub_response_files = (1..3).each { instance_double(HttpStub::Configurer::Request::StubResponseFile) }
+      allow(stub).to receive(:response_files).and_return(stub_response_files)
 
-    let(:activation_uri) { "http://some/activation/uri" }
+      expect(stub_activator.response_files).to eql(stub_response_files)
+    end
+
+  end
 
-    let(:request) { HttpStub::Configurer::Request::StubActivator.new(activation_uri: activation_uri) }
+  describe "#to_s" do
 
-    it "should return the activation uri from the payload" do
-      expect(request.activation_uri).to eql(activation_uri)
+    it "returns the activation uri" do
+      expect(stub_activator.to_s).to eql(activation_uri)
     end
 
   end

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

@@ -0,0 +1,154 @@
+describe HttpStub::Configurer::Request::StubBuilder do
+
+  let(:response_defaults) { {} }
+
+  let(:builder) { HttpStub::Configurer::Request::StubBuilder.new(response_defaults) }
+
+  shared_context "triggers one stub" do
+
+    let(:trigger_stub) { instance_double(HttpStub::Configurer::Request::Stub) }
+    let(:trigger_builder) do
+      instance_double(HttpStub::Configurer::Request::StubBuilder, build: trigger_stub)
+    end
+
+    before(:example) { builder.trigger(trigger_builder) }
+
+  end
+
+  shared_context "triggers many stubs" do
+
+    let(:trigger_stubs) { (1..3).map { instance_double(HttpStub::Configurer::Request::Stub) } }
+    let(:trigger_builders) do
+      trigger_stubs.map { |stub| instance_double(HttpStub::Configurer::Request::StubBuilder, build: stub) }
+    end
+
+    before(:example) { builder.trigger(trigger_builders) }
+
+  end
+
+  describe "#respond_with" do
+
+    it "does not modify any provided response defaults" do
+      original_response_defaults = response_defaults.clone
+
+      builder.respond_with(status: 201)
+
+      expect(response_defaults).to eql(original_response_defaults)
+    end
+
+  end
+
+  describe "#build" do
+
+    let(:fixture) { HttpStub::StubFixture.new }
+    let(:stub)    { instance_double(HttpStub::Configurer::Request::Stub) }
+
+    subject do
+      builder.match_requests(fixture.request.uri, fixture.request.symbolized)
+      builder.respond_with(fixture.response.symbolized)
+
+      builder.build
+    end
+
+    before(:example) { allow(HttpStub::Configurer::Request::Stub).to receive(:new).and_return(stub) }
+
+    context "when provided a request match and response data" do
+
+      it "creates a stub payload with request options that include the uri and the provided request options" do
+        expect_stub_to_be_created_with(request: { uri: fixture.request.uri }.merge(fixture.request.symbolized))
+
+        subject
+      end
+
+      it "creates a stub payload with response arguments" do
+        expect_stub_to_be_created_with(response: fixture.response.symbolized)
+
+        subject
+      end
+
+      context "when response default options are established" do
+
+        let(:response_defaults) { { some_options: "default value" } }
+
+        it "creates a stub payload with response arguments that includes the defaults" do
+          expect_stub_to_be_created_with(response: fixture.response.symbolized.merge(response_defaults))
+
+          subject
+        end
+
+        context "and response options provided match the defaults" do
+
+          let(:response_defaults) do
+            {
+              status:           203,
+              headers:          { "header-name-1" => "value 1", "header-name-2" => "value 2" },
+              body:             "some body",
+              delay_in_seconds: 8
+            }
+          end
+          let(:response_overrides) do
+            {
+              status:  302,
+              headers: { "header-name-2" => "updated value 2", "header-name-3" => "value 3" },
+              body:    "another body"
+            }
+          end
+
+          before(:example) { fixture.response = response_overrides }
+
+          it "overriddes the defaults with the provided options" do
+            expect_stub_to_be_created_with(
+              response: {
+                status:           302,
+                headers:          { "header-name-1" => "value 1",
+                                    "header-name-2" => "updated value 2",
+                                    "header-name-3" => "value 3" },
+                body:             "another body",
+                delay_in_seconds: 8
+              }
+            )
+
+            subject
+          end
+
+        end
+
+      end
+
+      context "when a trigger is added" do
+        
+        include_context "triggers one stub"
+
+        it "creates a stub payload with the provided trigger builder" do
+          expect_stub_to_be_created_with(triggers: [ trigger_builder ])
+
+          subject
+        end
+
+      end
+
+      context "when many triggers are added" do
+
+        include_context "triggers many stubs"
+
+        it "creates a stub payload with the provided trigger builders" do
+          expect_stub_to_be_created_with(triggers: trigger_builders)
+
+          subject
+        end
+
+      end
+
+      it "returns the created stub" do
+        expect(subject).to eql(stub)
+      end
+
+    end
+
+    def expect_stub_to_be_created_with(args)
+      expect(HttpStub::Configurer::Request::Stub).to receive(:new).with(hash_including(args))
+    end
+
+  end
+
+end

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

@@ -0,0 +1,136 @@
+describe HttpStub::Configurer::Request::StubResponse do
+
+  let(:stub_fixture) { HttpStub::StubFixture.new }
+  let(:fixture)      { stub_fixture.response }
+
+  let(:stub_response) { HttpStub::Configurer::Request::StubResponse.new(stub_fixture.id, fixture.symbolized) }
+
+  describe "#payload" do
+    
+    subject { stub_response.payload }
+
+    context "when a status response argument is provided" do
+
+      it "has a response entry for the argument" do
+        expect(subject).to include(status: fixture.status)
+      end
+
+    end
+
+    context "when no status response argument is provided" do
+
+      before(:example) { fixture.status = nil }
+
+      it "has a response entry with an empty status code" do
+        expect(subject).to include(status: "")
+      end
+
+    end
+
+    context "when response headers are provided" do
+
+      it "has a headers response entry containing the the provided headers" do
+        expect(subject).to include(headers: fixture.headers)
+      end
+
+    end
+
+    context "when response headers are omitted" do
+
+      before(:example) { fixture.headers = nil }
+
+      it "has a headers response entry containing an empty hash" do
+        expect(subject).to include(headers: {})
+      end
+
+    end
+
+    it "has an entry for the response body argument" do
+      expect(subject).to include(body: fixture.body)
+    end
+
+    context "when a delay option is provided" do
+
+      it "has a response entry for the argument" do
+        expect(subject).to include(delay_in_seconds: fixture.delay_in_seconds)
+      end
+
+    end
+
+    context "when a delay option is omitted" do
+
+      before(:example) { fixture.delay_in_seconds = nil }
+
+      it "has a response entry with an empty delay" do
+        expect(subject).to include(delay_in_seconds: "")
+      end
+
+    end
+
+  end
+
+  describe "#file" do
+
+    subject { stub_response.file }
+
+    context "when the body contains a file hash" do
+
+      let(:content_type) { "some-content-type" }
+      let(:file_path)    { "some/file/path" }
+      let(:file_name)    { "some_file.name" }
+
+      before(:example) do
+        fixture.headers = { "content-type" => content_type }
+        fixture.body    = { file: { path: file_path, name: file_name } }
+      end
+
+      it "creates a response file containing the stub id" do
+        expect_response_file_to_be_created_with(id: stub_fixture.id)
+
+        subject
+      end
+
+      it "creates a response file containing the provided file path" do
+        expect_response_file_to_be_created_with(path: file_path)
+
+        subject
+      end
+
+      it "creates a response file containing the provided file name" do
+        expect_response_file_to_be_created_with(name: file_name)
+
+        subject
+      end
+
+      it "creates a response file whose type is the content-type response header" do
+        expect_response_file_to_be_created_with(type: content_type)
+
+        subject
+      end
+
+      it "returns the created response file" do
+        response_file = instance_double(HttpStub::Configurer::Request::StubResponseFile)
+        allow(HttpStub::Configurer::Request::StubResponseFile).to receive(:new).and_return(response_file)
+
+        expect(subject).to eql(response_file)
+      end
+
+      def expect_response_file_to_be_created_with(hash)
+        expect(HttpStub::Configurer::Request::StubResponseFile).to receive(:new).with(hash_including(hash))
+      end
+
+    end
+
+    context "when the body contains text" do
+
+      before(:example) { fixture.body = "some text" }
+
+      it "returns nil" do
+        expect(subject).to be(nil)
+      end
+
+    end
+
+  end
+
+end