http_stub 0.22.4 → 0.23.0

data/spec/lib/http_stub/server/stub/match/rule/json_body_spec.rb

@@ -1,13 +1,13 @@
 describe HttpStub::Server::Stub::Match::Rule::JsonBody do
 
-  let(:stubbed_schema_definition) { { "type" => "object", "properties" => { "some_property" => "some_type" } } }
+  let(:stub_schema_definition) { { "type" => "object", "properties" => { "some_property" => "some_type" } } }
 
-  let(:json_body) { described_class.new(stubbed_schema_definition) }
+  let(:json_body) { described_class.new(stub_schema_definition) }
 
   describe "#matches?" do
 
     let(:request_body) { { "some_json_property" => "some_json_value" }.to_json }
-    let(:request)      { instance_double(HttpStub::Server::Request, body: request_body) }
+    let(:request)      { instance_double(HttpStub::Server::Request::Request, body: request_body) }
     let(:logger)       { instance_double(Logger, info: nil) }
 
     let(:validation_errors) { [] }
@@ -17,7 +17,7 @@ describe HttpStub::Server::Stub::Match::Rule::JsonBody do
     before(:example) { allow(JSON::Validator).to receive(:fully_validate).and_return(validation_errors) }
 
     it "validates the request body using the stubbed schema definition" do
-      expect(JSON::Validator).to receive(:fully_validate).with(stubbed_schema_definition, request_body, anything)
+      expect(JSON::Validator).to receive(:fully_validate).with(stub_schema_definition, request_body, anything)
 
       subject
     end
@@ -93,7 +93,7 @@ describe HttpStub::Server::Stub::Match::Rule::JsonBody do
     subject { json_body.to_s }
 
     it "returns the JSON representation of the schema definition" do
-      expect(subject).to eql(stubbed_schema_definition.to_json)
+      expect(subject).to eql(stub_schema_definition.to_json)
     end
 
   end

data/spec/lib/http_stub/server/stub/match/rule/method_spec.rb

@@ -1,20 +1,20 @@
 describe HttpStub::Server::Stub::Match::Rule::Method do
 
-  let(:raw_stub_method) { "put" }
+  let(:stub_method) { "put" }
 
-  let(:the_method) { described_class.new(raw_stub_method) }
+  let(:the_method) { described_class.new(stub_method) }
 
   describe "#matches?" do
 
     let(:request_method) { "get" }
-    let(:request)        { instance_double(HttpStub::Server::Request, method: request_method) }
+    let(:request)        { instance_double(HttpStub::Server::Request::Request, method: request_method) }
     let(:logger)         { instance_double(Logger) }
 
     subject { the_method.matches?(request, logger) }
 
     context "when the request method is identical to the stub method" do
 
-      let(:request_method) { raw_stub_method }
+      let(:request_method) { stub_method }
 
       it "returns true" do
         expect(subject).to be(true)
@@ -22,9 +22,9 @@ describe HttpStub::Server::Stub::Match::Rule::Method do
 
     end
 
-    context "when the request method and stub method are the the same value but have different casing" do
+    context "when the stub method and request method are the the same value but have different casing" do
 
-      let(:raw_stub_method) { "GET" }
+      let(:stub_method) { "GET" }
 
       it "returns true" do
         expect(subject).to be(true)
@@ -36,7 +36,7 @@ describe HttpStub::Server::Stub::Match::Rule::Method do
 
       context "with a nil value" do
 
-        let(:raw_stub_method) { nil }
+        let(:stub_method) { nil }
 
         it "returns true" do
           expect(subject).to be(true)
@@ -46,7 +46,7 @@ describe HttpStub::Server::Stub::Match::Rule::Method do
 
       context "with an empty string" do
 
-        let(:raw_stub_method) { "" }
+        let(:stub_method) { "" }
 
         it "returns true" do
           expect(subject).to be(true)
@@ -56,10 +56,10 @@ describe HttpStub::Server::Stub::Match::Rule::Method do
 
     end
 
-    context "when the request method is different to the stub method" do
+    context "when the stub method is different to the request method" do
 
+      let(:stub_method)     { "delete" }
       let(:request_method)  { "get" }
-      let(:raw_stub_method) { "delete" }
 
       it "returns false" do
         expect(subject).to be(false)
