http_stub 0.27.0 → 0.28.0.beta1

data/spec/lib/http_stub/configurer/server/session_facade_spec.rb

@@ -1,285 +0,0 @@
-describe HttpStub::Configurer::Server::SessionFacade do
-
-  let(:session_id)        { "some session id" }
-  let(:request_processor) { instance_double(HttpStub::Configurer::Server::RequestProcessor) }
-
-  let(:session_facade) { described_class.new(session_id, request_processor) }
-
-  describe "#stub_response" do
-
-    let(:the_stub_description) { "some stub description" }
-    let(:the_stub)             { instance_double(HttpStub::Configurer::Request::Stub, to_s: the_stub_description) }
-
-    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Multipart) }
-
-    subject { session_facade.stub_response(the_stub) }
-
-    before(:example) do
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:multipart).and_return(request)
-      allow(request_processor).to receive(:submit)
-    end
-
-    it "creates a multipart request to add a stub" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:multipart).with("stubs", anything, anything)
-      )
-
-      subject
-    end
-
-    it "creates a multipart request with the provided stub" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to receive(:multipart).with(anything, the_stub, anything)
-
-      subject
-    end
-
-    it "creates a multipart request identifying the session" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:multipart).with(anything, anything, http_stub_session_id: session_id)
-      )
-
-      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 stub via its string representation" do
-      expect(request_processor).to(
-        receive(:submit).with(hash_including(description: a_string_including("stubbing '#{the_stub_description}'")))
-      )
-
-      subject
-    end
-
-    it "describes the request as scoped within the session" do
-      expect(request_processor).to(
-        receive(:submit).with(hash_including(description: a_string_including("session '#{session_id}'")))
-      )
-
-      subject
-    end
-
-  end
-
-  describe "#activate" do
-
-    let(:scenario_names) { (1..3).map { |i| "scenario name #{i}" } }
-    let(:request)        { instance_double(HttpStub::Configurer::Request::Http::Basic) }
-
-    subject { session_facade.activate(scenario_names) }
-
-    before(:example) do
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:post).and_return(request)
-      allow(request_processor).to receive(:submit)
-    end
-
-    it "creates an POST request to activate the scenarios" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:post).with("scenarios/activate", anything).and_return(request)
-      )
-
-      subject
-    end
-
-    it "creates a POST request with the session id as a parameter" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:post).with(anything, hash_including(http_stub_session_id: session_id)).and_return(request)
-      )
-
-      subject
-    end
-
-    it "creates a POST request with the scenario names as an array parameter" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:post).with(anything, hash_including("names[]" => scenario_names)).and_return(request)
-      )
-
-      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 activation request including the scenario names" do
-      quoted_scenario_names = scenario_names.map { |name| "'#{name}'" }
-      description_expectation = Regexp.new("activating #{quoted_scenario_names.join(", ")}")
-      expect(request_processor).to(
-        receive(:submit).with(hash_including(description: a_string_matching(description_expectation)))
-      )
-
-      subject
-    end
-
-    it "describes the request as scoped within the session" do
-      expect(request_processor).to(
-        receive(:submit).with(hash_including(description: a_string_including("session '#{session_id}'")))
-      )
-
-      subject
-    end
-
-  end
-
-  describe "#reset_stubs" do
-
-    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
-
-    subject { session_facade.reset_stubs }
-
-    before(:example) do
-      allow(HttpStub::Configurer::Request::Http::Factory).to receive(:post).and_return(request)
-      allow(request_processor).to receive(:submit)
-    end
-
-    it "creates a POST request to reset the stubs" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:post).with("stubs/reset", anything).and_return(request)
-      )
-
-      subject
-    end
-
-    it "creates a POST request with the session id as a parameter" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:post).with(anything, http_stub_session_id: session_id).and_return(request)
-      )
-
-      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 request as resetting the stubs in memory" do
-      expect(request_processor).to(
-        receive(:submit).with(hash_including(description: a_string_including("resetting stubs")))
-      )
-
-      subject
-    end
-
-    it "describes the request as scoped within the session" do
-      expect(request_processor).to(
-        receive(:submit).with(hash_including(description: a_string_including("session '#{session_id}'")))
-      )
-
-      subject
-    end
-
-  end
-
-  describe "#clear_stubs" do
-
-    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
-
-    subject { session_facade.clear_stubs }
-
-    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 that deletes a stub" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:delete).with("stubs", anything).and_return(request)
-      )
-
-      subject
-    end
-
-    it "creates a DELETE request with the session id as a parameter" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:delete).with(anything, http_stub_session_id: session_id).and_return(request)
-      )
-
-      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 request as clearing the server stubs" do
-      expect(request_processor).to(
-        receive(:submit).with(hash_including(description: a_string_including("clearing stubs")))
-      )
-
-      subject
-    end
-
-    it "describes the request as scoped within the session" do
-      expect(request_processor).to(
-        receive(:submit).with(hash_including(description: a_string_including("session '#{session_id}'")))
-      )
-
-      subject
-    end
-
-  end
-
-  describe "#delete" do
-
-    let(:request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
-
-    subject { session_facade.delete }
-
-    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 intended to delete a session" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:delete).with("sessions", anything).and_return(request)
-      )
-
-      subject
-    end
-
-    it "creates a DELETE request with the session id as a parameter" do
-      expect(HttpStub::Configurer::Request::Http::Factory).to(
-        receive(:delete).with(anything, http_stub_session_id: session_id).and_return(request)
-      )
-
-      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 request as clearing the server stubs" do
-      expect(request_processor).to(
-        receive(:submit).with(hash_including(description: a_string_including("deleting session '#{session_id}'")))
-      )
-
-      subject
-    end
-
-    it "describes the request as scoped within the session" do
-      expect(request_processor).to(
-        receive(:submit).with(hash_including(description: a_string_including("session '#{session_id}'")))
-      )
-
-      subject
-    end
-
-  end
-
-end

