http_stub 0.27.0 → 0.28.0.beta1

data/spec/lib/http_stub/server/stub/match/rules_spec.rb

@@ -1,27 +1,27 @@
 describe HttpStub::Server::Stub::Match::Rules do
 
-  let(:header_payload) do
+  let(:method_arg) { :get }
+  let(:headers_arg) do
     {
-        "match_rule_header1" => "match_rule_header_value1",
-        "match_rule_header2" => "match_rule_header_value2",
-        "match_rule_header3" => "match_rule_header_value3"
+      match_rule_header1: "match_rule_header_value1",
+      match_rule_header2: "match_rule_header_value2",
+      match_rule_header3: "match_rule_header_value3"
     }
   end
-  let(:parameter_payload) do
+  let(:parameters_arg) do
     {
-        "match_rule_parameter1" => "match_rule_parameter_value1",
-        "match_rule_parameter2" => "match_rule_parameter_value2",
-        "match_rule_parameter3" => "match_rule_parameter_value3"
+      match_rule_parameter1: "match_rule_parameter_value1",
+      match_rule_parameter2: "match_rule_parameter_value2",
+      match_rule_parameter3: "match_rule_parameter_value3"
     }
   end
-  let(:method_payload) { "get" }
-  let(:match_rules_payload) do
+  let(:match_rules_args) do
     {
-      "uri" =>        "/a_path",
-      "method" =>     method_payload,
-      "headers" =>    header_payload,
-      "parameters" => parameter_payload,
-      "body" =>       { "schema" => { "json" => "stub schema definition" } }
+      uri:            "/a_path",
+      method:         method_arg,
+      headers:        headers_arg,
+      parameters:     parameters_arg,
+      body:           { schema: { json: "stub schema definition" } }
     }
   end
   let(:uri_rule)        { instance_double(HttpStub::Server::Stub::Match::Rule::Uri, matches?: true) }
@@ -30,7 +30,7 @@ describe HttpStub::Server::Stub::Match::Rules do
   let(:parameters_rule) { instance_double(HttpStub::Server::Stub::Match::Rule::Parameters, matches?: true) }
   let(:body_rule)       { double("HttpStub::Server::Stub::SomeRequestBody", matches?: true) }
 
-  let(:match_rules) { HttpStub::Server::Stub::Match::Rules.new(match_rules_payload) }
+  let(:match_rules) { described_class.new(match_rules_args) }
 
   before(:example) do
     allow(HttpStub::Server::Stub::Match::Rule::Uri).to receive(:new).and_return(uri_rule)
@@ -68,8 +68,8 @@ describe HttpStub::Server::Stub::Match::Rules do
 
   describe "#matches?" do
 
-    let(:request_method) { method_payload }
-    let(:request)        { instance_double(HttpStub::Server::Request::Request, method: method_payload) }
+    let(:request_method) { method_arg }
+    let(:request)        { instance_double(HttpStub::Server::Request::Request, method: method_arg) }
     let(:logger)         { instance_double(Logger) }
 
     subject { match_rules.matches?(request, logger) }

data/spec/lib/http_stub/server/stub/match/string_value_matcher_spec.rb

@@ -1,81 +1,28 @@
 describe HttpStub::Server::Stub::Match::StringValueMatcher do
 
-  let(:stub_value) { "some stub value" }
-
   describe "::match?" do
 
+    let(:stub_value)   { :some_stub_value }
     let(:actual_value) { "some actual value" }
 
     subject { described_class.match?(stub_value, actual_value) }
 
-    shared_examples_for "a StringValueMatcher that matches an expected stub value" do
-
-      it "determines if actual value should be omitted" do
-        expect(HttpStub::Server::Stub::Match::OmittedValueMatcher).to(
-          receive(:match?).with(expected_stub_match_value, actual_value)
-        )
-
-        subject
-      end
-
-      it "determines if the actual value matches a regular expression" do
-        expect(HttpStub::Server::Stub::Match::RegexpValueMatcher).to(
-          receive(:match?).with(expected_stub_match_value, actual_value)
-        )
-
-        subject
-      end
-
-      it "determines if the actual value exactly matches the stub value" do
-        expect(HttpStub::Server::Stub::Match::ExactValueMatcher).to(
-          receive(:match?).with(expected_stub_match_value, actual_value)
-        )
-
-        subject
-      end
-
-      it "determines if actual value should be omitted" do
-        expect(HttpStub::Server::Stub::Match::OmittedValueMatcher).to(
-          receive(:match?).with(expected_stub_match_value, actual_value)
-        )
-
-        subject
-      end
-
-      it "determines if the actual value matches a regular expression" do
-        expect(HttpStub::Server::Stub::Match::RegexpValueMatcher).to(
-          receive(:match?).with(expected_stub_match_value, actual_value)
-        )
-
-        subject
-      end
-
-      it "determines if the actual value exactly matches the stub value" do
-        expect(HttpStub::Server::Stub::Match::ExactValueMatcher).to(
-          receive(:match?).with(expected_stub_match_value, actual_value)
-        )
-
-        subject
-      end
+    it "determines if actual value matches by omission" do
+      expect(HttpStub::Server::Stub::Match::OmittedValueMatcher).to receive(:match?).with(stub_value, actual_value)
 
