http_stub 0.15.5 → 0.16.0.pre1

data/spec/lib/http_stub/server/stub_activator_controller_spec.rb

@@ -1,95 +0,0 @@
-describe HttpStub::Server::StubActivatorController do
-
-  let(:request)                 { instance_double(Rack::Request) }
-  let(:payload) { HttpStub::StubFixture.new.server_payload.merge("activation_uri" => "/some/activation/uri") }
-  let(:the_stub)                { instance_double(HttpStub::Server::Stub) }
-  let(:stub_activator)          { instance_double(HttpStub::Server::StubActivator, the_stub: the_stub) }
-  let(:stub_activator_registry) { instance_double(HttpStub::Server::Registry).as_null_object }
-  let(:stub_registry)           { instance_double(HttpStub::Server::StubRegistry).as_null_object }
-
-  let(:controller) { HttpStub::Server::StubActivatorController.new(stub_activator_registry, stub_registry) }
-
-  before(:example) do
-    allow(HttpStub::Server::RequestParser).to receive(:parse).and_return(payload)
-    allow(HttpStub::Server::StubActivator).to receive(:new).and_return(stub_activator)
-  end
-
-  describe "#register" do
-
-    subject { controller.register(request) }
-
-    it "parses the payload from the request" do
-      expect(HttpStub::Server::RequestParser).to receive(:parse).with(request).and_return(payload)
-
-      subject
-    end
-
-    it "creates a stub activator with the parsed payload" do
-      expect(HttpStub::Server::StubActivator).to receive(:new).with(payload).and_return(stub_activator)
-
-      subject
-    end
-
-    it "adds the created activator to the activator registry with the provided request" do
-      expect(stub_activator_registry).to receive(:add).with(stub_activator, request)
-
-      subject
-    end
-
-    it "returns a success response" do
-      expect(subject).to eql(HttpStub::Server::Response::SUCCESS)
-    end
-
-  end
-
-  describe "#activate" do
-
-    describe "when a stub activator has been registered that is activated by the request" do
-
-      before(:example) do
-        allow(stub_activator_registry).to receive(:find_for).with(request).and_return(stub_activator)
-      end
-
-      it "adds the activators stub to the stub registry" do
-        expect(stub_registry).to receive(:add).with(the_stub, request)
-
-        controller.activate(request)
-      end
-
-      it "returns a success response" do
-        expect(controller.activate(request)).to eql(HttpStub::Server::Response::SUCCESS)
-      end
-
-    end
-
-    describe "when no stub activator is activated by the request" do
-
-      before(:example) do
-        allow(stub_activator_registry).to receive(:find_for).with(request).and_return(nil)
-      end
-
-      it "does not add a stub to the registry" do
-        expect(stub_registry).not_to receive(:add)
-
-        controller.activate(request)
-      end
-
-      it "returns an empty response" do
-        expect(controller.activate(request)).to eql(HttpStub::Server::Response::EMPTY)
-      end
-
-    end
-
-  end
-
-  describe "#clear" do
-
-    it "clears the activator registry" do
-      expect(stub_activator_registry).to receive(:clear).with(request)
-
-      controller.clear(request)
-    end
-
-  end
-
-end

data/spec/lib/http_stub/server/stub_activator_spec.rb

@@ -1,83 +0,0 @@
-describe HttpStub::Server::StubActivator do
-
-  let(:activation_uri)  { "/some/activation/uri" }
-  let(:args)            { { "activation_uri" => activation_uri } }
-  let(:underlying_stub) { instance_double(HttpStub::Server::Stub) }
-
-  let(:stub_activator) { HttpStub::Server::StubActivator.new(args) }
-
-  before(:example) { allow(HttpStub::Server::Stub).to receive(:new).and_return(underlying_stub) }
-
-  describe "#constructor" do
-
-    it "creates an underlying stub from the provided arguments" do
-      expect(HttpStub::Server::Stub).to receive(:new).with(args)
-
-      stub_activator
-    end
-
-  end
-
-  describe "#satisfies?" do
-
-    let(:request) { double("HttpRequest", path_info: request_path_info) }
-
-    describe "when the request uri exactly matches the activator's activation uri" do
-
-      let(:request_path_info) { activation_uri }
-
-      it "returns true" do
-        expect(stub_activator.satisfies?(request)).to be_truthy
-      end
-
-    end
-
-    describe "when the activator's activation uri is a substring of the request uri" do
-
-      let(:request_path_info) { "#{activation_uri}/with/additional/paths" }
-
-      it "returns false" do
-        expect(stub_activator.satisfies?(request)).to be_falsey
-      end
-
-    end
-
-    describe "when the request uri is completely different to the activator's activation uri" do
-
-      let(:request_path_info) { "/completely/different/path" }
-
-      it "returns false" do
-        expect(stub_activator.satisfies?(request)).to be_falsey
-      end
-
-    end
-
-  end
-
-  describe "#the_stub" do
-
-    it "returns a HttpStub::Server::Stub constructed from the activator's arguments" do
-      expect(stub_activator.the_stub).to eql(underlying_stub)
-    end
-
-  end
-
-  describe "#activation_uri" do
-
-    it "returns the value provided in the request body" do
-      expect(stub_activator.activation_uri).to eql(activation_uri)
-    end
-
-  end
-
-  describe "#to_s" do
-
-    it "returns the string representation of the activation arguments" do
-      expect(args).to receive(:to_s).and_return("activation args string")
-
-      expect(stub_activator.to_s).to eql("activation args string")
-    end
-
-  end
-
-end

