http_stub 0.19.1 → 0.20.0

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

@@ -1,235 +0,0 @@
-describe HttpStub::Server::Stub::Instance do
-
-  let(:request_header_payload) do
-    {
-        "header1" => "header_value1",
-        "header2" => "header_value2",
-        "header3" => "header_value3"
-    }
-  end
-  let(:request_parameter_payload) do
-    {
-        "param1" => "param_value1",
-        "param2" => "param_value2",
-        "param3" => "param_value3"
-    }
-  end
-  let(:request_method_payload) { "get" }
-  let(:trigger_payload) do
-    {
-      "uri" =>        "/a_triggered_path",
-      "method" =>     "post",
-      "headers" =>    { "triggered_header" => "triggered_header_value" },
-      "parameters" => { "triggered_parameter" => "triggered_parameter_value" },
-      "body" =>       { "schema" => { "json" => "trigger schema definition" } },
-      "response" => {
-        "status" => 203,
-        "body" =>   "Triggered body"
-      }
-    }
-  end
-  let(:stub_payload) do
-    {
-      "uri" =>        "/a_path",
-      "method" =>     stub_method,
-      "headers" =>    request_header_payload,
-      "parameters" => request_parameter_payload,
-      "body" =>       { "schema" => { "json" => "stub schema definition" } },
-      "response" => {
-        "status" => 201,
-        "body" =>   "Some body"
-      },
-      "triggers" => [ trigger_payload ]
-    }
-  end
-  let(:stub_method)        { instance_double(HttpStub::Server::Stub::Method, match?: true) }
-  let(:uri)                { instance_double(HttpStub::Server::Stub::Uri, match?: true) }
-  let(:request_headers)    { instance_double(HttpStub::Server::Stub::RequestHeaders, match?: true) }
-  let(:request_parameters) { instance_double(HttpStub::Server::Stub::RequestParameters, match?: true) }
-  let(:request_body)       { double("HttpStub::Server::Stub::SomeRequestBody", match?: true) }
-  let(:response)           { instance_double(HttpStub::Server::Stub::Response::Base) }
-  let(:triggers)           { instance_double(HttpStub::Server::Stub::Triggers) }
-
-  let(:the_stub) { HttpStub::Server::Stub::Instance.new(stub_payload) }
-
-  before(:example) do
-    allow(HttpStub::Server::Stub::Method).to receive(:new).and_return(stub_method)
-    allow(HttpStub::Server::Stub::Uri).to receive(:new).and_return(uri)
-    allow(HttpStub::Server::Stub::RequestHeaders).to receive(:new).and_return(request_headers)
-    allow(HttpStub::Server::Stub::RequestParameters).to receive(:new).and_return(request_parameters)
-    allow(HttpStub::Server::Stub::RequestBody).to receive(:create).and_return(request_body)
-    allow(HttpStub::Server::Stub::Response).to receive(:create).and_return(response)
-    allow(HttpStub::Server::Stub::Triggers).to receive(:new).and_return(triggers)
-  end
-
-  describe "#satisfies?" do
-
-    let(:request_method) { request_method_payload }
-    let(:request_uri)    { "/a_request_uri" }
-    let(:request)        { instance_double(Rack::Request, :request_method => request_method_payload) }
-
-    subject { the_stub.satisfies?(request) }
-
-    describe "when the request uri matches" do
-
-      before(:example) { allow(uri).to receive(:match?).with(request).and_return(true) }
-
-      describe "and the request method matches" do
-
-        describe "and a header match is configured" do
-
-          describe "that matches" do
-
-            before(:example) { allow(request_headers).to receive(:match?).with(request).and_return(true) }
-
-            describe "and a parameter match is configured" do
-
-              describe "that matches" do
-
-                before(:example) { allow(request_parameters).to receive(:match?).with(request).and_return(true) }
-
-                describe "and a body match is configured" do
-
-                  describe "that matches" do
-
-                    before(:example) { allow(request_body).to receive(:match?).with(request).and_return(true) }
-
-                    it "returns true" do
-                      expect(subject).to be(true)
-                    end
-
-                  end
-
-                end
-
-              end
-
-            end
-
-          end
-
-        end
-
-      end
-
-    end
-
-    describe "when the request uri does not match" do
-
-      before(:example) { allow(uri).to receive(:match?).with(request).and_return(false) }
-
-      it "returns false" do
-        expect(subject).to be(false)
-      end
-
-    end
-
-    describe "when the request method does not match" do
-
-      before(:example) { allow(stub_method).to receive(:match?).with(request).and_return(false) }
-
-      it "returns false" do
-        expect(subject).to be(false)
-      end
-
-    end
-
-    describe "when the headers do not match" do
-
-      before(:example) { allow(request_headers).to receive(:match?).with(request).and_return(false) }
-
-      it "returns false" do
-        expect(subject).to be(false)
-      end
-
-    end
-
-    describe "when the parameters do not match" do
-
-      before(:example) { allow(request_parameters).to receive(:match?).with(request).and_return(false) }
-
-      it "returns false" do
-        expect(subject).to be(false)
-      end
-
-    end
-
-    describe "when the bodies do not match" do
-
-      before(:example) { allow(request_body).to receive(:match?).with(request).and_return(false) }
-
-      it "returns false" do
-        expect(subject).to be(false)
-      end
-
-    end
-
-  end
-
-  describe "#method" do
-
-    it "returns the method model encapsulating the method provided in the request body" do
-      expect(the_stub.method).to eql(stub_method)
-    end
-
-  end
-
-  describe "#uri" do
-
-    it "returns the rui model encapsulating the uri provided in the request body" do
-      expect(the_stub.uri).to eql(uri)
-    end
-
-  end
-
-  describe "#headers" do
-
-    it "returns the headers model encapsulating the headers provided in the request body" do
-      expect(the_stub.headers).to eql(request_headers)
-    end
-
-  end
-
-  describe "#parameters" do
-
-    it "returns the parameters model encapsulating the parameters provided in the request body" do
-      expect(the_stub.parameters).to eql(request_parameters)
-    end
-
-  end
-
-  describe "#body" do
-
-    it "returns the body model encapsulating the body provided in the request body" do
-      expect(the_stub.body).to eql(request_body)
-    end
-
-  end
-
-  describe "#response" do
-
-    it "exposes the response model encapsulating the response provided in the request body" do
-      expect(the_stub.response).to eql(response)
-    end
-
-  end
-
-  describe "#triggers" do
-
-    it "returns the triggers model encapsulating the triggers provided in the request body" do
-      expect(the_stub.triggers).to eql(triggers)
-    end
-
-  end
-
-  describe "#to_s" do
-
-    it "returns a string representation of the stub arguments" do
-      expect(stub_payload).to receive(:to_s).and_return("stub arguments string")
-
-      expect(the_stub.to_s).to eql("stub arguments string")
-    end
-
-  end
-
-end

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

