http_stub 0.13.5 → 0.14.0.rc1

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

@@ -2,179 +2,40 @@ describe HttpStub::Configurer::Request::Stub do
 
   describe "#initialize" do
 
-    context "when provided a uri and stub arguments" do
-
-      let(:uri) { "/some/uri" }
-      let(:stub_method) { "Some Method" }
-      let(:request_headers) { { "request_header_name" => "value" } }
-      let(:request_parameters) { { "parameter_name" => "value" } }
-      let(:response_status) { 500 }
-      let(:response_headers) { { "response_header_name" => "value" } }
-      let(:response_body) { "Some body" }
-      let(:response_delay_in_seconds) { 7 }
-
-      let(:stub_args) do
-        {
-            method: stub_method,
-            headers: request_headers,
-            parameters: request_parameters,
-            response: {
-                status: response_status,
-                headers: response_headers,
-                body: response_body,
-                delay_in_seconds: response_delay_in_seconds
-            }
-        }
-      end
+    context "when provided a payload" do
 
-      let(:request) { HttpStub::Configurer::Request::Stub.new(uri, stub_args) }
-      let(:request_body) { JSON.parse(request.body) }
+      let(:payload) { { payload_key: "payload value" } }
 
-      before(:each) { HttpStub::Configurer::Request::ControllableValue.stub(:format) }
+      let(:request) { HttpStub::Configurer::Request::Stub.new(payload) }
 
-      it "should create a HTTP POST request" do
-        request.method.should eql("POST")
+      it "creates a HTTP POST request" do
+        expect(request.method).to eql("POST")
       end
 
-      it "should submit the request to '/stubs'" do
-        request.path.should eql("/stubs")
+      it "submits the request to '/stubs'" do
+        expect(request.path).to eql("/stubs")
       end
 
-      it "should set the content type to json" do
-        request.content_type.should eql("application/json")
+      it "sets the content type to json" do
+        expect(request.content_type).to eql("application/json")
       end
 
-      context "when a request header argument is provided" do
-
-        it "should format the headers into control values" do
-          HttpStub::Configurer::Request::ControllableValue.should_receive(:format).with(request_headers)
-
-          request
-        end
-
+      it "sets the body to the JSON representation of the provided payload" do
+        expect(request.body).to eql(payload.to_json)
       end
 
-      context "when no request header is provided" do
-
-        let(:request_headers) { nil }
-
-        it "should format an empty header hash" do
-          HttpStub::Configurer::Request::ControllableValue.should_receive(:format).with({})
-
-          request
-        end
-
-      end
-
-      context "when a request parameter argument is provided" do
-
-        it "should format the request parameters into control values" do
-          HttpStub::Configurer::Request::ControllableValue.should_receive(:format).with(request_parameters)
-
-          request
-        end
-
-      end
-
-      context "when no request parameter argument is provided" do
-
-        let(:request_parameters) { nil }
-
-        it "should format an empty parameter hash" do
-          HttpStub::Configurer::Request::ControllableValue.should_receive(:format).with({})
-
-          request
-        end
-
-      end
-
-      context "generates a JSON body which" do
-
-        it "should have an entry containing the control value representation of the uri" do
-          HttpStub::Configurer::Request::ControllableValue.should_receive(:format).with(uri).and_return("uri as a string")
-
-          request_body.should include("uri" => "uri as a string")
-        end
-
-        it "should have an entry for the method argument" do
-          request_body.should include("method" => stub_method)
-        end
-
-        it "should have an entry containing the string representation of the request headers" do
-          HttpStub::Configurer::Request::ControllableValue.should_receive(:format)
-            .with(request_headers).and_return("request headers as string")
-
-          request_body.should include("headers" => "request headers as string")
-        end
-
-        it "should have an entry containing the string representation of the request parameters" do
-          HttpStub::Configurer::Request::ControllableValue.should_receive(:format)
-            .with(request_parameters).and_return("request parameters as string")
-
-          request_body.should include("parameters" => "request parameters as string")
-        end
-
-        context "when a status response argument is provided" do
-
-          it "should have a response entry for the argument" do
-            request_body["response"].should include("status" => response_status)
-          end
-
-        end
-
-        context "when no status response argument is provided" do
-
-          let(:response_status) { nil }
-
-          it "should have a response entry with an empty status code" do
-            request_body["response"].should include("status" => "")
-          end
-
-        end
-
-        it "should have an entry for the response body argument" do
-          request_body["response"].should include("body" => response_body)
-        end
-
-        context "when a delay argument is provided" do
-
-          it "should have a response entry for the argument" do
-            request_body["response"].should include("delay_in_seconds" => response_delay_in_seconds)
-          end
-
-        end
-
-        context "when a delay argument is not provided" do
-
-          let(:response_delay_in_seconds) { nil }
-
-          it "should have a response entry with an empty delay" do
-            request_body["response"].should include("delay_in_seconds" => "")
-          end
-
-        end
-
-        context "when response headers are provided" do
-
-          let(:response_headers) { { "response_header_name" => "value" } }
-
-          it "should have a headers response entry containing the the provided headers" do
-            request_body["response"]["headers"].should eql(response_headers)
-          end
-
-        end
+    end
 
