http_stub 0.27.0 → 0.28.0.beta1

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

@@ -1,231 +0,0 @@
-describe HttpStub::Configurer::Request::Stub do
-
-  let(:fixture)          { HttpStub::StubFixture.new }
-  let(:stub_response)    { instance_double(HttpStub::Configurer::Request::StubResponse) }
-  let(:stub_triggers)    { instance_double(HttpStub::Configurer::Request::Triggers) }
-
-  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) 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
-
-      context "are provided" do
-
-        it "formats the headers into control values" do
-          expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with(fixture.request.headers)
-
-          subject
-        end
-
-      end
-
-      context "are not provided" do
-
-        before(:example) { fixture.request.headers = nil }
-
-        it "formats an empty header hash" do
-          expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with({})
-
-          subject
-        end
-
-      end
-
-    end
-
-    context "when request parameters" do
-
-      context "are provided" do
-
-        it "formats the request parameters into control values" do
-          expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with(fixture.request.parameters)
-
-          subject
-        end
-
-      end
-
-      context "are not provided" do
-
-        before(:example) { fixture.request.parameters = nil }
-
-        it "formats an empty parameter hash" do
-          expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with({})
-
-          subject
-        end
-
-      end
-
-    end
-
-    context "when a request body" do
-
-      context "is provided" do
-
-        it "formats the request body into a control value" do
-          expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with(fixture.request.body)
-
-          subject
-        end
-
-      end
-
-      context "is not provided" do
-
-        before(:example) { fixture.request.body = nil }
-
-        it "formats an empty parameter hash" do
-          expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with({})
-
-          subject
-        end
-
-      end
-
-    end
-
-    it "creates a stub response with the provided response options" do
-      expect(HttpStub::Configurer::Request::StubResponse).to(
-        receive(:new).with(anything, fixture.configurer_payload[:response]).and_return(stub_response)
-      )
-
-      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
-
-      it "has an entry containing the control value representation of the uri" do
-        allow(HttpStub::Configurer::Request::ControllableValue).to(
-          receive(:format).with(fixture.request.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: fixture.request.http_method)
-      end
-
-      it "has an entry containing the string representation of the request headers" do
-        allow(HttpStub::Configurer::Request::ControllableValue).to(
-          receive(:format).with(fixture.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(fixture.request.parameters).and_return("request parameters as string")
-        )
-
-        expect(subject).to include(parameters: "request parameters as string")
-      end
-
-      it "has an entry containing the response payload" do
-        allow(stub_response).to receive(:payload).and_return("response payload")
-
-        expect(subject).to include(response: "response payload")
-      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
-
-  end
-
-  describe "#response_files" do
-
-    let(:stub_response_file)      { nil }
-    let(:triggers_response_files) { [] }
-
-    subject { stub.response_files }
-
-    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 "when the response contains a file" do
-
-      let(:stub_response_file) { instance_double(HttpStub::Configurer::Request::StubResponseFile) }
-
-      let(:triggers_response_files) { [] }
-
-      it "includes the stub response's file" do
-        expect(subject).to include(stub_response_file)
-      end
-
-    end
-
-    context "when the triggers contain files" do
-
-      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 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
-
-      it "is all the files" do
-        expect(subject).to eql(([ stub_response_file ] + triggers_response_files).flatten)
-      end
-
-    end
-
-    context "when neither the response or triggers contain files" do
-
-      it "returns an empty array" do
-        expect(subject).to eql([])
-      end
-
-    end
-
-  end
-
-  describe "#to_s" do
-
-    it "returns the request uri" do
-      expect(stub.to_s).to eql(fixture.request.uri)
-    end
-
-  end
-
-end

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

@@ -1,101 +0,0 @@
-describe HttpStub::Configurer::Request::Triggers do
-
-  let(:scenario_names) { (1..3).map { |i| "Some scenario #{i}" } }
-  let(:stubs)          { (1..3).map { instance_double(HttpStub::Configurer::Request::Stub) } }
-
-  let(:triggers) { HttpStub::Configurer::Request::Triggers.new(scenario_names: scenario_names, stubs: stubs) }
-
-  describe "#response_files" do
-
-    let(:stubs)                   do
-      response_files_per_stub.map do |response_files|
-        instance_double(HttpStub::Configurer::Request::Stub, response_files: response_files)
-      end
-    end
-
-    subject { triggers.response_files }
-
-    context "when many stubs contains response files" do
-
-      let(:response_files_per_stub) do
-        (1..3).map { (1..3).map { HttpStub::Configurer::Request::StubResponseFile } }
-      end
-
-      it "returns all the response files" do
-        expect(subject).to eql(response_files_per_stub.flatten)
-      end
-
-    end
-
-    context "when one stub contains response files" do
-
-      let(:response_files)          { (1..3).map { HttpStub::Configurer::Request::StubResponseFile } }
-      let(:response_files_per_stub) { (1..3).map { |i| i % 2 == 0 ? response_files : [] } }
-
-      it "returns the response files" do
-        expect(subject).to eql(response_files)
-      end
-
-    end
-
-    context "when no stubs contain response files" do
-
-      let(:response_files_per_stub) { (1..3).map { [] } }
-
-      it "returns an empty array" do
-        expect(subject).to eql([])
-      end
-
-    end
-
-  end
-
-  describe "#payload" do
-
-    let(:stub_payloads) { stubs.each_with_index.map { |i| "Stub payload #{i}" } }
-
-    subject { triggers.payload }
-
-    before(:example) do
-      stubs.zip(stub_payloads).each { |stub, payload| allow(stub).to receive(:payload).and_return(payload) }
-    end
-
-    context "when scenario names are provided" do
-
-      it "has a scenario names entry containing the names" do
-        expect(subject).to include(scenario_names: scenario_names)
-      end
-
-    end
-
-    context "when no scenario names are provided" do
-
-      let(:scenario_names) { [] }
-
-      it "has an scenario names entry that is empty" do
-        expect(subject).to include(scenario_names: [])
-      end
-
-    end
-
-    context "when stubs are provided" do
-
-      it "has a stubs entry containing the payload of the stubs" do
-        expect(subject).to include(stubs: stub_payloads)
-      end
-
-    end
-
-    context "when stub are not provided" do
-
-      let(:stubs) { [] }
-
-      it "has a stubs entry that is empty" do
-        expect(subject).to include(stubs: [])
-      end
-
-    end
-
-  end
-
-end

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

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

@@ -1,75 +0,0 @@
-describe HttpStub::Configurer::Server::CommandProcessor do
-
-  let(:server_host)     { "localhost" }
-  let(:server_port)     { 8001 }
-  let(:server_base_uri) { "http://#{server_host}:#{server_port}" }
-  let(:configuration)   do
-    double(HttpStub::Configurer::Server::Configuration, base_uri: server_base_uri, host: server_host, port: server_port)
-  end
-
-  let(:command_processor) { HttpStub::Configurer::Server::CommandProcessor.new(configuration) }
-
-  describe "#process" do
-
-    let(:command) do
-      HttpStub::Configurer::Server::Command.new(request: request, description: "performing an operation")
-    end
-
-    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) { create_get_request("stubs") }
-
-        it "executes without error" do
-          expect { subject }.not_to raise_error
-        end
-
-        it "returns the server response" do
-          expect(subject).to be_a(Net::HTTPResponse)
-        end
-
-      end
-
-      describe "and the server responds with a non-200 response" do
-
-        let(:request) { create_get_request("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
-
-      subject { command_processor.process(command, open_timeout: 1) }
-
-      let(:request) { create_get_request("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
-
-    def create_get_request(path)
-      HttpStub::Configurer::Request::Http::Basic.new(method: :get, path: path)
-    end
-
-  end
-
-end

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

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