@@ -1,68 +0,0 @@
-describe HttpStub::Server::Stub::RequestHeaders do
-
-  let(:request)         { instance_double(Rack::Request) }
-  let(:stubbed_headers) { { "stub_key" => "value" } }
-
-  let(:request_headers) { HttpStub::Server::Stub::RequestHeaders.new(stubbed_headers) }
-
-  it "is Headers" do
-    expect(request_headers).to be_a(HttpStub::Server::Stub::Headers)
-  end
-
-  describe "when stubbed headers are provided" do
-
-    it "creates a regexpable representation of the stubbed headers whose keys are downcased and underscored" do
-      downcased_and_underscored_hash = { "another_stub_key" => "value" }
-      expect(stubbed_headers).to receive(:downcase_and_underscore_keys).and_return(downcased_and_underscored_hash)
-      expect(HttpStub::Server::Stub::HashWithStringValueMatchers).to receive(:new).with(downcased_and_underscored_hash)
-
-      request_headers
-    end
-
-  end
-
-  describe "when the stubbed headers are nil" do
-
-    let(:stubbed_headers) { nil }
-
-    it "creates a regexpable representation of an empty hash" do
-      expect(HttpStub::Server::Stub::HashWithStringValueMatchers).to receive(:new).with({})
-
-      request_headers
-    end
-
-  end
-
-  describe "#match?" do
-
-    let(:parsed_headers) { { "request_key" => "value" } }
-    let(:regexpable_stubbed_headers) { double(HttpStub::Server::Stub::HashWithStringValueMatchers).as_null_object }
-
-    before(:example) do
-      allow(HttpStub::Server::Stub::HashWithStringValueMatchers).to receive(:new).and_return(regexpable_stubbed_headers)
-      allow(HttpStub::Server::Stub::RequestHeaderParser).to receive(:parse).with(request).and_return(parsed_headers)
-    end
-
-    it "parses the requests headers into a hash" do
-      expect(HttpStub::Server::Stub::RequestHeaderParser).to receive(:parse).with(request).and_return(parsed_headers)
-
-      request_headers.match?(request)
-    end
-
-    it "downcases and underscore the keys in the request header hash" do
-      expect(parsed_headers).to receive(:downcase_and_underscore_keys)
-
-      request_headers.match?(request)
-    end
-
-    it "delegates to the regexpable representation of the stubbed headers to determine a match" do
-      downcased_and_underscored_hash = { "another_request_key" => "value" }
-      allow(parsed_headers).to receive(:downcase_and_underscore_keys).and_return(downcased_and_underscored_hash)
-      expect(regexpable_stubbed_headers).to receive(:match?).with(downcased_and_underscored_hash).and_return(true)
-
-      expect(request_headers.match?(request)).to be_truthy
-    end
-
-  end
-
-end

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