-        context "when response headers are not provided" do
+  end
 
-          let (:response_headers) { nil }
+  describe "#stub_uri" do
 
-          it "should have a headers response entry containing an empty hash" do
-            request_body["response"]["headers"].should eql({})
-          end
-        end
+    let(:stub_uri) { "/some/stub/uri" }
 
-      end
+    let(:request) { HttpStub::Configurer::Request::Stub.new(uri: stub_uri) }
 
+    it "should return the uri from the payload" do
+      expect(request.stub_uri).to eql(stub_uri)
     end
 
   end

data/spec/lib/http_stub/configurer/server/buffered_command_processor_spec.rb

@@ -0,0 +1,35 @@
+describe HttpStub::Configurer::Server::BufferedCommandProcessor do
+
+  let(:command_processor) { instance_double(HttpStub::Configurer::Server::CommandProcessor) }
+
+  let(:buffered_command_processor) { HttpStub::Configurer::Server::BufferedCommandProcessor.new(command_processor) }
+
+  describe "#flush" do
+
+    subject { buffered_command_processor.flush }
+
+    describe "when a number of commands have been buffered via processing" do
+
+      let(:commands) { (1..3).map { instance_double(HttpStub::Configurer::Server::Command) } }
+
+      before(:example) { commands.each { |command| buffered_command_processor.process(command) } }
+
+      it "processes the buffered commands via the command processor" do
+        commands.each { |command| expect(command_processor).to receive(:process).with(command) }
+
+        subject
+      end
+
+    end
+
+    describe "when no commands have been buffered" do
+
+      it "executes without error" do
+        expect { subject }.not_to raise_error
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/configurer/server/command_processor_integration_spec.rb

