http_stub 0.14.2 → 0.15.0

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

@@ -1,304 +0,0 @@
-describe HttpStub::Configurer::Request::StubPayloadBuilder do
-
-  let(:response_defaults) { {} }
-
-  let(:builder) { HttpStub::Configurer::Request::StubPayloadBuilder.new(response_defaults) }
-
-  shared_context "triggers one stub" do
-
-    let(:trigger_payload) { { "trigger_key" => "trigger value" } }
-    let(:trigger_builder) do
-      instance_double(HttpStub::Configurer::Request::StubPayloadBuilder, build: trigger_payload)
-    end
-
-    before(:example) { builder.trigger(trigger_builder) }
-
-  end
-
-  shared_context "triggers many stubs" do
-
-    let(:trigger_payloads) { (1..3).map { |i| { "trigger_#{i}_key" => "trigger #{i} value" } } }
-    let(:trigger_builders) do
-      trigger_payloads.map do |payload|
-        instance_double(HttpStub::Configurer::Request::StubPayloadBuilder, build: payload)
-      end
-    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
-
-    context "when provided a request match and response data" do
-
-      include_context "stub payload builder arguments"
-
-      subject { builder.build }
-
-      before(:example) do
-        allow(HttpStub::Configurer::Request::ControllableValue).to receive(:format)
-
-        builder.match_requests(uri, request_options)
-        builder.respond_with(response_options)
-      end
-
-      context "when request header is provided" do
-
-        it "formats the headers into control values" do
-          expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with(request_headers)
-
-          subject
-        end
-
-      end
-
-      context "when no request header is provided" do
-
-        let(:request_headers) { nil }
-
-        it "formats an empty header hash" do
-          expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with({})
-
-          subject
-        end
-
-      end
-
-      context "when a request parameter is provided" do
-
-        it "formats the request parameters into control values" do
-          expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with(request_parameters)
-
-          subject
-        end
-
-      end
-
-      context "when no request parameter is provided" do
-
-        let(:request_parameters) { nil }
-
-        it "formats an empty parameter hash" do
-          expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with({})
-
-          subject
-        end
-
-      end
-
-      context "when many triggers are added" do
-        
-        include_context "triggers many stubs"
-
-        it "builds the payload for each trigger" do
-          trigger_builders.each { |trigger_builder| expect(trigger_builder).to receive(:build) }
-
-          subject
-        end
-
-      end
-
-      context "builds a request payload" do
-
-        it "has an entry containing the control value representation of the uri" do
-          allow(HttpStub::Configurer::Request::ControllableValue).to(
-            receive(:format).with(uri).and_return("uri as a string")
-          )
-
-          expect(subject).to include(uri: "uri as a string")
-        end
-
-        it "has an entry for the method option" do
-          expect(subject).to include(method: stub_method)
-        end
-
-        it "has an entry containing the string representation of the request headers" do
-          allow(HttpStub::Configurer::Request::ControllableValue).to(
-            receive(:format).with(request_headers).and_return("request headers as string")
-          )
-
-          expect(subject).to include(headers: "request headers as string")
-        end
-
-        it "has an entry containing the string representation of the request parameters" do
-          allow(HttpStub::Configurer::Request::ControllableValue).to(
-            receive(:format).with(request_parameters).and_return("request parameters as string")
-          )
-
-          expect(subject).to include(parameters: "request parameters as string")
-        end
-
-        context "when a status response argument is provided" do
-
-          it "has a response entry for the argument" do
-            expect(subject[:response]).to include(status: response_status)
-          end
-
-        end
-
-        context "when no status response argument is provided" do
-
-          let(:response_status) { nil }
-
-          it "has a response entry with an empty status code" do
-            expect(subject[:response]).to include(status: "")
-          end
-
-        end
-
-        context "when response headers are provided" do
-
-          let(:response_headers) { { response_header_name: "value" } }
-
-          it "has a headers response entry containing the the provided headers" do
-            expect(subject[:response]).to include(headers: response_headers)
-          end
-
-        end
-
-        context "when response headers are omitted" do
-
-          let (:response_headers) { nil }
-
-          it "has a headers response entry containing an empty hash" do
-            expect(subject[:response]).to include(headers: {})
-          end
-
-        end
-
-        it "has an entry for the response body argument" do
-          expect(subject[:response]).to include(body: response_body)
-        end
-
-        context "when a delay option is provided" do
-
-          it "has a response entry for the argument" do
-            expect(subject[:response]).to include(delay_in_seconds: response_delay_in_seconds)
-          end
-
-        end
-
-        context "when a delay option is omitted" do
-
-          let(:response_delay_in_seconds) { nil }
-
-          it "has a response entry with an empty delay" do
-            expect(subject[:response]).to include(delay_in_seconds: "")
-          end
-
-        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
-
-        end
-
-        context "when a root level response attribute is defaulted" do
-
-          let(:response_defaults) { { status: 204 } }
-
-          context "and is not overridden" do
-
-            let(:response_options) { {} }
-
-            it "assumes the defaulted value" do
-              expect(subject[:response]).to include(status: 204)
-            end
-
-          end
-
-          context "and is overridden" do
-
-            let(:response_status) { 302 }
-
-            it "assumes the override value" do
-              expect(subject[:response]).to include(status: 302)
-            end
-
-          end
-
-        end
-
-        context "when a nested response attribute is defaulted" do
-
-          let(:response_defaults) { { headers: { response_header_name: "default value" } } }
-
-          context "and the attribute has no other values defined" do
-
-            let(:response_headers) { {} }
-
-            it "assumes the defaults attributes" do
-              expect(subject[:response]).to include(response_defaults)
-            end
-
-          end
-
-          context "and the attribute has additional values defined" do
-
-            let(:response_headers) { { additional_header_name: "additional value" } }
-
-            it "includes the defaults values" do
-              expect(subject[:response][:headers]).to include(response_defaults[:headers])
-            end
-
-            it "includes the additional values" do
-              expect(subject[:response][:headers]).to include(response_headers)
-            end
-
-          end
-
-          context "and the attributes default values have been overridden" do
-
-            let(:response_headers) { { response_header_name: "override value"} }
-
-            it "assumes the defaults attributes" do
-              expect(subject[:response]).to include(headers: response_headers)
-            end
-
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/spec/lib/http_stub/controllers/stub_activator_controller_spec.rb

