RubyGems - http_stub - Versions diffs - 0.27.0 → 0.28.0.beta1 - Mend

http_stub 0.27.0 → 0.28.0.beta1

Files changed (299) hide show

data/spec/lib/http_stub/configurer/server/configuration_spec.rb DELETED Viewed

@@ -1,139 +0,0 @@
-describe HttpStub::Configurer::Server::Configuration do
-  let(:configuration) { described_class.new }
-  shared_context "a configuration with host and port configured" do
-    before(:example) do
-      configuration.host = "some_host"
-      configuration.port =  8888
-    end
-  end
-  describe "#session_identifier" do
-    let(:session_identifier) { { headers: :some_session_identifier } }
-    subject { configuration.session_identifier }
-    before(:example) { configuration.session_identifier = session_identifier }
-    it "returns any configured value" do
-      expect(subject).to eql(session_identifier)
-    end
-  end
-  describe "#base_uri" do
-    subject { configuration.base_uri }
-    include_context "a configuration with host and port configured"
-    it "returns a uri that combines any established host and port" do
-      expect(subject).to include("some_host:8888")
-    end
-    it "returns a uri accessed via http" do
-      expect(subject).to match(/^http:\/\//)
-    end
-  end
-  describe "#external_base_uri" do
-    subject { configuration.external_base_uri }
-    include_context "a configuration with host and port configured"
-    context "when an external base URI environment variable is established" do
-      let(:external_base_uri) { "http://some/external/base/uri" }
-      before(:example) { ENV["STUB_EXTERNAL_BASE_URI"] = external_base_uri }
-      after(:example)  { ENV["STUB_EXTERNAL_BASE_URI"] = nil }
-      it "returns the environment variable" do
-        expect(subject).to eql(external_base_uri)
-      end
-    end
-    context "when an external base URI environment variable is not established" do
-      it "returns the base URI" do
-        expect(subject).to eql(configuration.base_uri)
-      end
-    end
-    it "returns a uri that combines any established host and port" do
-      expect(subject).to include("some_host:8888")
-    end
-    it "returns a uri accessed via http" do
-      expect(subject).to match(/^http:\/\//)
-    end
-  end
-  describe "#enable" do
-    context "when a feature is provided" do
-      let(:feature) { :some_feature }
-      subject { configuration.enable(feature) }
-      it "enables the feature" do
-        subject
-        expect(configuration.enabled?(feature)).to be(true)
-      end
-    end
-    context "when features are provided" do
-      let(:features) { (1..3).map { |i| "feature_#{i}".to_sym } }
-      subject { configuration.enable(*features) }
-      it "enables the features" do
-        subject
-        features.each { |feature| expect(configuration.enabled?(feature)).to be(true) }
-      end
-    end
-  end
-  describe "#enabled?" do
-    let(:feature) { :some_feature }
-    subject { configuration.enabled?(feature) }
-    context "when a feature is enabled" do
-      before(:example) { configuration.enable(feature) }
-      it "returns false" do
-        expect(subject).to be(true)
-      end
-    end
-    context "when a feature is not enabled" do
-      it "returns false" do
-        expect(subject).to be(false)
-      end
-    end
-  end
-end

data/spec/lib/http_stub/configurer/server/facade_spec.rb DELETED Viewed

@@ -1,235 +0,0 @@
-describe HttpStub::Configurer::Server::Facade do
-  let(:configuration) { double(HttpStub::Configurer::Server::Configuration) }
-  let(:request_processor) { instance_double(HttpStub::Configurer::Server::RequestProcessor) }
-  let(:facade) { HttpStub::Configurer::Server::Facade.new(configuration) }
-  before(:example) do
-    allow(HttpStub::Configurer::Server::RequestProcessor).to receive(:new).and_return(request_processor)
-  end
-  it "creates a request processor with the provided configuration" do
-    expect(HttpStub::Configurer::Server::RequestProcessor).to receive(:new).with(configuration)
-    facade
-  end
-  describe "#initialize_server" do
-    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
-    subject { facade.initialize_server }
-    before(:example) do
-      allow(request_processor).to receive(:flush!)
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:post).and_return(request)
-      allow(request_processor).to receive(:submit)
-    end
-    it "causes the request processor to flush its requests" do
-      expect(request_processor).to receive(:flush!)
-      subject
-    end
-    it "creates a POST request for the initialized status endpoint" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:post).with("status/initialized").and_return(request)
-      )
-      subject
-    end
-    it "submits the HTTP Stub request via the request processor" do
-      expect(request_processor).to receive(:submit).with(hash_including(request: request))
-      subject
-    end
-    it "describes the request as marking the server as initialized" do
-      expect(request_processor).to receive(:submit).with(hash_including(description: "marking server as initialized"))
-      subject
-    end
-  end
-  describe "#server_has_started" do
-    subject { facade.server_has_started }
-    it "informs the request processor to disable buffering requests" do
-      expect(request_processor).to receive(:disable_buffering!)
-      subject
-    end
-  end
-  describe "#reset" do
-    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
-    subject { facade.reset }
-    before(:example) do
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:delete).and_return(request)
-      allow(request_processor).to receive(:submit)
-    end
-    it "creates a DELETE request for the memory endpoint" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:delete).with("memory").and_return(request)
-      subject
-    end
-    it "submits the HTTP Stub request via the request processor" do
-      expect(request_processor).to receive(:submit).with(hash_including(request: request))
-      subject
-    end
-    it "describes the request as resetting the server" do
-      expect(request_processor).to receive(:submit).with(hash_including(description: "resetting server"))
-      subject
-    end
-  end
-  describe "#define_scenario" do
-    let(:scenario_description) { "some scenario description" }
-    let(:scenario)             { instance_double(HttpStub::Configurer::Request::Scenario, to_s: scenario_description) }
-    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Multipart) }
-    subject { facade.define_scenario(scenario) }
-    before(:example) do
-      allow(request_processor).to receive(:submit)
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:multipart).and_return(request)
-    end
-    it "creates a multipart request to the scenarios endpoint" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:multipart).with("scenarios", anything)
-      subject
-    end
-    it "creates a multipart request with the provided scenario" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:multipart).with(anything, scenario)
-      subject
-    end
-    it "submits the request via the request processor" do
-      expect(request_processor).to receive(:submit).with(hash_including(request: request))
-      subject
-    end
-    it "describes the scenario via its string representation" do
-      expect(request_processor).to(
-        receive(:submit).with(hash_including(description: "registering scenario '#{scenario_description}'"))
-      )
-      subject
-    end
-  end
-  describe "#clear_scenarios" do
-    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
-    subject { facade.clear_scenarios }
-    before(:example) do
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:delete).and_return(request)
-      allow(request_processor).to receive(:submit)
-    end
-    it "creates a DELETE request for the scenarios endpoint" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:delete).with("scenarios").and_return(request)
-      subject
-    end
-    it "submits the HTTP Stub request via the request processor" do
-      expect(request_processor).to receive(:submit).with(hash_including(request: request))
-      subject
-    end
-    it "describes the request as clearing the servers scenarios" do
-      expect(request_processor).to receive(:submit).with(hash_including(description: "clearing scenarios"))
-      subject
-    end
-  end
-  describe "#create_session_facade" do
-    let(:session_id) { "some session id" }
-    let(:session_facade) { instance_double(HttpStub::Configurer::Server::SessionFacade) }
-    subject { facade.create_session_facade(session_id) }
-    before(:example) { allow(HttpStub::Configurer::Server::SessionFacade).to receive(:new).and_return(session_facade) }
-    it "creates a session facade for the provided session" do
-      expect(HttpStub::Configurer::Server::SessionFacade).to receive(:new).with(session_id, anything)
-      subject
-    end
-    it "creates a session facade that processes requests the server facades request processor" do
-      expect(HttpStub::Configurer::Server::SessionFacade).to receive(:new).with(anything, request_processor)
-      subject
-    end
-    it "returns the created session facade" do
-      expect(subject).to eql(session_facade)
-    end
-  end
-  describe "#clear_sessions" do
-    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
-    subject { facade.clear_sessions }
-    before(:example) do
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:delete).and_return(request)
-      allow(request_processor).to receive(:submit)
-    end
-    it "creates a DELETE request for the sessions endpoint" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:delete).with("sessions").and_return(request)
-      subject
-    end
-    it "submits the HTTP Stub request via the request processor" do
-      expect(request_processor).to receive(:submit).with(hash_including(request: request))
-      subject
-    end
-    it "describes the request as clearing the servers sessions" do
-      expect(request_processor).to receive(:submit).with(hash_including(description: "clearing sessions"))
-      subject
-    end
-  end
-end