@@ -0,0 +1,62 @@
+describe HttpStub::Configurer::Server::CommandProcessor do
+
+  let(:command) { HttpStub::Configurer::Server::Command.new(request: request, description: "performing an operation") }
+  let(:server_base_uri) { "http://localhost:8001" }
+
+  let(:configurer) do
+    double(HttpStub::Configurer, get_base_uri: server_base_uri, get_host: "localhost", get_port: 8001)
+  end
+
+  let(:command_processor) { HttpStub::Configurer::Server::CommandProcessor.new(configurer) }
+
+  describe "#process" do
+
+    subject { command_processor.process(command) }
+
+    context "when the server is running" do
+
+      include_context "server integration"
+
+      describe "and the server responds with a 200 response" do
+
+        let(:request) { Net::HTTP::Get.new("/stubs") }
+
+        it "executes without error" do
+          expect { subject }.not_to raise_error
+        end
+
+      end
+
+      describe "and the server responds with a non-200 response" do
+
+        let(:request) { Net::HTTP::Get.new("/causes_error") }
+
+        it "raises an exception that includes the server base URI" do
+          expect { subject }.to raise_error(/#{server_base_uri}/)
+        end
+
+        it "raises an exception that includes the commands description" do
+          expect { subject }.to raise_error(/performing an operation/)
+        end
+
+      end
+
+    end
+
+    context "when the server is unavailable" do
+
+      let(:request) { Net::HTTP::Get.new("/does/not/exist") }
+
+      it "raises an exception that includes the server base URI" do
+        expect { subject }.to raise_error(/#{server_base_uri}/)
+      end
+
+      it "raises an exception that includes the commands description" do
+        expect { subject }.to raise_error(/performing an operation/)
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/configurer/server/command_spec.rb

@@ -0,0 +1,25 @@
+describe HttpStub::Configurer::Server::Command do
+
+  let(:request)     { double("HttpRequest") }
+  let(:description) { "Some Description" }
+  let(:args)        { { request: request, description: description } }
+
+  let(:command) { HttpStub::Configurer::Server::Command.new(args) }
+
+  describe "#request" do
+
+    it "exposes the provided request" do
+      expect(command.request).to eql(request)
+    end
+
+  end
+
+  describe "#description" do
+
+    it "exposes the provided description" do
+      expect(command.description).to eql(description)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/configurer/server/dsl_spec.rb

@@ -0,0 +1,241 @@
+describe HttpStub::Configurer::Server::DSL do
+
+  let(:server_facade) { instance_double(HttpStub::Configurer::Server::Facade) }
+
+  let(:dsl) { HttpStub::Configurer::Server::DSL.new(server_facade) }
+
+  describe "#has_started!" do
+
+    it "informs the facade that the server has started" do
+      expect(server_facade).to receive(:server_has_started)
+
+      dsl.has_started!
+    end
+
+  end
+
+  describe "#build_stub" do
+
+    let(:stub_payload_builder) { instance_double(HttpStub::Configurer::Request::StubPayloadBuilder) }
+
+    before(:example) do
+      allow(HttpStub::Configurer::Request::StubPayloadBuilder).to receive(:new).and_return(stub_payload_builder)
+    end
+
+    it "creates a stub payload builder" do
+      expect(HttpStub::Configurer::Request::StubPayloadBuilder).to receive(:new)
+
+      dsl.build_stub
+    end
+
+    context "when a block is provided" do
+
+      let(:block) { lambda { |_stub| "some block" } }
+
+      subject { dsl.build_stub(&block) }
+
+      it "yields the created builder to the provided block" do
+        expect(block).to receive(:call).with(stub_payload_builder)
+
+        subject
+      end
+
+      it "returns the created builder" do
+        expect(subject).to eql(stub_payload_builder)
+      end
+
+    end
+
+    context "when a block is not provided" do
+
+      subject { dsl.build_stub }
+
+      it "returns the built stub" do
+        expect(subject).to eql(stub_payload_builder)
+      end
+
+    end
+
+  end
+
+  describe "#add_stub!" do
+
+    let(:stub_payload)         { { stub_payload_key: "stub payload value" } }
+    let(:stub_payload_builder) do
+      instance_double(HttpStub::Configurer::Request::StubPayloadBuilder, build: stub_payload)
+    end
+    let(:stub_request)         { instance_double(HttpStub::Configurer::Request::Stub) }
+
+    before(:example) do
+      allow(HttpStub::Configurer::Request::Stub).to receive(:new).and_return(stub_request)
+      allow(server_facade).to receive(:stub_response)
+    end
+
+    shared_examples_for "adding a stub payload" do
+
+      it "builds the stub payload" do
+        expect(stub_payload_builder).to receive(:build).and_return(stub_payload)
+
+        subject
+      end
+
+      it "creates a stub request with the built payload" do
+        expect(HttpStub::Configurer::Request::Stub).to receive(:new).with(stub_payload).and_return(stub_request)
+
+        subject
+      end
+
+      it "informs the server facade to stub the response" do
+        expect(server_facade).to receive(:stub_response).with(stub_request)
+
+        subject
+      end
+
+    end
+
+    context "when a stub payload builder is provided" do
+
+      subject { dsl.add_stub!(stub_payload_builder) }
+
+      it_behaves_like "adding a stub payload"
+
+    end
+
+    context "when a stub payload builder is not provided" do
+
+      let(:block) { lambda { |_stub| "some block" } }
+
+      before(:example) do
+        allow(HttpStub::Configurer::Request::StubPayloadBuilder).to receive(:new).and_return(stub_payload_builder)
+      end
+
+      subject { dsl.add_stub!(&block) }
+
+      it "creates a stub payload builder" do
+        expect(HttpStub::Configurer::Request::StubPayloadBuilder).to receive(:new)
+
+        subject
+      end
+
+      it "yields the created builder to the provided block" do
+        expect(block).to receive(:call).with(stub_payload_builder)
+
+        subject
+      end
+
+      it_behaves_like "adding a stub payload"
+
+    end
+
+  end
+
+  describe "#add_activator!" do
+
+    let(:stub_activator_payload)         { { activator_payload_key: "activator payload value" } }
+    let(:stub_activator_payload_builder) do
+      instance_double(HttpStub::Configurer::Request::StubActivatorPayloadBuilder, build: stub_activator_payload)
+    end
+    let(:stub_activator_request)         { instance_double(HttpStub::Configurer::Request::StubActivator) }
+
+    before(:example) do
+      allow(HttpStub::Configurer::Request::StubActivator).to receive(:new).and_return(stub_activator_request)
+      allow(server_facade).to receive(:stub_activator)
+    end
+
+    let(:block) { lambda { |_activator| "some block" } }
+
+    before(:example) do
+      allow(HttpStub::Configurer::Request::StubActivatorPayloadBuilder).to(
+        receive(:new).and_return(stub_activator_payload_builder)
+      )
+    end
+
+    subject { dsl.add_activator!(&block) }
+
+    it "creates a stub activator payload builder" do
+      expect(HttpStub::Configurer::Request::StubActivatorPayloadBuilder).to receive(:new)
+
+      subject
+    end
+
+    it "yields the created builder to the provided block" do
+      expect(block).to receive(:call).with(stub_activator_payload_builder)
+
+      subject
+    end
+
+    it "builds the stub activator payload" do
+      expect(stub_activator_payload_builder).to receive(:build).and_return(stub_activator_payload)
+
+      subject
+    end
+
+    it "creates a stub activator request with the built payload" do
+      expect(HttpStub::Configurer::Request::StubActivator).to(
+        receive(:new).with(stub_activator_payload).and_return(stub_activator_request)
+      )
+
+      subject
+    end
+
+    it "informs the server facade to submit the stub activator request" do
+      expect(server_facade).to receive(:stub_activator).with(stub_activator_request)
+
+      subject
+    end
+
+  end
+
+  describe "#activate!" do
+
+    let(:uri) { "/some/activation/uri" }
+
+    it "delegates to the server facade" do
+      expect(server_facade).to receive(:activate).with(uri)
+
+      dsl.activate!(uri)
+    end
+
+  end
+
+  describe "#remember_stubs" do
+
+    it "delegates to the server facade" do
+      expect(server_facade).to receive(:remember_stubs)
+
+      dsl.remember_stubs
+    end
+
+  end
+
+  describe "#recall_stubs!" do
+
+    it "delegates to the server facade" do
+      expect(server_facade).to receive(:recall_stubs)
+
+      dsl.recall_stubs!
+    end
+
+  end
+
+  describe "#clear_stubs!" do
+
+    it "delegates to the server facade" do
+      expect(server_facade).to receive(:clear_stubs)
+
+      dsl.clear_stubs!
+    end
+
+  end
+
+  describe "#clear_activators!" do
+
+    it "delegates to the server facade" do
+      expect(server_facade).to receive(:clear_activators)
+
+      dsl.clear_activators!
+    end
+
+  end
+
+end