data/spec/lib/http_stub/configurer_spec.rb

@@ -1,105 +0,0 @@
-describe HttpStub::Configurer do
-
-  class HttpStub::Configurer::TestableConfigurer
-    include HttpStub::Configurer
-  end
-
-  let(:configurer_class) { HttpStub::Configurer::TestableConfigurer }
-  let(:configurer)       { configurer_class.new }
-
-  describe "::stub_server" do
-
-    subject { configurer_class.stub_server }
-
-    it "creates a server DSL" do
-      expect(HttpStub::Configurer::DSL::Server).to receive(:new)
-
-      subject
-    end
-
-    it "returns the created server DSL" do
-      server = instance_double(HttpStub::Configurer::DSL::Server)
-      allow(HttpStub::Configurer::DSL::Server).to receive(:new).and_return(server)
-
-      expect(subject).to eql(server)
-    end
-
-    it "reuses the stub server in subsequent requests" do
-      server = configurer_class.stub_server
-
-      expect(subject).to be(server)
-    end
-
-  end
-
-  describe "::initialize!" do
-
-    subject { configurer_class.initialize! }
-
-    before(:example) { allow(configurer_class.stub_server).to receive(:initialize!) }
-
-    context "when included in a class with an on_initialize class method" do
-
-      let(:configurer_class) do
-        Class.new do
-          include HttpStub::Configurer
-
-          def self.on_initialize
-            # Intentionally blank
-          end
-        end
-      end
-
-      context "and the class has not been initialized previously" do
-
-        it "invokes the on_initialize method" do
-          expect(configurer_class).to receive(:on_initialize)
-
-          subject
-        end
-
-      end
-
-      context "and the class has been initialized previously" do
-
-        before(:example) { configurer_class.initialize! }
-
-        it "does not re-invoke the on_initialize method" do
-          expect(configurer_class).to_not receive(:on_initialize)
-
-          subject
-        end
-
-      end
-
-    end
-
-    context "when included in a class without an on_initialize method" do
-
-      let(:configurer_class) { Class.new { include HttpStub::Configurer } }
-
-      it "executes without error" do
-        expect { subject }.to_not raise_error
-      end
-
-    end
-
-    it "initializes the stub server" do
-      expect(configurer_class.stub_server).to receive(:initialize!)
-
-      subject
-    end
-
-  end
-
-  describe "#stub_server" do
-
-    subject { configurer.stub_server }
-
-    it "returns the same server as the class method" do
-      expect(subject).to be(configurer_class.stub_server)
-    end
-
-  end
-
-end

data/spec/lib/http_stub/server/application/configuration_spec.rb

@@ -1,59 +0,0 @@
-describe HttpStub::Server::Application::Configuration do
-
-  let(:configuration) { described_class.new(args) }
-
-  describe "#settings" do
-
-    subject { configuration.settings }
-
-    context "when a configurer is provided" do
-
-      let(:port)                      { 8888 }
-      let(:session_identifier)        { { parameters: :some_session_parameter } }
-      let(:cross_origin_support_flag) { true }
-      let(:stub_server)               do
-        instance_double(HttpStub::Configurer::DSL::Server, port: port, session_identifier: session_identifier)
-      end
-      let(:configurer)         { double(HttpStub::Configurer, stub_server: stub_server) }
-      let(:args)               { { configurer: configurer } }
-
-      before(:example) do
-        allow(stub_server).to receive(:enabled?).with(:cross_origin_support).and_return(cross_origin_support_flag)
-      end
-
-      it "has the configurers port" do
-        expect(subject).to include(port: port)
-      end
-
-      it "has the configurers session identifier" do
-        expect(subject).to include(session_identifier: session_identifier)
-      end
-
-      it "has the configurers cross origin support flag" do
-        expect(subject).to include(cross_origin_support: cross_origin_support_flag)
-      end
-
-    end
-
-    context "when a configurer is not provided" do
-
-      let(:port) { 8889 }
-      let(:args) { { port: port } }
-
-      it "has the provided port" do
-        expect(subject).to include(port: port)
-      end
-
-      it "has a nil session identifier" do
-        expect(subject).to include(session_identifier: nil)
-      end
-
-      it "has disabled cross origin support" do
-        expect(subject).to include(cross_origin_support: false)
-      end
-
-    end
-
-  end
-
-end