http_stub 0.22.4 → 0.23.0

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

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

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

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

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

@@ -2,13 +2,10 @@ describe HttpStub::Server::Stub::Response::Base do
 
   let(:status)           { 202 }
   let(:headers)          { nil }
-  let(:body)             { "A response body" }
   let(:delay_in_seconds) { 18 }
-  let(:args) do
-    { "status" => status, "headers" => headers, "body" => body, "delay_in_seconds" => delay_in_seconds }
-  end
+  let(:args)             { { "status" => status, "headers" => headers, "delay_in_seconds" => delay_in_seconds } }
 
-  let(:testable_response_class) { Class.new(HttpStub::Server::Stub::Response::Base) }
+  let(:testable_response_class) { Class.new(described_class) }
 
   let(:response) { testable_response_class.new(args) }
 
@@ -38,7 +35,7 @@ describe HttpStub::Server::Stub::Response::Base do
 
     context "when the status is not provided in the arguments" do
 
-      let(:args) { { "body" => body, "delay_in_seconds" => delay_in_seconds } }
+      let(:args) { { "headers" => headers } }
 
       it "defaults to 200" do
         expect(response.status).to eql(200)
@@ -48,14 +45,6 @@ describe HttpStub::Server::Stub::Response::Base do
 
   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
@@ -82,7 +71,7 @@ describe HttpStub::Server::Stub::Response::Base do
 
     context "when a value is not provided in the arguments" do
 
-      let(:args) { { "status" => status, "body" => body } }
+      let(:args) { { "status" => status } }
 
       it "defaults to 0" do
         expect(response.delay_in_seconds).to eql(0)
@@ -96,14 +85,8 @@ describe HttpStub::Server::Stub::Response::Base do
 
     let(:response_header_hash) { response.headers.to_hash }
 
-    it "is a readable hash" do
-      expect(response.headers).to be_a(HttpStub::Server::FormattedHash)
-    end
-
-    it "formats the hash with a ':' key value delimiter" do
-      expect(HttpStub::Server::FormattedHash).to receive(:new).with(anything, ":")
-
-      response.headers
+    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
@@ -203,34 +186,4 @@ describe HttpStub::Server::Stub::Response::Base do
 
   end
 
-  describe "#empty?" do
-
-    context "when the response is EMPTY" do
-
-      let(:response) { HttpStub::Server::Response::EMPTY }
-
-      it "returns true" do
-        expect(response).to be_empty
-      end
-
-    end
-
-    context "when the response is not EMPTY" do
-
-      it "returns false" do
-        expect(response).not_to be_empty
-      end
-
-    end
-
-  end
-
-  describe "#to_s" do
-
-    it "returns the string representation of the provided arguments" do
-      expect(response.to_s).to eql(args.to_s)
-    end
-
-  end
-
 end

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

@@ -4,13 +4,8 @@ describe HttpStub::Server::Stub::Response::File do
   let(:headers)        { {} }
   let(:file_name)      { "sample.txt" }
   let(:temp_file_path) { "#{HttpStub::Spec::RESOURCES_DIR}/#{file_name}" }
-  let(:args) do
-    {
-      "status" => status,
-      "headers" => headers,
-      "body" => { filename: file_name, tempfile: File.new(temp_file_path) }
-    }
-  end
+  let(:body)           { { filename: file_name, tempfile: File.new(temp_file_path) } }
+  let(:args)           { { "status" => status, "headers" => headers, "body" => body } }
 
   let(:response_file) { HttpStub::Server::Stub::Response::File.new(args) }
 
@@ -32,6 +27,52 @@ describe HttpStub::Server::Stub::Response::File do
 
   end
 