+      subject
     end
 
-    context "when the provided stub value is a string" do
-
-      let(:stub_value)                { "some stub value" }
-      let(:expected_stub_match_value) { "some stub value" }
-
-      it_behaves_like "a StringValueMatcher that matches an expected stub value"
+    it "determines if the actual value matches the stub value using a regular expression" do
+      expect(HttpStub::Server::Stub::Match::RegexpValueMatcher).to receive(:match?).with(stub_value, actual_value)
 
+      subject
     end
 
-    context "when the provided stub value is not a string" do
-
-      let(:stub_value)                { 88 }
-      let(:expected_stub_match_value) { "88" }
-
-      it_behaves_like "a StringValueMatcher that matches an expected stub value"
+    it "determines if the actual value exactly matches the stub value" do
+      expect(HttpStub::Server::Stub::Match::ExactValueMatcher).to receive(:match?).with(stub_value, actual_value)
 
+      subject
     end
 
     context "when an omitted match occurs" do

data/spec/lib/http_stub/server/stub/registry_integration_spec.rb

@@ -1,14 +1,14 @@
 describe HttpStub::Server::Stub::Registry, "integrating with real stubs" do
 
-  let(:memory_session) { HttpStub::Server::SessionFixture.memory }
+  let(:initial_stubs) { [] }
 
   let(:logger) { instance_double(Logger, info: nil) }
 
-  let(:stub_registry) { HttpStub::Server::Stub::Registry.new(memory_session) }
+  let(:stub_registry) { HttpStub::Server::Stub::Registry.new(initial_stubs) }
 
   shared_context "a stub is added" do
 
-    let(:added_stub) { create_stub(4) }
+    let(:added_stub) { HttpStub::Server::StubFixture.create(id: 4) }
 
     before(:example) { stub_registry.add(added_stub, logger) }
 
@@ -18,23 +18,21 @@ describe HttpStub::Server::Stub::Registry, "integrating with real stubs" do
 
     subject { stub_registry.reset(logger) }
 
-    context "when stubs have been added to the servers memory" do
+    context "when initial stubs were provided" do
 
-      let(:stubs) { (1..3).map { |i| create_stub(i) } }
-
-      before(:example) { stubs.each { |stub| memory_session.add_stub(stub, logger) } }
+      let(:initial_stubs) { (1..3).map { |i| HttpStub::Server::StubFixture.create(id: i) } }
 
       context "and a stub is subsequently added" do
 
         include_context "a stub is added"
 
-        it "retains stubs added to the servers memory" do
+        it "retains the initial stubs" do
           subject
 
-          expect(stub_registry.all).to eql(stubs)
+          expect(stub_registry.all).to include(*initial_stubs)
         end
 
-        it "rejects stubs not added to the servers memory" do
+        it "rejects stubs not initially present" do
           subject
 
           expect(stub_registry.all).not_to include(added_stub)
@@ -44,7 +42,9 @@ describe HttpStub::Server::Stub::Registry, "integrating with real stubs" do
 
     end
 
-    context "when no stubs have been added to the servers memory" do
+    context "when no initial stubs were provided" do
+
+      let(:initial_stubs) { [] }
 
       context "and a stub is subsequently added" do
 
@@ -62,21 +62,4 @@ describe HttpStub::Server::Stub::Registry, "integrating with real stubs" do
 
   end
 