data/spec/lib/http_stub/server/stub_headers_spec.rb

@@ -1,68 +0,0 @@
-describe HttpStub::Server::StubHeaders do
-
-  let(:request) { double("HttpRequest") }
-  let(:stubbed_headers) { { "stub_key" => "value" } }
-
-  let(:stub_headers) { HttpStub::Server::StubHeaders.new(stubbed_headers) }
-
-  it "is Headers" do
-    expect(stub_headers).to be_a(HttpStub::Server::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::HashWithStringValueMatchers).to receive(:new).with(downcased_and_underscored_hash)
-
-      stub_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::HashWithStringValueMatchers).to receive(:new).with({})
-
-      stub_headers
-    end
-
-  end
-
-  describe "#match?" do
-
-    let(:request_headers) { { "request_key" => "value" } }
-    let(:regexpable_stubbed_headers) { double(HttpStub::Server::HashWithStringValueMatchers).as_null_object }
-
-    before(:example) do
-      allow(HttpStub::Server::HashWithStringValueMatchers).to receive(:new).and_return(regexpable_stubbed_headers)
-      allow(HttpStub::Server::RequestHeaderParser).to receive(:parse).with(request).and_return(request_headers)
-    end
-
-    it "parses the requests headers into a hash" do
-      expect(HttpStub::Server::RequestHeaderParser).to receive(:parse).with(request).and_return(request_headers)
-
-      stub_headers.match?(request)
-    end
-
-    it "downcases and underscore the keys in the request header hash" do
-      expect(request_headers).to receive(:downcase_and_underscore_keys)
-
-      stub_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(request_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(stub_headers.match?(request)).to be_truthy
-    end
-
-  end
-
-end

data/spec/lib/http_stub/server/stub_registry_integration_spec.rb

@@ -1,62 +0,0 @@
-describe HttpStub::Server::StubRegistry, "integrating with real stubs" do
-
-  let(:logger)  { double("Logger").as_null_object }
-  let(:request) { double("HttpRequest", logger: logger) }
-
-  let(:stub_registry) { HttpStub::Server::StubRegistry.new }
-
-  describe "#recall" do
-
-    subject { stub_registry.recall }
-
-    context "when stubs have been added" do
-
-      let(:stubs) do
-        (1..3).map { |i| create_stub(i) }
-      end
-
-      before(:example) do
-        stubs.each { |stub| stub_registry.add(stub, request) }
-      end
-
-      context "and remembered" do
-
-        before(:example) { stub_registry.remember }
-
-        context "and a stub subsequently added" do
-
-          let(:stub_to_add) { create_stub(4) }
-
-          before(:example) { stub_registry.add(stub_to_add, request) }
-
-          it "should restore all known stubs to the remembered state" do
-            subject
-
-            expect(stub_registry.all).not_to include(stub_to_add)
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-  def create_stub(number)
-    HttpStub::Server::Stub.new(
-      {
-        "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" => []
-      }
-    )
-  end
-
-end

data/spec/lib/http_stub/server/stub_uri_spec.rb

@@ -1,42 +0,0 @@
-describe HttpStub::Server::StubUri do
-
-  let(:stubbed_uri) { "/some/uri" }
-  let(:request) { double("HttpRequest", path_info: request_uri) }
-  let(:value_matcher) { double(HttpStub::Server::StringValueMatcher).as_null_object }
-  let(:stub_uri) { HttpStub::Server::StubUri.new(stubbed_uri) }
-
-  before(:example) { allow(HttpStub::Server::StringValueMatcher).to receive(:new).and_return(value_matcher) }
-
-  describe "constructor" do
-
-    it "creates a value matcher for the provided uri" do
-      expect(HttpStub::Server::StringValueMatcher).to receive(:new).with(stubbed_uri)
-
-      stub_uri
-    end
-
-  end
-
-  describe "#match?" do
-
-    let(:request_uri) { "/some/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(stub_uri.match?(request)).to be_truthy
-    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(stub_uri.to_s).to eql("some value matcher string")
-    end
-
-  end
-
-end