@@ -1,94 +0,0 @@
-describe HttpStub::Controllers::StubActivatorController do
-
-  let(:request_body) { "Some request body" }
-  let(:request) { double("HttpRequest", body: double("RequestBody", read: request_body)) }
-  let(:stub_activator_options) { double("StubActivatorOptions") }
-  let(:the_stub) { double(HttpStub::Models::Stub) }
-  let(:stub_activator) { double(HttpStub::Models::StubActivator, the_stub: the_stub) }
-  let(:stub_activator_registry) { double("HttpStub::Models::StubActivatorRegistry").as_null_object }
-  let(:stub_registry) { double("HttpStub::Models::StubRegistry").as_null_object }
-  let(:controller) { HttpStub::Controllers::StubActivatorController.new(stub_activator_registry, stub_registry) }
-
-  before(:example) { allow(JSON).to receive(:parse).and_return(stub_activator_options) }
-
-  describe "#register" do
-
-    before(:example) do
-      allow(HttpStub::Models::StubActivator).to receive(:new).and_return(stub_activator)
-    end
-
-    it "parses an options hash from the JSON request body" do
-      expect(JSON).to receive(:parse).with(request_body).and_return(stub_activator_options)
-
-      controller.register(request)
-    end
-
-    it "creates a stub activator from the parsed options" do
-      expect(HttpStub::Models::StubActivator).to receive(:new).with(stub_activator_options).and_return(stub_activator)
-
-      controller.register(request)
-    end
-
-    it "adds the created activator to the activator registry" do
-      expect(stub_activator_registry).to receive(:add).with(stub_activator, request)
-
-      controller.register(request)
-    end
-
-    it "returns a success response" do
-      expect(controller.register(request)).to eql(HttpStub::Models::Response::SUCCESS)
-    end
-
-  end
-
-  describe "#activate" do
-
-    describe "when a stub activator has been registered that is activated by the request" do
-
-      before(:example) do
-        allow(stub_activator_registry).to receive(:find_for).with(request).and_return(stub_activator)
-      end
-
-      it "adds the activators stub to the stub registry" do
-        expect(stub_registry).to receive(:add).with(the_stub, request)
-
-        controller.activate(request)
-      end
-
-      it "returns a success response" do
-        expect(controller.activate(request)).to eql(HttpStub::Models::Response::SUCCESS)
-      end
-
-    end
-
-    describe "when no stub activator is activated by the request" do
-
-      before(:example) do
-        allow(stub_activator_registry).to receive(:find_for).with(request).and_return(nil)
-      end
-
-      it "does not add a stub to the registry" do
-        expect(stub_registry).not_to receive(:add)
-
-        controller.activate(request)
-      end
-
-      it "returns an empty response" do
-        expect(controller.activate(request)).to eql(HttpStub::Models::Response::EMPTY)
-      end
-
-    end
-
-  end
-
-  describe "#clear" do
-
-    it "clears the activator registry" do
-      expect(stub_activator_registry).to receive(:clear).with(request)
-
-      controller.clear(request)
-    end
-
-  end
-
-end

