http_stub 0.27.0 → 0.28.0.beta1

data/spec/lib/http_stub/server/stub/response/attribute/body_spec.rb

@@ -1,98 +0,0 @@
-describe HttpStub::Server::Stub::Response::Attribute::Body do
-
-  let(:body) { described_class.new(stub_body) }
-
-  describe "#with_values_from" do
-
-    let(:request) { HttpStub::Server::Request::Request }
-
-    subject { body.with_values_from(request) }
-
-    context "when a body is provided" do
-
-      let(:stub_body) { "some stub body" }
-
-      it "interpolates the stub body with values from the request" do
-        expect(HttpStub::Server::Stub::Response::Attribute::Interpolator).to(
-          receive(:interpolate).with(stub_body, request)
-        )
-
-        subject
-      end
-
-      it "returns the interpolation result" do
-        interpolated_body = "some interpolated body"
-        allow(HttpStub::Server::Stub::Response::Attribute::Interpolator).to(
-          receive(:interpolate).and_return(interpolated_body)
-        )
-
-        expect(subject).to eql(interpolated_body)
-      end
-
-    end
-
-    context "when the body is nil" do
-
-      let(:stub_body) { nil }
-
-      it "returns nil" do
-        expect(subject).to eql(nil)
-      end
-
-    end
-
-  end
-
-  describe "#provided?" do
-
-    subject { body.provided? }
-
-    context "when the provided body is not nil" do
-
-      let(:stub_body) { "" }
-
-      it "returns true" do
-        expect(subject).to eql(true)
-      end
-
-    end
-
-    context "when the provided body is nil" do
-
-      let(:stub_body) { nil }
-
-      it "returns false" do
-        expect(subject).to eql(false)
-      end
-
-    end
-
-  end
-
-  describe "#to_s" do
-
-    subject { body.to_s }
-
-    context "when a body is provided" do
-
-      let(:stub_body) { "some stub body" }
-
-      it "returns the stub body" do
-        expect(subject).to eql(stub_body)
-      end
-
-    end
-
-    context "when the body is nil" do
-
-      let(:stub_body) { nil }
-
-      it "returns an empty string" do
-        expect(subject).to eql("")
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,73 +0,0 @@
-describe HttpStub::Server::Stub::Response::Attribute::Headers do
-
-  let(:stub_headers) { (1..3).each_with_object({}) { |i, result| result["key#{i}"] = "value #{i}" } }
-
-  let(:headers) { described_class.new(stub_headers) }
-
-  describe "#with_values_from" do
-
-    let(:request) { HttpStub::Server::Request::Request }
-
-    let(:interpolated_headers) do
-      stub_headers.keys.each_with_object({}).with_index do |(name, result), i|
-        result[name] = "interpolated value #{i + 1}"
-      end
-    end
-
-    subject { headers.with_values_from(request) }
-
-    it "interpolates each header value with values from the request" do
-      stub_headers.values.each do |header_value|
-        expect(HttpStub::Server::Stub::Response::Attribute::Interpolator).to(
-          receive(:interpolate).with(header_value, request)
-        )
-      end
-
-      subject
-    end
-
-    it "returns a hash containing the interpolated values" do
-      stub_headers.values.zip(interpolated_headers.values).each do |header_value, interpolated_value|
-        allow(HttpStub::Server::Stub::Response::Attribute::Interpolator).to(
-          receive(:interpolate).with(header_value, anything).and_return(interpolated_value)
-        )
-      end
-
-      expect(subject).to eql(interpolated_headers)
-    end
-
-    context "when a header value is a number" do
-
-      let(:stub_headers) { (1..3).each_with_object({}) { |i, result| result["key#{i}"] = i } }
-
-      it "does not interpolate any values" do
-        expect(HttpStub::Server::Stub::Response::Attribute::Interpolator).to_not receive(:interpolate)
-
-        subject
-      end
-
-      it "returns a hash containing the values unchanged" do
-        expect(subject).to eql(stub_headers)
-      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
-
-      stub_headers.each { |name, value| expect(result).to match(/#{name}:#{value}/) }
-    end
-
-    it "separates each header with comma for readability" do
-      expect(subject).to match(/key\d.value \d, key\d.value \d, key\d.value \d/)
-    end
-
-  end
-
-end

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

@@ -1,53 +0,0 @@
-describe HttpStub::Server::Stub::Response::Attribute::Interpolator::Headers do
-
-  describe "::interpolate" do
-
-    let(:request_headers) { instance_double(HttpStub::Server::Request::Headers) }
-    let(:request)         { instance_double(HttpStub::Server::Request::Request, headers: request_headers) }
-
-    subject { described_class.interpolate(value, request) }
-
-    context "when the value has header references" do
-
-      let(:value) do
-        "control:request.headers[name1] some text control:request.parameters[name1] control:request.headers[name2]"
-      end
-
-      context "and the headers are present in the request" do
-
-        before(:example) do
-          allow(request_headers).to receive(:[]).with("name1").and_return("value1")
-          allow(request_headers).to receive(:[]).with("name2").and_return("value2")
-        end
-
-        it "returns the value with the header references interpolated" do
-          expect(subject).to eql("value1 some text control:request.parameters[name1] value2")
-        end
-
-      end
-
-      context "and the headers are not present in the request" do
-
-        before(:example) { allow(request_headers).to receive(:[]).and_return(nil) }
-
-        it "returns the value with the header references removed" do
-          expect(subject).to eql(" some text control:request.parameters[name1] ")
-        end
-
-      end
-
-    end
-
-    context "when the value does not have header references" do
-
-      let(:value) { "some value without header references control:request.parameters[name1]" }
-
-      it "returns the value unchanged" do
-        expect(subject).to eql(value)
-      end
-
-    end
-
-  end
-
-end

data/spec/lib/http_stub/server/stub/response/attribute/interpolator/parameters_spec.rb

@@ -1,53 +0,0 @@
-describe HttpStub::Server::Stub::Response::Attribute::Interpolator::Parameters do
-
-  describe "::interpolate" do
-
-    let(:request_parameters) { instance_double(HttpStub::Server::Request::Parameters) }
-    let(:request)            { instance_double(HttpStub::Server::Request::Request, parameters: request_parameters) }
-
-    subject { described_class.interpolate(value, request) }
-
-    context "when the value has parameter references" do
-
-      let(:value) do
-        "control:request.parameters[name1] some text control:request.headers[name1] control:request.parameters[name2]"
-      end
-
-      context "and the parameters are present in the request" do
-
-        before(:example) do
-          allow(request_parameters).to receive(:[]).with("name1").and_return("value1")
-          allow(request_parameters).to receive(:[]).with("name2").and_return("value2")
-        end
-
-        it "returns the value with the parameter references interpolated" do
-          expect(subject).to eql("value1 some text control:request.headers[name1] value2")
-        end
-
-      end
-
-      context "and the parameters are not present in the request" do
-
-        before(:example) { allow(request_parameters).to receive(:[]).and_return(nil) }
-
-        it "returns the value with the parameter references removed" do
-          expect(subject).to eql(" some text control:request.headers[name1] ")
-        end
-
-      end
-
-    end
-
-    context "when the value does not have parameter references" do
-
-      let(:value) { "some value without parameter references control:request.headers[name1]" }
-
-      it "returns the value unchanged" do
-        expect(subject).to eql(value)
-      end
-
-    end
-
-  end
-
-end

data/spec/lib/http_stub/server/stub/response/attribute/interpolator_spec.rb

@@ -1,41 +0,0 @@
-describe HttpStub::Server::Stub::Response::Attribute::Interpolator do
-
-  describe "::interpolate" do
-
-    let(:value)   { "some value" }
-    let(:request) { instance_double(HttpStub::Server::Request::Request) }
-
-    subject { described_class.interpolate(value, request) }
-
-    it "interpolates header references in the provided value" do
-      expect(HttpStub::Server::Stub::Response::Attribute::Interpolator::Headers).to(
-        receive(:interpolate).with(value, request).and_return("")
-      )
-
-      subject
-    end
-
-    it "combines the result of header interpolation to include parameter interpolation" do
-      value_with_header_interpolation = "some value with header interpolation"
-      allow(HttpStub::Server::Stub::Response::Attribute::Interpolator::Headers).to(
-        receive(:interpolate).and_return(value_with_header_interpolation)
-      )
-      expect(HttpStub::Server::Stub::Response::Attribute::Interpolator::Parameters).to(
-        receive(:interpolate).with(value_with_header_interpolation, request)
-      )
-
-      subject
-    end
-
-    it "returns the result of parameter interpolation as the overall result" do
-      overall_result = "overall_result"
-      allow(HttpStub::Server::Stub::Response::Attribute::Interpolator::Parameters).to(
-        receive(:interpolate).and_return(overall_result)
-      )
-
-      expect(subject).to eql(overall_result)
-    end
-
-  end
-
-end

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

@@ -1,217 +0,0 @@
-describe HttpStub::Server::Stub::Response::Base do
-
-  let(:status)           { 202 }
-  let(:headers)          { nil }
-  let(:delay_in_seconds) { 18 }
-  let(:args)             { { "status" => status, "headers" => headers, "delay_in_seconds" => delay_in_seconds } }
-
-  let(:testable_response_class) { Class.new(described_class) }
-
-  let(:response) { testable_response_class.new(args) }
-
-  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 "defaults to 200" do
-          expect(response.status).to eql(200)
-        end
-
-      end
-
-    end
-
-    context "when the status is not provided in the arguments" do
-
-      let(:args) { { "headers" => headers } }
-
-      it "defaults to 200" do
-        expect(response.status).to eql(200)
-      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
-
-      context "that is an empty string" do
-
-        let(:delay_in_seconds) { "" }
-
-        it "defaults to 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(:args) { { "status" => status } }
-
-      it "defaults to 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 interpolateable headers" do
-      expect(response.headers).to be_a(HttpStub::Server::Stub::Response::Attribute::Headers)
-    end
-
-    context "when default headers have been added" do
-
-      let(:default_headers) do
-        { "a_default_header" => "a default value", "another_default_header" => "some other default value" }
-      end
-
-      before(:example) { testable_response_class.add_default_headers(default_headers) }
-
-      context "and headers are provided" do
-
-        context "that have some names matching the defaults" do
-
-          let(:headers) { { "a_default_header" => "an overridde value" } }
-
-          it "replaces the matching default values with those provided" do
-            expect(response_header_hash["a_default_header"]).to eql("an overridde value")
-          end
-
-          it "preserves the default values that do not match" do
-            expect(response_header_hash["another_default_header"]).to eql("some other default value")
-          end
-
-        end
-
-        context "that do not have names matching the defaults" do
-
-          let(:headers) do
-            {
-              "a_header" => "some header",
-              "another_header" => "another value",
-              "yet_another_header" => "yet another value"
-            }
-          end
-
-          it "returns the defaults headers combined with the provided headers" do
-            expect(response_header_hash).to eql(default_headers.merge(headers))
-          end
-
-        end
-
-      end
-
-      context "and no headers are provided" do
-
-        it "returns the default headers" do
-          expect(response_header_hash).to eql(default_headers)
-        end
-
-      end
-
-    end
-
-    context "when no default headers have been added" do
-
-      context "and 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
-
-  end
-
-  describe "#type" do
-
-    class HttpStub::Server::Stub::Response::TestableBaseClass < HttpStub::Server::Stub::Response::Base
-    end
-
-    let(:testable_response_class) { HttpStub::Server::Stub::Response::TestableBaseClass }
-
-    it "returns the name of the concrete base instance underscored" do
-      expect(response.type).to eql("testable_base_class")
-    end
-
-  end
-
-  describe "#to_hash" do
-
-    subject { response.to_hash }
-
-    it "contains the responses status" do
-      expect(subject).to include(status: response.status)
-    end
-
-    it "contains the responses headers" do
-      expect(subject).to include(headers: response.headers)
-    end
-
-    it "contains the responses delay in seconds" do
-      expect(subject).to include(delay_in_seconds: response.delay_in_seconds)
-    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