http_stub 0.27.0 → 0.28.0.beta1

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

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

data/spec/lib/http_stub/configurer/request/controllable_value_spec.rb

@@ -1,34 +0,0 @@
-describe HttpStub::Configurer::Request::ControllableValue do
-
-  describe "::format" do
-
-    let(:value) { "some value" }
-
-    it "formats the potential control value via the Regexpable formatter" do
-      expect(HttpStub::Configurer::Request::Regexpable).to receive(:format).with(value)
-
-      perform_format
-    end
-
-    it "chains formatting by formatting the Regexpable formatter result via the Omittable formatter" do
-      regexp_formatted_value = "some regexp formatted value"
-      allow(HttpStub::Configurer::Request::Regexpable).to receive(:format).and_return(regexp_formatted_value)
-      expect(HttpStub::Configurer::Request::Omittable).to receive(:format).with(regexp_formatted_value)
-
-      perform_format
-    end
-
-    it "returns the Omittable formatter result" do
-      omit_formatted_value = "some omit formatted value"
-      allow(HttpStub::Configurer::Request::Omittable).to receive(:format).and_return(omit_formatted_value)
-
-      expect(perform_format).to eql(omit_formatted_value)
-    end
-
-    def perform_format
-      HttpStub::Configurer::Request::ControllableValue.format(value)
-    end
-
-  end
-
-end

data/spec/lib/http_stub/configurer/request/http/basic_spec.rb

@@ -1,91 +0,0 @@
-describe HttpStub::Configurer::Request::Http::Basic do
-
-  let(:request_method) { :get }
-  let(:path)           { "some/path" }
-  let(:args)           { { method: request_method, path: path } }
-
-  let(:basic_request) { described_class.new(args) }
-
-  describe "#to_http_request" do
-
-    subject { basic_request.to_http_request }
-
-    it "returns a HTTP request of the provided type" do
-      expect(subject).to be_a(Net::HTTP::Get)
-    end
-
-    it "returns a request with the provided path prefixed with http_stub scoping" do
-      expect(subject.path).to eql("/http_stub/#{path}")
-    end
-
-    context "when headers are provided" do
-
-      let(:args) { { method: request_method, path: path, headers: headers } }
-
-      context "whose names are symbols" do
-
-        let(:headers) { (1..3).each_with_object({}) { |i, result| result["header#{i}".to_sym] = "value#{i}" } }
-
-        it "returns a request with the provided headers with names converted to strings" do
-          expect(request_headers).to include(headers.stringify_keys)
-        end
-
-      end
-
-      context "whose names are strings" do
-
-        let(:headers) { (1..3).each_with_object({}) { |i, result| result["header#{i}"] = "value#{i}" } }
-
-        it "returns a request with the provided headers" do
-          expect(request_headers).to include(headers)
-        end
-
-      end
-
-    end
-
-    context "when headers are not provided" do
-
-      it "returns a request with default headers" do
-        expect(request_headers).to_not be_empty
-      end
-
-    end
-
-    context "when parameters are provided" do
-
-      let(:parameters) { (1..3).each_with_object({}) { |i, result| result["parameter#{i}"] = "value#{i}" } }
-
-      let(:args) { { method: request_method, path: path, parameters: parameters } }
-
-      it "returns a request with the provided parameters" do
-        expect(request_parameters).to eql(parameters)
-      end
-
-    end
-
-    context "when parameters are not provided" do
-
-      let(:args) { { method: request_method, path: path } }
-
-      it "returns a request without parameters" do
-        expect(subject.body).to eql(nil)
-      end
-
-    end
-
-    it "returns a request with the provided path prefixed with http_stub scoping" do
-      expect(subject.path).to eql("/http_stub/#{path}")
-    end
-
-  end
-
-  def request_headers
-    subject.to_hash.each_with_object({}) { |(key, value), result| result[key] = value.first }
-  end
-
-  def request_parameters
-    URI.decode_www_form(subject.body).to_h
-  end
-
-end

data/spec/lib/http_stub/configurer/request/http/factory_spec.rb