data/spec/lib/http_stub/configurer/server/request_processor_spec.rb DELETED Viewed

@@ -1,100 +0,0 @@
-describe HttpStub::Configurer::Server::RequestProcessor do
-  let(:configuration) { double(HttpStub::Server::Application::Configuration) }
-  let(:command_processor)          { instance_double(HttpStub::Configurer::Server::CommandProcessor) }
-  let(:buffered_command_processor) { instance_double(HttpStub::Configurer::Server::BufferedCommandProcessor) }
-  let(:request_processor) { described_class.new(configuration) }
-  before(:example) do
-    allow(HttpStub::Configurer::Server::CommandProcessor).to receive(:new).and_return(command_processor)
-    allow(HttpStub::Configurer::Server::BufferedCommandProcessor).to(
-      receive(:new).and_return(buffered_command_processor)
-    )
-  end
-  describe "constructor" do
-    it "creates a command processor based on the servers configuration" do
-      expect(HttpStub::Configurer::Server::CommandProcessor).to receive(:new).with(configuration)
-      request_processor
-    end
-    it "creates a buffered command processor that flushes via the command processor" do
-      expect(HttpStub::Configurer::Server::BufferedCommandProcessor).to receive(:new).with(command_processor)
-      request_processor
-    end
-  end
-  describe "#submit" do
-    let(:args) { { some_arg_key: "some arg value" } }
-    subject { request_processor.submit(args) }
-    shared_examples_for "submitting a request to the server" do |processor_description|
-      let(:command) { instance_double(HttpStub::Configurer::Server::Command) }
-      before(:each) { allow(active_command_processor).to receive(:process) }
-      it "creates a command for the provided arguments" do
-        expect(HttpStub::Configurer::Server::Command).to receive(:new).with(hash_including(args)).and_return(command)
-        subject
-      end
-      it "processes the command via the #{processor_description}" do
-        allow(HttpStub::Configurer::Server::Command).to receive(:new).and_return(command)
-        expect(active_command_processor).to receive(:process).with(command)
-        subject
-      end
-    end
-    context "when request buffering is enabled" do
-      let(:active_command_processor) { buffered_command_processor }
-      it_behaves_like "submitting a request to the server", "buffered command processor"
-    end
-    context "when request buffering is disabled" do
-      let(:active_command_processor) { command_processor }
-      before(:example) { request_processor.disable_buffering! }
-      it_behaves_like "submitting a request to the server", "command processor"
-    end
-  end
-  describe "#flush!" do
-    subject { request_processor.flush! }
-    before(:example) { allow(buffered_command_processor).to receive(:flush) }
-    it "delegates to the buffered command processor" do
-      expect(buffered_command_processor).to receive(:flush)
-      subject
-    end
-    it "disables request buffering" do
-      expect(request_processor).to receive(:disable_buffering!)
-      subject
-    end
-  end
-end