-  def create_stub(number)
-    HttpStub::Server::Stub.create(
-      "uri" => "/uri#{number}",
-      "method" => "get",
-      "headers" => {"header_key_#{number}" => "header_value_#{number}"},
-      "parameters" => {"parameter_key_#{number}" => "parameter_value_#{number}"},
-      "response" => {
-        "status" => 200 + number,
-        "body" => "Body #{number}"
-      },
-      "triggers" => {
-        "scenario_names" => [],
-        "stubs"          => []
-      }
-    )
-  end
-
 end

data/spec/lib/http_stub/server/stub/registry_spec.rb

@@ -1,17 +1,16 @@
 describe HttpStub::Server::Stub::Registry do
 
-  let(:stubs_in_memory) { (1..3).map { instance_double(HttpStub::Server::Stub::Stub) } }
-  let(:memory_session)  { instance_double(HttpStub::Server::Session::Session, stubs: stubs_in_memory) }
+  let(:initial_stubs) { (1..3).map { HttpStub::Server::StubFixture.create } }
 
   let(:underlying_stub_registry) { instance_double(HttpStub::Server::Registry) }
   let(:logger)                   { instance_double(Logger) }
 
-  let(:stub_registry) { described_class.new(memory_session) }
+  let(:stub_registry) { described_class.new(initial_stubs) }
 
   before(:example) { allow(HttpStub::Server::Registry).to receive(:new).and_return(underlying_stub_registry) }
 
-  it "uses an underlying simple registry that is initialised with the memory sessions stubs" do
-    expect(HttpStub::Server::Registry).to receive(:new).with("stub", stubs_in_memory)
+  it "uses an underlying simple registry that is initialised with the initial stubs" do
+    expect(HttpStub::Server::Registry).to receive(:new).with("stub", initial_stubs)
 
     stub_registry
   end
@@ -114,14 +113,8 @@ describe HttpStub::Server::Stub::Registry do
 
     before(:example) { allow(underlying_stub_registry).to receive(:replace) }
 
-    it "retrieves the stubs in the memory session" do
-      expect(memory_session).to receive(:stubs)
-
-      subject
-    end
-
-    it "replaces the stubs in the underlying registry with those in the memory session" do
-      expect(underlying_stub_registry).to receive(:replace).with(stubs_in_memory, logger)
+    it "replaces the stubs in the underlying registry with those initially provided" do
+      expect(underlying_stub_registry).to receive(:replace).with(initial_stubs, logger)
 
       subject
     end

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

@@ -0,0 +1,64 @@
+describe HttpStub::Server::Stub::Response::Blocks do
+
+  let(:provided_blocks) { HttpStub::Server::Stub::Response::BlocksFixture.many }
+
+  let(:blocks) { described_class.new(provided_blocks) }
+
+  describe "#each" do
+
+    it "yields each provided block" do
+      yielded_blocks = []
+      blocks.each { |block| yielded_blocks << block }
+
+      expect(yielded_blocks).to eql(provided_blocks)
+    end
+
+  end
+
+  describe "#evaluate_with" do
+
+    let(:parameter_value) { "some parameter value" }
+    let(:parameters)      { { some_parameter: parameter_value } }
+    let(:request)         { HttpStub::Server::RequestFixture.create(parameters: parameters) }
+
+    let(:provided_blocks) do
+      [
+        lambda { |request| { key: "value with parameter: #{request.parameters[:some_parameter]}" } },
+        lambda { { hash: { nested_key: "nested value", another_nested_key: "another nested value" } } },
+        lambda { { hash: { nested_key: "new nested value", yet_another_nested_key: "yet another nested value" } } }
+      ]
+    end
+
+    subject { blocks.evaluate_with(request) }
+
+    it "merges the hashes composed by each block" do
+      expect(subject.keys).to eql(%i{ key hash })
+    end
+
+    it "interpolates values from the request" do
+      expect(subject).to include(key: "value with parameter: #{parameter_value}")
+    end
+
+    it "performs a nested merge of the hashes" do
+      expected_hash = {
+        nested_key:             "new nested value",
+        another_nested_key:     "another nested value",
+        yet_another_nested_key: "yet another nested value"
+      }
+
+      expect(subject).to include(hash: expected_hash)
+    end
+
+  end
+
+  describe "#to_array" do
+
+    subject { blocks.to_array }
+
+    it "returns the source of the provided blocks" do
+      expect(subject).to eql(provided_blocks.map(&:source))
+    end
+
+  end
+
+end

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