@@ -1,43 +0,0 @@
-describe HttpStub::Server::Stub::SimpleRequestBody do
-
-  let(:raw_body)      { "some body" }
-  let(:value_matcher) { instance_double(HttpStub::Server::Stub::StringValueMatcher).as_null_object }
-
-  let(:simple_request_body) { HttpStub::Server::Stub::SimpleRequestBody.new(raw_body) }
-
-  before(:example) { allow(HttpStub::Server::Stub::StringValueMatcher).to receive(:new).and_return(value_matcher) }
-
-  describe "constructor" do
-
-    it "creates a value matcher for the provided body" do
-      expect(HttpStub::Server::Stub::StringValueMatcher).to receive(:new).with(raw_body)
-
-      simple_request_body
-    end
-
-  end
-
-  describe "#match?" do
-
-    let(:request_body) { "some request body" }
-    let(:request)      { instance_double(Rack::Request, body: double("Rack::Body", read: request_body)) }
-
-    it "delegates to the value matcher to match the request body" do
-      expect(value_matcher).to receive(:match?).with(request_body).and_return(true)
-
-      expect(simple_request_body.match?(request)).to be(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_request_body.to_s).to eql("some value matcher string")
-    end
-
-  end
-
-end

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

@@ -1,23 +0,0 @@
-describe HttpStub::Server::Stub::TruthyRequestMatcher do
-
-  let(:truthy_request_matcher) { HttpStub::Server::Stub::TruthyRequestMatcher }
-
-  describe "::match?" do
-
-    let(:request) { instance_double(Rack::Request) }
-
-    it "returns true" do
-      expect(truthy_request_matcher.match?(request)).to be(true)
-    end
-
-  end
-
-  describe "::to_s" do
-
-    it "returns an empty string" do
-      expect(truthy_request_matcher.to_s).to eql("")
-    end
-
-  end
-
-end

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

@@ -1,43 +0,0 @@
-describe HttpStub::Server::Stub::Uri do
-
-  let(:raw_uri)       { "/some/uri" }
-  let(:value_matcher) { instance_double(HttpStub::Server::Stub::StringValueMatcher).as_null_object }
-
-  let(:uri) { HttpStub::Server::Stub::Uri.new(raw_uri) }
-
-  before(:example) { allow(HttpStub::Server::Stub::StringValueMatcher).to receive(:new).and_return(value_matcher) }
-
-  describe "constructor" do
-
-    it "creates a value matcher for the provided uri" do
-      expect(HttpStub::Server::Stub::StringValueMatcher).to receive(:new).with(raw_uri)
-
-      uri
-    end
-
-  end
-
-  describe "#match?" do
-
-    let(:request_uri) { "/some/uri" }
-    let(:request)     { instance_double(Rack::Request, path_info: request_uri) }
-
-    it "delegates to the value matcher representation of the provided uri" do
-      expect(value_matcher).to receive(:match?).with(request_uri).and_return(true)
-
-      expect(uri.match?(request)).to be(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")
-    end
-
-  end
-
-end