@@ -71,22 +71,24 @@ describe HttpStub::Server::Stub::Match::Rule::Method do
 
   describe "#to_s" do
 
-    context "when the stub method provided is not nil" do
+    subject { the_method.to_s }
 
-      let(:raw_stub_method) { "not_nil" }
+    context "when the stub method is not nil" do
 
-      it "returns the stub method provided" do
-        expect(the_method.to_s).to eql(raw_stub_method)
+      let(:stub_method) { "present" }
+
+      it "returns the stub method" do
+        expect(subject).to eql(stub_method)
       end
 
     end
 
-    context "when the stub method provided is nil" do
+    context "when the stub method is nil" do
 
-      let(:raw_stub_method) { nil }
+      let(:stub_method) { nil }
 
       it "returns an empty string" do
-        expect(the_method.to_s).to eql("")
+        expect(subject).to eql("")
       end
 
     end

data/spec/lib/http_stub/server/stub/match/rule/parameters_spec.rb

@@ -1,64 +1,57 @@
 describe HttpStub::Server::Stub::Match::Rule::Parameters do
 
-  let(:raw_request_parameters) { double("RequestParameters") }
-  let(:request)                { instance_double(HttpStub::Server::Request, parameters: raw_request_parameters) }
+  let(:stub_parameters) { (1..3).each_with_object({}) { |i, result| result["key#{i}"] = "value#{i}" } }
 