@@ -0,0 +1,52 @@
+describe HttpStub::Server::Stub::Response::Body do
+
+  describe "::create" do
+
+    subject { described_class.create(args) }
+
+    context "when a body argument containing text is provided" do
+
+      let(:args) { HttpStub::Server::Stub::Response::TextBodyFixture.args_with_body }
+
+      it "returns a text body" do
+        expect(subject).to be_an_instance_of(HttpStub::Server::Stub::Response::TextBody)
+      end
+
+      it "has text which is the value of the body" do
+        expect(subject.text).to eql(args[:body])
+      end
+
+    end
+
+    context "when a json argument is provided" do
+
+      let(:args) { HttpStub::Server::Stub::Response::TextBodyFixture.args_with_json }
+
+      it "returns a text body" do
+        expect(subject).to be_an_instance_of(HttpStub::Server::Stub::Response::TextBody)
+      end
+
+      it "has text which is the JSON representation of the value" do
+        expect(subject.text).to eql(args[:json].to_json)
+      end
+
+    end
+
+    context "when a body argument containing a file is provided" do
+
+      let(:args)      { { body: HttpStub::Server::Stub::Response::FileBodyFixture.args } }
+      let(:file_path) { args[:body][:file][:path] }
+
+      it "returns a file body" do
+        expect(subject).to be_an_instance_of(HttpStub::Server::Stub::Response::FileBody)
+      end
+
+      it "has a uri which includes the path to the file" do
+        expect(subject.uri).to include(file_path)
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,117 @@
+describe HttpStub::Server::Stub::Response::FileBody do
+
+  let(:args)      { HttpStub::Server::Stub::Response::FileBodyFixture.args }
+  let(:file_path) { args[:file][:path] }
+
+  let(:file_body) { described_class.new(args) }
+
+  describe "#headers" do
+
+    subject { file_body.headers }
+
+    it "includes a content-type of application/octet-stream" do
+      expect(subject).to include("content-type" => "application/octet-stream")
+    end
+
+  end
+
+  describe "#uri" do
+
+    subject { file_body.uri }
+
+    it "returns the url to the file navigable by a browser" do
+      expect(subject).to eql("file://#{file_path}")
+    end
+
+  end
+
+  describe "#serve" do
+
+    let(:content_type) { "plain/text" }
+    let(:headers)      { { "content-type" => content_type } }
+    let(:response)     { HttpStub::Server::Stub::ResponseBuilder.new.with_headers!(headers).build }
+    let(:application)  { instance_double(Sinatra::Base) }
+
+    subject { file_body.serve(application, response) }
+
+    it "sends the file via the application" do
+      expect(application).to receive(:send_file).with(file_path, anything)
+
+      subject
+    end
+
+    it "sends the file without any provided response status to ensure that 304 responses are honoured" do
+      expect(application).to receive(:send_file).with(anything, hash_excluding(:status))
+
+      subject
+    end
+
+    it "sends the file with a type that is the configured content type" do
+      expect(application).to receive(:send_file).with(anything, hash_including(type: content_type))
+
+      subject
+    end
+
+    context "when a last modified header is configured in the stub response" do
+
+      let(:last_modified_date) { "Thu, 14 May 2015 12:56:00 GMT" }
+      let(:headers)            { { "last-modified" => last_modified_date } }
+
+      it "sends the file with the last modified date" do
+        expect(application).to receive(:send_file).with(anything, hash_including(last_modified: last_modified_date))
+
+        subject
+      end
+
+    end
+
+    context "when no last modified header is configured in the stub response" do
+
+      let(:headers) { {} }
+
+      it "sends the file without a last modified date" do
+        expect(application).to receive(:send_file).with(anything, hash_excluding(:last_modified))
+
+        subject
+      end
+
+    end
+
+    context "when a content disposition header is configured in the stub response" do
+
+      let(:content_disposition) { "attachment" }
+      let(:headers)             { { "content-disposition" => content_disposition } }
+
+      it "sends the file with a disposition whose value is the configured content disposition" do
+        expect(application).to receive(:send_file).with(anything, hash_including(disposition: content_disposition))
+
+        subject
+      end
+
+    end
+
+    context "when a content disposition header is not configured in the stub response" do
+
+      let(:headers) { {} }
+
+      it "sends the file without a disposition" do
+        expect(application).to receive(:send_file).with(anything, hash_excluding(:disposition))
+
+        subject
+      end
+
+    end
+
+  end
+
+  describe "#to_s" do
+
+    subject { file_body.to_s }
+
+    it "returns the uri" do
+      expect(subject).to eql(file_body.uri)
+    end
+
+  end
+
+end