http_stub 0.27.0 → 0.28.0.beta1

data/spec/lib/http_stub/server/stub/response/headers_spec.rb

@@ -0,0 +1,89 @@
+describe HttpStub::Server::Stub::Response::Headers do
+
+  let(:header_hash) { HttpStub::HeadersFixture.many }
+
+  let(:headers) { described_class.new(header_hash) }
+
+  it "is a hash with indifferent access in order to support merging of headers regardless of type" do
+    expect(headers).to be_a_kind_of(HashWithIndifferentAccess)
+  end
+
+  describe "::create" do
+
+    let(:body) { HttpStub::Server::Stub::Response::TextBodyFixture.text }
+
+    subject { described_class.create(header_hash, body) }
+
+    context "when headers whose keys are symbols are provided" do
+
+      let(:header_hash)      { HttpStub::HeadersFixture.many.symbolize_keys }
+      let(:stringified_keys) { header_hash.keys.map(&:to_s) }
+
+      it "returns headers containing the provided headers with keys converted to strings" do
+        expect(subject.values_at(*stringified_keys)).to eql(header_hash.values)
+      end
+
+      it "returns headers containing the bodies headers" do
+        expect(subject).to include(body.headers)
+      end
+
+    end
+
+    context "when nil headers are provided" do
+
+      let(:header_hash) { nil }
+
+      it "creates headers containing only the bodies headers" do
+        expect(subject).to eql(body.headers)
+      end
+
+    end
+
+  end
+
+  describe "constructor" do
+
+    subject { headers }
+
+    context "when headers whose keys are symbols are provided" do
+
+      let(:header_hash)      { HttpStub::HeadersFixture.many.symbolize_keys }
+      let(:stringified_keys) { header_hash.keys.map(&:to_s) }
+
+      it "returns headers containing the provided headers with keys converted to strings" do
+        expect(subject.values_at(*stringified_keys)).to eql(header_hash.values)
+      end
+
+    end
+
+    context "when headers whose keys are strings are provided" do
+
+      let(:header_hash) { HttpStub::HeadersFixture.many.stringify_keys }
+
+      it "returns headers containing the provided headers" do
+        expect(subject).to eql(header_hash)
+      end
+
+    end
+
+  end
+
+  describe "#to_s" do
+
+    subject { headers.to_s }
+
+    it "returns a string with each header name and value separated by ':'" do
+      result = subject
+
+      header_hash.each { |name, value| expect(result).to match(/#{name}:#{value}/) }
+    end
+
+    it "separates each header entry with a comma for readability" do
+      expected_expression = header_hash.map { |name, value| "#{name}.#{value}" }.join(", ")
+
+      expect(subject).to match(/#{expected_expression}/)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/stub/response/response_spec.rb

@@ -0,0 +1,342 @@
+describe HttpStub::Server::Stub::Response::Response do
+
+  let(:status)           { 202 }
+  let(:body)             { "" }
+  let(:headers)          { nil }
+  let(:delay_in_seconds) { 18 }
+  let(:blocks)           { nil }
+  let(:args)             do
+    { status: status, body: body, headers: headers, delay_in_seconds: delay_in_seconds, blocks: blocks }
+  end
+
+  let(:response) { described_class.new(args) }
+
+  describe "#status" do
+
+    subject { response.status }
+
+    context "when a value is provided in the arguments" do
+
+      context "that is an integer" do
+
+        it "returns the value provided" do
+          expect(subject).to eql(status)
+        end
+
+      end
+
+    end
+
+    context "when the status is not provided in the arguments" do
+
+      let(:args) { {} }
+
+      it "defaults to 200" do
+        expect(subject).to eql(200)
+      end
+
+    end
+
+  end
+
+  describe "#body" do
+
+    subject { response.body }
+
+    context "when a json argument is provided" do
+
+      let(:json) { "some json" }
+      let(:args) { HttpStub::Server::Stub::Response::TextBodyFixture.args_with_json(json) }
+
+      it "returns a text body" do
+        expect(subject).to be_an_instance_of(HttpStub::Server::Stub::Response::TextBody)
+      end
+
+      it "returns a body containing the json" do
+        expect(subject.to_s).to eql(json)
+      end
+
+    end
+
+    context "when a body argument is provided" do
+
+      let(:args) { { body: body } }
+
+      context "that contains text" do
+
+        let(:body) { "some text" }
+
+        it "returns a text body" do
+          expect(subject).to be_an_instance_of(HttpStub::Server::Stub::Response::TextBody)
+        end
+
+        it "returns a body containing the text" do
+          expect(subject.to_s).to eql(body)
+        end
+
+      end
+
+      context "that contains a file" do
+
+        let(:body) { HttpStub::Server::Stub::Response::FileBodyFixture.args }
+
+        it "returns a file body" do
+          expect(subject).to be_an_instance_of(HttpStub::Server::Stub::Response::FileBody)
+        end
+
+        it "returns a body containing the path to the file" do
+          expect(subject.to_s).to include(body.dig(:file, :path))
+        end
+
+      end
+
+    end
+
+    context "when no body arguments are provided" do
+
+      it "returns a text body" do
+        expect(subject).to be_an_instance_of(HttpStub::Server::Stub::Response::TextBody)
+      end
+
+      it "defaults to an empty body" do
+        expect(response.body.to_s).to eql("")
+      end
+
+    end
+
+  end
+
+  describe "#headers" do
+
+    let(:response_header_hash) { response.headers.to_hash }
+
+    it "has a well formatted string representation" do
+      expect(response.headers).to be_a(HttpStub::Server::Stub::Response::Headers)
+    end
+
+    context "when headers are provided" do
+
+      let(:headers) do
+        {
+          "a_header" => "some header",
+          "another_header" => "another value",
+          "yet_another_header" => "yet another value"
+        }
+      end
+
+      it "returns the headers" do
+        expect(response_header_hash).to eql(headers)
+      end
+
+    end
+
+    context "and no headers are provided" do
+
+      let(:headers) { nil }
+
+      it "returns an empty hash" do
+        expect(response_header_hash).to eql({})
+      end
+
+    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
+
+    end
+
+    context "when a value is not provided in the arguments" do
+
+      let(:args) { {} }
+
+      it "defaults to 0" do
+        expect(response.delay_in_seconds).to eql(0)
+      end
+
+    end
+
+  end
+
+  describe "#blocks" do
+
+    subject { response.blocks }
+
+    context "when a value is provided in the arguments" do
+
+      let(:blocks) { HttpStub::Server::Stub::Response::BlocksFixture.many }
+
+      it "provides a means of evaluating the blocks" do
+        expect(subject).to be_an_instance_of(HttpStub::Server::Stub::Response::Blocks)
+      end
+
+      it "contains the provided blocks" do
+        expect(subject.to_array).to eql(blocks.map(&:source))
+      end
+
+    end
+
+    context "when no blocks are provided" do
+
+      let(:args) { {} }
+
+      it "contains the provided blocks" do
+        expect(subject.to_array).to eql([])
+      end
+
+    end
+
+  end
+
+  describe "#with_values_from" do
+
+    let(:parameter_value) { "some parameter value"}
+    let(:parameters)      { { some_parameter: parameter_value } }
+    let(:request)         { HttpStub::Server::RequestFixture.create(parameters: parameters) }
+
+    subject { response.with_values_from(request) }
+
+    context "when no blocks are provided" do
+
+      it "returns a response" do
+        expect(subject).to be_an_instance_of(HttpStub::Server::Stub::Response::Response)
+      end
+
+      it "returns a response that is unchanged" do
+        expect(subject.to_json).to eql(response.to_json)
+      end
+
+    end
+
+    context "when blocks are provided" do
+
+      let(:simple_block_headers) { { some_header: "some header value", another_header: "another header value" } }
+      let(:simple_block)         do
+        lambda do
+          {
+            status:           400,
+            headers:          simple_block_headers,
+            body:             "First response body",
+            delay_in_seconds: 0
+          }
+        end
+      end
+      let(:interpolated_block_headers) do
+        { some_header: "some new header value", yet_another_header: "yet another header value" }
+      end
+      let(:interpolated_block)         do
+        lambda do |request|
+          {
+            status:           201,
+            headers:          interpolated_block_headers,
+            body:             "Body with parameter: #{request.parameters[:some_parameter]}",
+            delay_in_seconds: 7
+          }
+        end
+      end
+      let(:blocks) { [ simple_block, interpolated_block ] }
+
+      it "returns a response" do
+        expect(subject).to be_an_instance_of(HttpStub::Server::Stub::Response::Response)
+      end
+
+      it "returns a response whose values include those within the blocks" do
+        expect(subject.to_hash).to include(status: 201, delay_in_seconds: 7)
+      end
+
+      it "returns a response with headers that are combined from all blocks" do
+        expected_headers = {
+          some_header:         "some new header value",
+          another_header:      "another header value",
+          yet_another_header: "yet another header value"
+        }
+
+        expect(subject.to_hash).to include(headers: expected_headers)
+      end
+
+      it "returns a response whose values are interpolated from the request" do
+        expect(subject.to_hash[:body].to_s).to eql("Body with parameter: #{parameter_value}")
+      end
+
+    end
+
+  end
+
+  describe "#serve_on" do
+
+    let(:application) { instance_double(Sinatra::Base) }
+
+    subject { response.serve_on(application) }
+
+    before(:example) { allow(response).to receive(:sleep) }
+
+    it "uses the body to serve the response on the application" do
+      expect(response.body).to receive(:serve).with(application, response)
+
+      subject
+    end
+
+    it "waits for the delayed time in seconds before serving the response" do
+      expect(response).to receive(:sleep).with(delay_in_seconds).ordered
+      expect(response.body).to receive(:serve).ordered
+
+      subject
+    end
+
+  end
+
+  describe "#to_hash" do
+
+    subject { response.to_hash }
+
+    it "contains the status" do
+      expect(subject).to include(status: response.status)
+    end
+
+    it "contains the headers" do
+      expect(subject).to include(headers: response.headers)
+    end
+
+    it "contains the body" do
+      expect(subject).to include(body: response.body)
+    end
+
+    it "contains the delay in seconds" do
+      expect(subject).to include(delay_in_seconds: response.delay_in_seconds)
+    end
+
+    context "when blocks are provided" do
+
+      let(:blocks)            { HttpStub::Server::Stub::Response::BlocksFixture.many }
+      let(:blocks_as_strings) { blocks.map(&:source) }
+      let(:args)              { { blocks: blocks } }
+
+      it "contains a string respresentation of the blocks" do
+        expect(subject).to include(blocks: blocks_as_strings)
+      end
+
+    end
+
+  end
+
+  describe "#to_json" do
+
+    subject { response.to_json }
+
+    it "is the JSON representation of the responses hash" do
+      expect(subject).to eql(response.to_hash.to_json)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/stub/response/text_body_spec.rb

@@ -0,0 +1,138 @@
+describe HttpStub::Server::Stub::Response::TextBody do
+
+  let(:args) { HttpStub::Server::Stub::Response::TextBodyFixture.args_with_body }
+
+  let(:text_body) { described_class.new(args) }
+
+  describe "#headers" do
+
+    subject { text_body.headers }
+
+    context "when a json argument is provided" do
+
+      let(:args) { HttpStub::Server::Stub::Response::TextBodyFixture.args_with_json }
+
+      it "includes a content-type of application/json" do
+        expect(subject).to include("content-type" => "application/json")
+      end
+
+    end
+
+    context "when a body is provided" do
+
+      let(:args) { HttpStub::Server::Stub::Response::TextBodyFixture.args_with_body }
+
+      it "returns an empty hash" do
+        expect(subject).to eql({})
+      end
+
+    end
+
+    context "when neither a json argument or body is provided" do
+
+      let(:args) { {} }
+
+      it "returns an empty hash" do
+        expect(subject).to eql({})
+      end
+
+    end
+
+  end
+
+  describe "#text" do
+
+    subject { text_body.text }
+
+    context "when a json argument is provided" do
+
+      let(:args) { HttpStub::Server::Stub::Response::TextBodyFixture.args_with_json(json_value) }
+
+      context "that converts to json" do
+
+        let(:json_value) { "some json value" }
+
+        it "returns the json representation of the argument" do
+          expect(subject).to eql(json_value)
+        end
+
+      end
+
+      context "that does not convert to json" do
+
+        let(:json_value) { nil }
+
+        it "returns an empty string" do
+          expect(subject).to eql("")
+        end
+
+      end
+
+    end
+
+    context "when a body is provided" do
+
+      let(:args) { HttpStub::Server::Stub::Response::TextBodyFixture.args_with_body }
+
+      it "returns the body value" do
+        expect(subject).to eql(args[:body])
+      end
+
+    end
+
+    context "when neither JSON or a body is provided" do
+
+      let(:args) { {} }
+
+      it "returns an empty string" do
+        expect(subject).to eql("")
+      end
+
+    end
+
+  end
+
+  describe "#serve" do
+
+    let(:application) { instance_double(Sinatra::Base) }
+    let(:response)    { HttpStub::Server::Stub::ResponseBuilder.new.with_headers!.build }
+
+    subject { text_body.serve(application, response) }
+
+    it "halts processing of the applications request" do
+      expect(application).to receive(:halt)
+
+      subject
+    end
+
+    it "halts with the responses status" do
+      expect(application).to receive(:halt).with(response.status, anything, anything)
+
+      subject
+    end
+
+    it "halts with the hash representation of the responses headers" do
+      expect(application).to receive(:halt).with(anything, response.headers, anything)
+
+      subject
+    end
+
+    it "halts with the text bodys text" do
+      expect(application).to receive(:halt).with(anything, anything, text_body.text)
+
+      subject
+    end
+
+  end
+
+  describe "#to_s" do
+
+    subject { text_body.to_s }
+
+    it "returns the text" do
+      expect(subject).to eql(text_body.text)
+    end
+
+  end
+
+end