http_stub 0.27.0 → 0.28.0.beta1

data/spec/lib/http_stub/client/server_spec.rb

@@ -0,0 +1,75 @@
+describe HttpStub::Client::Server do
+
+  let(:base_uri) { "http://some/base/uri" }
+
+  let(:server) { described_class.new(base_uri) }
+
+  describe "::submit!" do
+
+    let(:response_code)    { "200" }
+    let(:response_message) { "some response message" }
+    let(:response)         { instance_double(Net::HTTPResponse, code: response_code, message: response_message) }
+
+    let(:request_args)                 { { key: "some value" } }
+    let(:request_error_message_prefix) { "some error message prefix" }
+    let(:request)                      do
+      instance_double(HttpStub::Client::Request, submit: response, error_message_prefix: request_error_message_prefix)
+    end
+
+    subject { server.submit!(request_args) }
+
+    before(:example) { allow(HttpStub::Client::Request).to receive(:new).and_return(request) }
+
+    it "creates a request with the servers base uri" do
+      expect(HttpStub::Client::Request).to receive(:new).with(hash_including(base_uri: base_uri))
+
+      subject
+    end
+
+    it "creates a request with the provided arguments" do
+      expect(HttpStub::Client::Request).to receive(:new).with(hash_including(request_args))
+
+      subject
+    end
+
+    it "submits the request" do
+      expect(request).to receive(:submit)
+
+      subject
+    end
+
+    describe "and the responses code is 200" do
+
+      let(:response_code) { "200" }
+
+      it "executes without error" do
+        expect { subject }.not_to raise_error
+      end
+
+      it "returns the server response" do
+        expect(subject).to eql(response)
+      end
+
+    end
+
+    describe "and the responses code is non-200" do
+
+      let(:response_code) { "400" }
+
+      it "raises an exception that describes the request" do
+        expect { subject }.to raise_error(/#{request_error_message_prefix}/)
+      end
+
+      it "raises an exception that contains the response code" do
+        expect { subject }.to raise_error(/#{response_code}/)
+      end
+
+      it "raises an exception that contains the responses message" do
+        expect { subject }.to raise_error(/#{response_message}/)
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/client/session_spec.rb

@@ -0,0 +1,117 @@
+describe HttpStub::Client::Session do
+
+  let(:id)     { "some_session_id" }
+  let(:server) { instance_double(HttpStub::Client::Server, submit!: nil) }
+
+  let(:session) { described_class.new(id, server) }
+
+  describe "#activate!" do
+
+    let(:scenario_names) { (1..3).map { |i| "Scenario name #{i}" } }
+
+    subject { session.activate!(*scenario_names) }
+
+    it "submits a post request" do
+      expect_request_submission_with(method: :post)
+
+      subject
+    end
+
+    it "submits a request to the scenario activation endpoint" do
+      expect_request_submission_with(path: "scenarios/activate")
+
+      subject
+    end
+
+    it "creates a request identifying the session via a parameter" do
+      expect_request_submission_with(parameters: hash_including(http_stub_session_id: id))
+
+      subject
+    end
+
+    it "submits a request with the scenario names as a parameter" do
+      expect_request_submission_with(parameters: hash_including("names[]" => scenario_names))
+
+      subject
+    end
+
+    it "describes the intent of the request as to activate the provided scenarios" do
+      scenario_names_description = scenario_names.map { |name| "'#{name}'" }.join(", ")
+      expect_request_submission_with(intent: a_string_including("activate scenarios #{scenario_names_description}"))
+
+      subject
+    end
+
+    it "the intent of the request includes the session affected" do
+      expect_request_submission_with(intent: a_string_including("session '#{id}'"))
+
+      subject
+    end
+
+  end
+
+  describe "#reset!" do
+
+    subject { session.reset! }
+
+    it "submits a post request" do
+      expect_request_submission_with(method: :post)
+
+      subject
+    end
+
+    it "submits a request to the stubs reset endpoint" do
+      expect_request_submission_with(path: "stubs/reset")
+
+      subject
+    end
+
+    it "submits a request identifying the session via a parameter" do
+      expect_request_submission_with(parameters: hash_including(http_stub_session_id: id))
+
+      subject
+    end
+
+    it "describes the intent of the request as to reset stubs in the session" do
+      expect_request_submission_with(intent: "reset stubs in session '#{id}'")
+
+      subject
+    end
+
+  end
+
+  describe "#delete!" do
+
+    subject { session.delete! }
+
+    it "submits a delete request" do
+      expect_request_submission_with(method: :delete)
+
+      subject
+    end
+
+    it "submits a request to the sessions endpoint" do
+      expect_request_submission_with(path: "sessions")
+
+      subject
+    end
+
+    it "submits a request identifying the session via a parameter" do
+      expect_request_submission_with(parameters: hash_including(http_stub_session_id: id))
+
+      subject
+    end
+
+    it "describes the intent of the request as to delete the session" do
+      expect_request_submission_with(intent: "delete session '#{id}'")
+
+      subject
+    end
+
+  end
+
+  def expect_request_submission_with(element)
+    expect(server).to receive(:submit!).with(hash_including(element))
+  end
+
+end

data/spec/lib/http_stub/client_spec.rb

@@ -0,0 +1,15 @@
+describe HttpStub::Client do
+
+  describe "::create" do
+
+    let(:server_uri) { "http://some.server.uri" }
+
+    subject { described_class.create(server_uri) }
+
+    it "returns a client" do
+      expect(subject).to be_an_instance_of(HttpStub::Client::Client)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/{configurer/dsl/server_endpoint_template_spec.rb → configurator/endpoint_template_spec.rb}

@@ -1,19 +1,17 @@
-describe HttpStub::Configurer::DSL::ServerEndpointTemplate do
+describe HttpStub::Configurator::EndpointTemplate do
 
-  let(:server)                    { instance_double(HttpStub::Configurer::DSL::Server) }
-  let(:session_endpoint_template) { instance_double(HttpStub::Configurer::DSL::SessionEndpointTemplate) }
-  let(:active_session)            do
-    instance_double(HttpStub::Configurer::DSL::Session, endpoint_template: session_endpoint_template)
-  end
-  let(:initial_block_verifier)    { double("BlockVerifier") }
-  let(:block)                     { lambda { initial_block_verifier.verify } }
+  let(:server)                 { instance_double(HttpStub::Configurator::Server) }
+  let(:default_stub_template)  { instance_double(HttpStub::Configurator::Stub::Template) }
+  let(:endpoint_stub_template) { instance_double(HttpStub::Configurator::Stub::Template) }
+  let(:initial_block_verifier) { double("BlockVerifier") }
+  let(:initial_block)          { lambda { initial_block_verifier.verify } }
 
-  let(:server_endpoint_template) { described_class.new(server, active_session, &block) }
+  let(:server_endpoint_template) { described_class.new(server, default_stub_template, &initial_block) }
 
-  before(:each) { }
+  before(:example) { allow(HttpStub::Configurator::Stub::Template).to receive(:new).and_return(endpoint_stub_template) }
 
-  it "creates a session template in the active session that is initialized with the provided block" do
-    expect(active_session).to receive(:endpoint_template).and_yield
+  it "creates a stub template that is initialized with provided default stub template and block" do
+    expect(HttpStub::Configurator::Stub::Template).to receive(:new).with(default_stub_template).and_yield
     expect(initial_block_verifier).to receive(:verify)
 
     server_endpoint_template
@@ -25,8 +23,8 @@ describe HttpStub::Configurer::DSL::ServerEndpointTemplate do
 
     subject { server_endpoint_template.match_requests(request_matching_rules) }
 
-    it "delegates to the session template" do
-      expect(session_endpoint_template).to receive(:match_requests).with(request_matching_rules)
+    it "delegates to the endpoints stub template" do
+      expect(endpoint_stub_template).to receive(:match_requests).with(request_matching_rules)
 
       subject
     end
@@ -40,15 +38,15 @@ describe HttpStub::Configurer::DSL::ServerEndpointTemplate do
 
     subject { server_endpoint_template.schema(type, definition) }
 
-    it "delegates to the session template" do
-      expect(session_endpoint_template).to receive(:schema).with(type, definition)
+    it "delegates to the endpoints stub template" do
+      expect(endpoint_stub_template).to receive(:schema).with(type, definition)
 
       subject
     end
 
     it "returns the created schema" do
       schema = { schema: :some_schema }
-      expect(session_endpoint_template).to receive(:schema).and_return(schema)
+      expect(endpoint_stub_template).to receive(:schema).and_return(schema)
 
       expect(subject).to eql(schema)
     end
@@ -61,8 +59,8 @@ describe HttpStub::Configurer::DSL::ServerEndpointTemplate do
 
     subject { server_endpoint_template.respond_with(response_settings) }
 
-    it "delegates to the session templates" do
-      expect(session_endpoint_template).to receive(:respond_with).with(response_settings)
+    it "delegates to the endpoints stub template" do
+      expect(endpoint_stub_template).to receive(:respond_with).with(response_settings)
 
       subject
     end
@@ -75,8 +73,8 @@ describe HttpStub::Configurer::DSL::ServerEndpointTemplate do
 
     subject { server_endpoint_template.trigger(trigger_settings) }
 
-    it "delegates to the session template" do
-      expect(session_endpoint_template).to receive(:trigger).with(trigger_settings)
+    it "delegates to the endpoints stub template" do
+      expect(endpoint_stub_template).to receive(:trigger).with(trigger_settings)
 
       subject
     end
@@ -90,8 +88,8 @@ describe HttpStub::Configurer::DSL::ServerEndpointTemplate do
 
     subject { server_endpoint_template.invoke(&block) }
 
-    it "delegates to the session template" do
-      expect(session_endpoint_template).to receive(:invoke).and_yield
+    it "delegates to the endpoints stub template" do
+      expect(endpoint_stub_template).to receive(:invoke).and_yield
       expect(block_verifier).to receive(:verify)
 
       subject
@@ -107,8 +105,8 @@ describe HttpStub::Configurer::DSL::ServerEndpointTemplate do
 
     subject { server_endpoint_template.build_stub(response_overrides, &block) }
 
-    it "delegates to the session template" do
-      expect(session_endpoint_template).to receive(:build_stub).with(response_overrides).and_yield
+    it "delegates to the endpoints stub template" do
+      expect(endpoint_stub_template).to receive(:build_stub).with(response_overrides).and_yield
       expect(block_verifier).to receive(:verify)
 
       subject
@@ -116,48 +114,61 @@ describe HttpStub::Configurer::DSL::ServerEndpointTemplate do
 
   end
 
-  describe "#add_stub!" do
+  describe "#add_scenario!" do
 
+    let(:name)               { "Some scenario name" }
     let(:response_overrides) { { status: 201 } }
     let(:block_verifier)     { double("BlockVerifier") }
     let(:block)              { lambda { block_verifier.verify } }
 
-    subject { server_endpoint_template.add_stub!(response_overrides, &block) }
+    let(:built_stub) { instance_double(HttpStub::Configurator::Stub::Stub) }
+
+    subject { server_endpoint_template.add_scenario!(name, response_overrides, &block) }
+
+    before(:example) do
+      allow(endpoint_stub_template).to receive(:build_stub).and_return(built_stub)
+      allow(server).to receive(:add_scenario_with_one_stub!)
+    end
 
-    it "delegates to the session template" do
-      expect(session_endpoint_template).to receive(:add_stub!).with(response_overrides).and_yield
+    it "builds a stub using any provided response overrides and block" do
+      expect(endpoint_stub_template).to receive(:build_stub).with(response_overrides).and_yield
       expect(block_verifier).to receive(:verify)
 
       subject
     end
 
+    it "adds a one stub scenario to the server with the provided name and built stub" do
+      expect(server).to receive(:add_scenario_with_one_stub!).with(name, built_stub)
+
+      subject
+    end
+
   end
 
-  describe "#add_scenario!" do
+  describe "#add_stub!" do
 
-    let(:name)               { "Some scenario name" }
     let(:response_overrides) { { status: 201 } }
     let(:block_verifier)     { double("BlockVerifier") }
     let(:block)              { lambda { block_verifier.verify } }
 
-    let(:stub_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder) }
+    let(:built_stub) { instance_double(HttpStub::Configurator::Stub::Stub) }
 
-    subject { server_endpoint_template.add_scenario!(name, response_overrides, &block) }
+    subject { server_endpoint_template.add_stub!(response_overrides, &block) }
 
     before(:example) do
-      allow(session_endpoint_template).to receive(:build_stub).and_return(stub_builder)
-      allow(server).to receive(:add_scenario_with_one_stub!)
+      allow(endpoint_stub_template).to receive(:build_stub).and_return(built_stub)
+      allow(server).to receive(:add_stub!)
     end
 
     it "builds a stub using any provided response overrides and block" do
-      expect(session_endpoint_template).to receive(:build_stub).with(response_overrides).and_yield
+      expect(endpoint_stub_template).to receive(:build_stub).with(response_overrides).and_yield
       expect(block_verifier).to receive(:verify)
 
       subject
     end
 
-    it "adds a one stub scenario to the server with the provided name and created stub builder" do
-      expect(server).to receive(:add_scenario_with_one_stub!).with(name, stub_builder)
+    it "adds the built stub to the server" do
+      expect(server).to receive(:add_stub!).with(built_stub)
 
       subject
     end

data/spec/lib/http_stub/configurator/part_spec.rb

@@ -0,0 +1,103 @@
+describe HttpStub::Configurator::Part do
+
+  let(:configurator) do
+    Class.new.tap { |configurator| configurator.send(:include, HttpStub::Configurator) }
+  end
+
+  let(:part_class) do
+    Class.new.tap { |part_class| part_class.send(:include, HttpStub::Configurator::Part) }
+  end
+
+  let(:part) { part_class.new }
+
+  describe "#apply_to" do
+
+    subject { part.apply_to(configurator) }
+
+    shared_context "expect configuration methods to be automatically invoked" do
+
+      before(:example) do
+        configuration_method_names.each do |method_name|
+          part_class.send(:define_method, method_name) do
+            # Intentionally blank
+          end
+        end
+      end
+
+      it "invokes the configuration methods" do
+        configuration_method_names.each { |method_name| expect(part).to receive(method_name) }
+
+        subject
+      end
+
+    end
+
+    context "when the part has configured stubs methods" do
+
+      let(:configuration_method_names) { (1..3).map { |i| "configure_resource_#{i}_stubs".to_sym } }
+
+      include_context "expect configuration methods to be automatically invoked"
+
+    end
+
+    context "when the part has configured stub methods" do
+
+      let(:configuration_method_names) { (1..3).map { |i| "configure_resource_#{i}_stub".to_sym } }
+
+      include_context "expect configuration methods to be automatically invoked"
+
+    end
+
+    context "when the part has configured scenarios methods" do
+
+      let(:configuration_method_names) { (1..3).map { |i| "configure_resource_#{i}_scenarios".to_sym } }
+
+      include_context "expect configuration methods to be automatically invoked"
+
+    end
+
+    context "when the part has configured scenario methods" do
+
+      let(:configuration_method_names) { (1..3).map { |i| "configure_resource_#{i}_scenario".to_sym } }
+
+      include_context "expect configuration methods to be automatically invoked"
+
+    end
+
+  end
+
+  context "when applied to a configurator" do
+
+    before(:example) { part.apply_to(configurator) }
+
+    describe "other methods on the part" do
+
+      context "when available on the configurator" do
+
+        it "are available on the part" do
+          expect(part.respond_to?(:stub_server)).to be(true)
+        end
+
+        it "are delegated to the configurator" do
+          expect(part.stub_server).to eql(configurator.stub_server)
+        end
+
+      end
+
+      context "when not available on the configurator" do
+
+        it "are not available on the part" do
+          expect(part.respond_to?(:not_in_configurator)).to be(false)
+        end
+
+        it "raise an error on the part when invoked" do
+          expect { part.not_in_configurator }.to raise_error(/#{part_class}/)
+        end
+
+      end
+
+    end
+
+  end
+
+end