data/spec/lib/http_stub/controllers/stub_controller_spec.rb

@@ -1,83 +0,0 @@
-describe HttpStub::Controllers::StubController do
-
-  let(:request_body) { "Some request body" }
-  let(:stub_options) { double("StubOptions") }
-  let(:request) { double("HttpRequest", body: double("RequestBody", read: request_body)) }
-  let(:response) { double(HttpStub::Models::Response) }
-  let(:the_stub) { double(HttpStub::Models::Stub, response: response) }
-  let(:registry) { double(HttpStub::Models::Registry).as_null_object }
-  let(:controller) { HttpStub::Controllers::StubController.new(registry) }
-
-  before(:example) { allow(JSON).to receive(:parse).and_return(stub_options) }
-
-  describe "#register" do
-
-    before(:example) do
-      allow(HttpStub::Models::Stub).to receive(:new).and_return(the_stub)
-    end
-
-    it "parses an options hash from the JSON request body" do
-      expect(JSON).to receive(:parse).with(request_body).and_return(stub_options)
-
-      controller.register(request)
-    end
-
-    it "creates a stub from the parsed options" do
-      expect(HttpStub::Models::Stub).to receive(:new).with(stub_options).and_return(the_stub)
-
-      controller.register(request)
-    end
-
-    it "adds the stub to the stub registry" do
-      expect(registry).to receive(:add).with(the_stub, request)
-
-      controller.register(request)
-    end
-
-    it "returns a success response" do
-      expect(controller.register(request)).to eql(HttpStub::Models::Response::SUCCESS)
-    end
-
-  end
-
-  describe "#replay" do
-
-    describe "when a stub has been registered that should be replayed for the request" do
-
-      before(:example) do
-        allow(registry).to receive(:find_for).with(request).and_return(the_stub)
-      end
-
-      it "returns the stubs response" do
-        expect(the_stub).to receive(:response).and_return(response)
-
-        expect(controller.replay(request)).to eql(response)
-      end
-
-    end
-
-    describe "when no stub should be replayed for the request" do
-
-      before(:example) do
-        allow(registry).to receive(:find_for).with(request).and_return(nil)
-      end
-
-      it "returns an empty response" do
-        expect(controller.replay(request)).to eql(HttpStub::Models::Response::EMPTY)
-      end
-
-    end
-
-  end
-
-  describe "#clear" do
-
-    it "clears the stub registry" do
-      expect(registry).to receive(:clear).with(request)
-
-      controller.clear(request)
-    end
-
-  end
-
-end

data/spec/lib/http_stub/models/request_pipeline_spec.rb

@@ -1,17 +0,0 @@
-describe HttpStub::Models::RequestPipeline do
-
-  let(:request_pipeline) { HttpStub::Models::RequestPipeline }
-
-  describe ".before_halt" do
-
-    let(:response) { double(HttpStub::Models::Response, delay_in_seconds: 5) }
-
-    it "sleeps for specified duration" do
-      expect(request_pipeline).to receive(:sleep).with(5)
-
-      request_pipeline.before_halt(response)
-    end
-
-  end
-
-end

data/spec/lib/http_stub/models/response_spec.rb