-  let(:stubbed_parameters)            { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
-  let(:regexpable_stubbed_paremeters) do
-    double(HttpStub::Server::Stub::Match::HashWithStringValueMatchers).as_null_object
-  end
+  let(:parameters) { described_class.new(stub_parameters) }
 
-  let(:request_parameters) { described_class.new(stubbed_parameters) }
+  it "is a hash with indifferent access" do
+    expect(parameters).to be_a(::HashWithIndifferentAccess)
+  end
 
-  describe "when stubbed parameters are provided" do
+  context "when no parameters are provided" do
 
-    it "creates a regexpable representation of the stubbed parameters" do
-      expect(HttpStub::Server::Stub::Match::HashWithStringValueMatchers).to receive(:new).with(stubbed_parameters)
+    let(:stub_parameters) { nil }
 
-      request_parameters
+    it "is empty" do
+      expect(parameters.empty?).to be(true)
     end
 
   end
 
-  describe "when the stubbed parameters are nil" do
+  describe "#matches?" do
 
-    let(:stubbed_parameters) { nil }
+    let(:request_parameters) { instance_double(HttpStub::Server::Request::Parameters) }
+    let(:request)            { instance_double(HttpStub::Server::Request::Request, parameters: request_parameters) }
+    let(:logger)             { instance_double(Logger) }
 
-    it "creates a regexpable representation of an empty hash" do
-      expect(HttpStub::Server::Stub::Match::HashWithStringValueMatchers).to receive(:new).with({})
+    subject { parameters.matches?(request, logger) }
 
-      request_parameters
-    end
+    it "determines if the stub parameter and request parameter hashes match" do
+      expect(HttpStub::Server::Stub::Match::HashMatcher).to receive(:match?).with(parameters, request_parameters)
 
-  end
-
-  describe "#matches?" do
-
-    let(:logger) { instance_double(Logger) }
+      subject
+    end
 
-    it "delegates to the regexpable representation of the stubbed parameters to determine a match" do
-      allow(HttpStub::Server::Stub::Match::HashWithStringValueMatchers).to(
-        receive(:new).and_return(regexpable_stubbed_paremeters)
-      )
-      expect(regexpable_stubbed_paremeters).to receive(:matches?).with(raw_request_parameters).and_return(true)
+    it "returns the result of the match" do
+      allow(HttpStub::Server::Stub::Match::HashMatcher).to receive(:match?).and_return(true)
 
-      expect(request_parameters.matches?(request, logger)).to be(true)
+      expect(subject).to eql(true)
     end
 
   end
 
   describe "#to_s" do
 
-    subject { request_parameters.to_s }
+    subject { parameters.to_s }
 
     describe "when multiple parameters are provided" do
 
-      let(:stubbed_parameters) { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
+      let(:stub_parameters) { (1..3).each_with_object({}) { |i, result| result["key#{i}"] = "value#{i}" } }
 
       it "returns a string containing each parameter formatted as a conventional request parameter" do
         result = subject
 
-        stubbed_parameters.each { |key, value| expect(result).to match(/#{key}=#{value}/) }
+        stub_parameters.each { |key, value| expect(result).to match(/#{key}=#{value}/) }
       end
 
       it "separates each parameter with the conventional request parameter delimiter" do
@@ -69,7 +62,7 @@ describe HttpStub::Server::Stub::Match::Rule::Parameters do
 
     describe "when empty parameters are provided" do
 
-      let(:stubbed_parameters) { {} }
+      let(:stub_parameters) { {} }
 
       it "returns an empty string" do
         expect(subject).to eql("")
@@ -79,7 +72,7 @@ describe HttpStub::Server::Stub::Match::Rule::Parameters do
 
     describe "when nil parameters are provided" do
 
-      let(:stubbed_parameters) { nil }
+      let(:stub_parameters) { nil }
 
       it "returns an empty string" do
         expect(subject).to eql("")

data/spec/lib/http_stub/server/stub/match/rule/simple_body_spec.rb

@@ -1,44 +1,35 @@
 describe HttpStub::Server::Stub::Match::Rule::SimpleBody do
 
-  let(:raw_body)      { "some body" }
-  let(:value_matcher) { instance_double(HttpStub::Server::Stub::Match::StringValueMatcher).as_null_object }
+  let(:stub_body) { "some body" }
 
-  let(:simple_body) { described_class.new(raw_body) }
-
-  before(:example) do
-    allow(HttpStub::Server::Stub::Match::StringValueMatcher).to receive(:new).and_return(value_matcher)
-  end
-
-  describe "constructor" do
-
-    it "creates a value matcher for the provided body" do
-      expect(HttpStub::Server::Stub::Match::StringValueMatcher).to receive(:new).with(raw_body)
-
-      simple_body
-    end
-
-  end
+  let(:simple_body) { described_class.new(stub_body) }
 
   describe "#matches?" do
 
     let(:request_body) { "some request body" }
-    let(:request)      { instance_double(HttpStub::Server::Request, body: request_body) }
+    let(:request)      { instance_double(HttpStub::Server::Request::Request, body: request_body) }
     let(:logger)       { instance_double(Logger) }
 
-    it "delegates to the value matcher to match the request body" do
-      expect(value_matcher).to receive(:matches?).with(request_body).and_return(true)
+    subject { simple_body.matches?(request, logger) }
+
+    it "determines if the stub uri  and request uri strings match" do
+      expect(HttpStub::Server::Stub::Match::StringValueMatcher).to receive(:match?).with(stub_body, request_body)
+
+      subject
+    end
+
+    it "returns the result of the match" do
+      allow(HttpStub::Server::Stub::Match::StringValueMatcher).to receive(:match?).and_return(true)
 
-      expect(simple_body.matches?(request, logger)).to be(true)
+      expect(subject).to eql(true)
     end
 
   end
 
   describe "#to_s" do
 
-    it "delegates to the value matcher representation of the provided body" do
-      expect(value_matcher).to receive(:to_s).and_return("some value matcher string")
-
-      expect(simple_body.to_s).to eql("some value matcher string")
+    it "returns the stub body" do
+      expect(simple_body.to_s).to eql(stub_body)
     end
 
   end

data/spec/lib/http_stub/server/stub/match/{truthy_matcher_spec.rb → rule/truthy_spec.rb}

@@ -1,6 +1,4 @@
-describe HttpStub::Server::Stub::Match::TruthyMatcher do
-
-  let(:truthy_matcher) { described_class }
+describe HttpStub::Server::Stub::Match::Rule::Truthy do
 
   describe "::matches?" do
 
@@ -8,7 +6,7 @@ describe HttpStub::Server::Stub::Match::TruthyMatcher do
     let(:logger)  { instance_double(Logger) }
 
     it "returns true" do
-      expect(truthy_matcher.matches?(request, logger)).to be(true)
+      expect(described_class.matches?(request, logger)).to be(true)
     end
 
   end
@@ -16,7 +14,7 @@ describe HttpStub::Server::Stub::Match::TruthyMatcher do
   describe "::to_s" do
 
     it "returns an empty string" do
-      expect(truthy_matcher.to_s).to eql("")
+      expect(described_class.to_s).to eql("")
     end
 
   end

data/spec/lib/http_stub/server/stub/match/rule/uri_spec.rb

@@ -1,44 +1,35 @@
 describe HttpStub::Server::Stub::Match::Rule::Uri do
 
-  let(:raw_uri)       { "/some/uri" }
-  let(:value_matcher) { instance_double(HttpStub::Server::Stub::Match::StringValueMatcher).as_null_object }
+  let(:stub_uri) { "/some/uri" }
 
-  let(:uri) { described_class.new(raw_uri) }
-
-  before(:example) do
-    allow(HttpStub::Server::Stub::Match::StringValueMatcher).to receive(:new).and_return(value_matcher)
-  end
-
-  describe "constructor" do
-
-    it "creates a value matcher for the provided uri" do
-      expect(HttpStub::Server::Stub::Match::StringValueMatcher).to receive(:new).with(raw_uri)
-
-      uri
-    end
-
-  end
+  let(:uri) { described_class.new(stub_uri) }
 
   describe "#matches?" do
 
     let(:request_uri) { "/some/uri" }
-    let(:request)     { instance_double(HttpStub::Server::Request, uri: request_uri) }
+    let(:request)     { instance_double(HttpStub::Server::Request::Request, uri: request_uri) }
     let(:logger)      { instance_double(Logger) }
 
-    it "delegates to the value matcher representation of the provided uri" do
-      expect(value_matcher).to receive(:matches?).with(request_uri).and_return(true)
+    subject { uri.matches?(request, logger) }
+
+    it "determines if the stub uri and request uri strings match" do
+      expect(HttpStub::Server::Stub::Match::StringValueMatcher).to receive(:match?).with(stub_uri, request_uri)
+
+      subject
+    end
+
+    it "returns the result of the match" do
+      allow(HttpStub::Server::Stub::Match::StringValueMatcher).to receive(:match?).and_return(true)
 
-      expect(uri.matches?(request, logger)).to be(true)
+      expect(subject).to eql(true)
     end
 
   end
 
   describe "#to_s" do
 
-    it "delegates to the value matcher representation of the provided uri" do
-      expect(value_matcher).to receive(:to_s).and_return("some value matcher string")
-
-      expect(uri.to_s).to eql("some value matcher string")
+    it "returns the stub uri" do
+      expect(uri.to_s).to eql(stub_uri)
     end
 
   end

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

@@ -2,13 +2,11 @@ describe HttpStub::Server::Stub::Match::StringValueMatcher do
 
   let(:stub_value) { "some stub value" }
 
-  let(:string_value_matcher) { HttpStub::Server::Stub::Match::StringValueMatcher.new(stub_value) }
-
-  describe "#matches?" do
+  describe "::match?" do
 
     let(:actual_value) { "some actual value" }
 
-    subject { string_value_matcher.matches?(actual_value) }
+    subject { described_class.match?(stub_value, actual_value) }
 
     shared_examples_for "a StringValueMatcher that matches an expected stub value" do
 
@@ -126,12 +124,4 @@ describe HttpStub::Server::Stub::Match::StringValueMatcher do
 
   end
 
-  describe "#to_s" do
-
-    it "returns the stub value provided" do
-      expect(string_value_matcher.to_s).to eql(stub_value)
-    end
-
-  end
-
 end

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

@@ -6,14 +6,16 @@ describe HttpStub::Server::Stub::Parser do
 
     let(:parameters) { {} }
     let(:body_hash)  { {} }
-    let(:request)    { instance_double(HttpStub::Server::Request, parameters: parameters, body: body_hash.to_json) }
+    let(:request)    do
+      instance_double(HttpStub::Server::Request::Request, parameters: parameters, body: body_hash.to_json)
+    end
 
     subject { parser.parse(request) }
 
     context "when the request contains a payload parameter" do
 
-      let(:payload) { HttpStub::StubFixture.new.server_payload }
-      let(:parameters)  { { "payload" => payload.to_json } }
+      let(:payload)    { HttpStub::StubFixture.new.server_payload }
+      let(:parameters) { { "payload" => payload.to_json } }
 
       it "consolidates any files into the payload" do
         expect(HttpStub::Server::Stub::PayloadFileConsolidator).to receive(:consolidate!).with(payload, request)

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

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