@@ -1,222 +0,0 @@
-describe HttpStub::Configurer::Request::Http::Factory do
-
-  describe "::multipart" do
-
-    let(:model) { double("HttpStub::Configurer::Request::SomeModel") }
-    let(:path)  { "some/model/path" }
-
-    let(:multipart_request) { instance_double(HttpStub::Configurer::Request::Http::Multipart) }
-
-    subject { described_class.multipart(path, model) }
-
-    before(:example) do
-      allow(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).and_return(multipart_request)
-    end
-
-    it "creates a multipart request with the provided path" do
-      expect(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).with(hash_including(path: path))
-
-      subject
-    end
-
-    it "creates a multipart request with the provided model" do
-      expect(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).with(hash_including(model: model))
-
-      subject
-    end
-
-    context "when headers are provided" do
-
-      let(:headers) { (1..3).each_with_object({}) { |i, result| result["header#{i}"] = "value#{i}" } }
-
-      subject { described_class.multipart(path, model, headers) }
-
-      it "creates a multipart request with the provided headers" do
-        expect(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).with(hash_including(headers: headers))
-
-        subject
-      end
-
-    end
-
-    context "when no headers are provided" do
-
-      subject { described_class.multipart(path, model) }
-
-      it "creates a multipart request with the empty headers" do
-        expect(HttpStub::Configurer::Request::Http::Multipart).to receive(:new).with(hash_including(headers: {}))
-
-        subject
-      end
-
-    end
-
-    it "returns the created request" do
-      expect(subject).to eql(multipart_request)
-    end
-
-  end
-
-  describe "::get" do
-
-    let(:path) { "/some/get/path" }
-
-    let(:basic_request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
-
-    subject { described_class.get(path) }
-
-    before(:example) { allow(HttpStub::Configurer::Request::Http::Basic).to receive(:new).and_return(basic_request) }
-
-    it "creates a basic GET request" do
-      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(method: :get))
-
-      subject
-    end
-
-    it "creates a basic request with the provided path" do
-      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(path: path))
-
-      subject
-    end
-
-    context "when headers are provided" do
-
-      let(:headers) { (1..3).each_with_object({}) { |i, result| result["header#{i}"] = "value#{i}" } }
-
-      subject { described_class.get(path, headers) }
-
-      it "creates a basic request with the provided headers" do
-        expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(headers: headers))
-
-        subject
-      end
-
-    end
-
-    context "when no headers are provided" do
-
-      subject { described_class.get(path) }
-
-      it "creates a basic request with empty headers" do
-        expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(headers: {}))
-
-        subject
-      end
-
-    end
-
-    it "returns the created basic request" do
-      expect(subject).to eql(basic_request)
-    end
-
-  end
-
-  describe "::post" do
-
-    let(:path) { "/some/post/path" }
-
-    let(:basic_request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
-
-    subject { described_class.post(path) }
-
-    before(:example) { allow(HttpStub::Configurer::Request::Http::Basic).to receive(:new).and_return(basic_request) }
-
-    it "creates a basic POST request" do
-      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(method: :post))
-
-      subject
-    end
-
-    it "creates a basic request with the provided path" do
-      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(path: path))
-
-      subject
-    end
-
-    context "when parameters are provided" do
-
-      let(:parameters) { (1..3).each_with_object({}) { |i, result| result["parameter#{i}"] = "value#{i}" } }
-
-      subject { described_class.post(path, parameters) }
-
-      it "creates a basic request with the provided parameters" do
-        expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(parameters: parameters))
-
-        subject
-      end
-
-    end
-
-    context "when no parameters are provided" do
-
-      subject { described_class.post(path) }
-
-      it "creates a basic POST request with empty parameters" do
-        allow(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(parameters: {}))
-
-        subject
-      end
-
-    end
-
-    it "returns the created basic request" do
-      expect(subject).to eql(basic_request)
-    end
-
-  end
-
-  describe "::delete" do
-
-    let(:path) { "/some/delete/path" }
-
-    let(:basic_request) { instance_double(HttpStub::Configurer::Request::Http::Basic) }
-
-    subject { described_class.delete(path) }
-
-    before(:example) { allow(HttpStub::Configurer::Request::Http::Basic).to receive(:new).and_return(basic_request) }
-
-    it "creates a basic DELETE request" do
-      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(method: :delete))
-
-      subject
-    end
-
-    it "creates a basic request with the provided path" do
-      expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(path: path))
-
-      subject
-    end
-
-    context "when headers are provided" do
-
-      let(:headers) { (1..3).each_with_object({}) { |i, result| result["header#{i}"] = "value#{i}" } }
-
-      subject { described_class.delete(path, headers) }
-
-      it "creates a basic request with the provided headers" do
-        expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(headers: headers))
-
-        subject
-      end
-
-    end
-
-    context "when no headers are provided" do
-
-      subject { described_class.delete(path) }
-
-      it "creates a basic request with empty headers" do
-        expect(HttpStub::Configurer::Request::Http::Basic).to receive(:new).with(hash_including(headers: {}))
-
-        subject
-      end
-
-    end
-
-    it "returns the created basic request" do
-      expect(subject).to eql(basic_request)
-    end
-
-  end
-
-end