@@ -1,206 +0,0 @@
-describe HttpStub::Models::Response do
-
-  let(:status) { 202 }
-  let(:headers) { nil }
-  let(:body) { "A response body" }
-  let(:delay_in_seconds) { 18 }
-
-  let(:response) do
-    HttpStub::Models::Response.new(
-      "status" => status, "headers" => headers, "body" => body, "delay_in_seconds" => delay_in_seconds
-    )
-  end
-
-  describe "::SUCCESS" do
-
-    let(:response) { HttpStub::Models::Response::SUCCESS }
-
-    it "has a status of 200" do
-      expect(response.status).to eql(200)
-    end
-
-    it "has a body containing OK to visually indicate success to those interacting via a browser" do
-      expect(response.body).to match(/OK/)
-    end
-
-  end
-
-  describe "::ERROR" do
-
-    let(:response) { HttpStub::Models::Response::ERROR }
-
-    it "has a status of 404" do
-      expect(response.status).to eql(404)
-    end
-
-    it "has a body containing ERROR to visually indicate the error to those interacting via a browser" do
-      expect(response.body).to match(/ERROR/)
-    end
-
-  end
-
-  describe "#status" do
-
-    context "when a value is provided in the arguments" do
-
-      context "that is an integer" do
-
-        it "returns the value provided" do
-          expect(response.status).to eql(status)
-        end
-
-      end
-
-      context "that is an empty string" do
-
-        let(:status) { "" }
-
-        it "returns 200" do
-          expect(response.status).to eql(200)
-        end
-
-      end
-
-    end
-
-    context "when the status is not provided in the arguments" do
-
-      let(:response) { HttpStub::Models::Response.new("body" => body, "delay_in_seconds" => delay_in_seconds) }
-
-      it "returns 200" do
-        expect(response.status).to eql(200)
-      end
-
-    end
-
-  end
-
-  describe "#body" do
-
-    it "returns the value provided in the arguments" do
-      expect(response.body).to eql("A response body")
-    end
-
-  end
-
-  describe "#delay_in_seconds" do
-
-    context "when a value is provided in the arguments" do
-
-      context "that is an integer" do
-
-        it "returns the value" do
-          expect(response.delay_in_seconds).to eql(delay_in_seconds)
-        end
-
-      end
-
-      context "that is an empty string" do
-
-        let(:delay_in_seconds) { "" }
-
-        it "returns 0" do
-          expect(response.delay_in_seconds).to eql(0)
-        end
-
-      end
-
-    end
-
-    context "when a value is not provided in the arguments" do
-
-      let(:response) { HttpStub::Models::Response.new("status" => status, "body" => body) }
-
-      it "returns 0" do
-        expect(response.delay_in_seconds).to eql(0)
-      end
-
-    end
-
-  end
-
-  describe "#headers" do
-
-    let(:response_header_hash) { response.headers.to_hash }
-
-    it "is Headers" do
-      expect(response.headers).to be_a(HttpStub::Models::Headers)
-    end
-
-    context "when headers are provided" do
-
-      context "that include a content type" do
-
-        let(:headers) do
-          { "content-type" => "some/content/type", "some_header" => "some value", "another_header" => "another value" }
-        end
-
-        it "returns headers including the provided headers" do
-          expect(response_header_hash).to eql(headers)
-        end
-
-      end
-
-      context "that do not include a content type" do
-
-        let(:headers) do
-          {
-            "some_header" => "some value",
-            "another_header" => "another value",
-            "yet_another_header" => "yet another value"
-          }
-        end
-
-        it "returns headers including the provided headers" do
-          expect(response_header_hash).to include(headers)
-        end
-
-        it "returns headers including json as the default response content type" do
-          expect(response_header_hash).to include("content-type" => "application/json")
-        end
-
-      end
-
-    end
-
-    context "when no headers are provided" do
-
-      let(:headers) { nil }
-
-      it "returns headers containing json as the default response content type" do
-        expect(response_header_hash).to eql("content-type" => "application/json")
-      end
-
-    end
-
-  end
-
-  describe "#empty?" do
-
-    context "when the response is EMPTY" do
-
-      it "returns true" do
-        expect(HttpStub::Models::Response::EMPTY).to be_empty
-      end
-
-    end
-
-    context "when the response is not EMPTY but contains no values" do
-
-      it "returns true" do
-        expect(HttpStub::Models::Response.new).to be_empty
-      end
-
-    end
-
-    context "when the response is not EMPTY" do
-
-      it "returns false" do
-        expect(HttpStub::Models::Response::SUCCESS).not_to be_empty
-      end
-
-    end
-
-  end
-
-end