+  describe "#with_values_from" do
+
+    let(:request)              { instance_double(HttpStub::Server::Request::Request) }
+    let(:interpolated_headers) { { interpolated_header_name: "some interpolated header value" } }
+    let(:response_headers)     do
+      instance_double(HttpStub::Server::Stub::Response::Attribute::Headers, with_values_from: interpolated_headers)
+    end
+
+    subject { response_file.with_values_from(request) }
+
+    before(:example) do
+      allow(HttpStub::Server::Stub::Response::Attribute::Headers).to receive(:new).and_return(response_headers)
+      ensure_response_file_is_created!
+    end
+
+    it "interpolates headers with values from the request" do
+      expect(response_headers).to receive(:with_values_from).with(request)
+
+      subject
+    end
+
+    it "creates a new response file with the interpolated headers" do
+      expect(described_class).to receive(:new).with(hash_including("headers" => interpolated_headers))
+
+      subject
+    end
+
+    it "creates a new response file with other arguments preserved" do
+      expect(described_class).to receive(:new).with(hash_including("status" => status, "body" => body))
+
+      subject
+    end
+
+    it "returns the created file response" do
+      new_file_response = instance_double(described_class)
+      expect(described_class).to receive(:new).and_return(new_file_response)
+
+      expect(subject).to eql(new_file_response)
+    end
+
+    def ensure_response_file_is_created!
+      response_file
+    end
+
+  end
+
   describe "#serve_on" do
 
     let(:server) { instance_double(Sinatra::Base) }

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

@@ -3,14 +3,79 @@ describe HttpStub::Server::Stub::Response::Text do
   let(:status)  { 123 }
   let(:headers) { {} }
   let(:body)    { "Some text body" }
-  let(:args) { { "status" => status, "headers" => headers, "body" => body } }
+  let(:args)    { { "status" => status, "headers" => headers, "body" => body } }
 
   let(:response_text) { HttpStub::Server::Stub::Response::Text.new(args) }
 
+  describe "#body" do
+
+    it "returns the value provided in the arguments" do
+      expect(response_text.body).to eql("Some text body")
+    end
+
+  end
+
   it "is a base response" do
     expect(response_text).to be_a(HttpStub::Server::Stub::Response::Base)
   end
 
+  describe "#with_values_from" do
+
+    let(:request)              { instance_double(HttpStub::Server::Request::Request) }
+    let(:interpolated_headers) { { interpolated_header_name: "some interpolated header value" } }
+    let(:response_headers)     do
+      instance_double(HttpStub::Server::Stub::Response::Attribute::Headers, with_values_from: interpolated_headers)
+    end
+    let(:interpolated_body)    { "some interpolated body" }
+    let(:response_body)        do
+      instance_double(HttpStub::Server::Stub::Response::Attribute::Body, with_values_from: interpolated_body )
+    end
+
+    subject { response_text.with_values_from(request) }
+
+    before(:example) do
+      allow(HttpStub::Server::Stub::Response::Attribute::Headers).to receive(:new).and_return(response_headers)
+      allow(HttpStub::Server::Stub::Response::Attribute::Body).to receive(:new).and_return(response_body)
+      ensure_response_text_is_created!
+    end
+
+    it "interpolates headers with values from the request" do
+      expect(response_headers).to receive(:with_values_from).with(request)
+
+      subject
+    end
+
+    it "creates a new response text with the interpolated headers" do
+      expect(described_class).to receive(:new).with(hash_including("headers" => interpolated_headers))
+
+      subject
+    end
+
+    it "creates a new response text with the interpolated body" do
+      expect(described_class).to receive(:new).with(hash_including("body" => interpolated_body))
+
+      subject
+    end
+
+    it "creates a new response text with other arguments preserved" do
+      expect(described_class).to receive(:new).with(hash_including("status" => status))
+
+      subject
+    end
+
+    it "returns the created text response" do
+      new_text_response = instance_double(described_class)
+      expect(described_class).to receive(:new).and_return(new_text_response)
+
+      expect(subject).to eql(new_text_response)
+    end
+
+    def ensure_response_text_is_created!
+      response_text
+    end
+
+  end
+
   describe "#serve_on" do
 
     let(:server) { instance_double(Sinatra::Base) }