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/request/http/multipart_spec.rb DELETED Viewed

@@ -1,118 +0,0 @@
-describe HttpStub::Configurer::Request::Http::Multipart do
-  class HttpStub::Configurer::Request::SomeModel
-    attr_reader :payload, :response_files
-    def initialize(args)
-      @payload        = args[:payload]
-      @response_files = args[:response_files]
-    end
-  end
-  let(:payload)        { { key: "value" } }
-  let(:response_files) { [] }
-  let(:path)  { "some/model/path" }
-  let(:model) { HttpStub::Configurer::Request::SomeModel.new(payload: payload, response_files: response_files) }
-  let(:args)  { { path: path , model: model } }
-  let(:multipart_request) { HttpStub::Configurer::Request::Http::Multipart.new(args) }
-  describe "#to_http_request" do
-    subject { multipart_request.to_http_request }
-    it "creates a HTTP multipart request" do
-      expect(Net::HTTP::Post::Multipart).to receive(:new)
-      subject
-    end
-    it "returns the created HTTP multipart request" do
-      http_multipart_request = instance_double(Net::HTTP::Post::Multipart)
-      allow(Net::HTTP::Post::Multipart).to receive(:new).and_return(http_multipart_request)
-      expect(subject).to eql(http_multipart_request)
-    end
-    it "creates a HTTP request with the provided path prefixed with http_stub scoping" do
-      expect(Net::HTTP::Post::Multipart).to receive(:new).with("/http_stub/some/model/path", anything, anything)
-      subject
-    end
-    it "creates a HTTP request with a payload parameter containing the JSON representation of the payload" do
-      expect(Net::HTTP::Post::Multipart).to(
-        receive(:new).with(anything, hash_including(payload: payload.to_json), anything)
-      )
-      subject
-    end
-    context "when the payload contains response files" do
-      let(:response_files) do
-        (1..3).map do |i|
-          instance_double(HttpStub::Configurer::Request::StubResponseFile,
-                          id: "id#{i}", path: "file/path/#{i}", type: "file-type-#{i}", name: "file_name_#{i}")
-        end
-      end
-      it "creates a HTTP request with an upload parameter for each file keyed on the file ID" do
-        expected_upload_parameters = response_files.reduce({}) do |result, response_file|
-          upload_file = instance_double(UploadIO)
-          expect(UploadIO).to(
-            receive(:new).with(response_file.path, response_file.type, response_file.name).and_return(upload_file)
-          )
-          result.tap { |hash| hash["response_file_#{response_file.id}"] = upload_file }
-        end
-        expect(Net::HTTP::Post::Multipart).to(
-          receive(:new).with(anything, hash_including(expected_upload_parameters), anything)
-        )
-        subject
-      end
-    end
-    context "when the payload contains no response files" do
-      it "creates a HTTP request with no upload parameters" do
-        expect(Net::HTTP::Post::Multipart).to receive(:new).with(anything, { payload: payload.to_json }, anything)
-        subject
-      end
-    end
-    context "when headers are provided" do
-      let(:headers) { (1..3).each_with_object({}) { |i, result| result["header#{i}"] = "value#{i}" } }
-      let(:args) { { path: path, headers: headers, model: model } }
-      it "creates a HTTP request with the provided headers" do
-        expect(Net::HTTP::Post::Multipart).to receive(:new).with(anything, anything, headers)
-        subject
-      end
-    end
-    context "when no headers are provided" do
-      let(:args) { { path: path, model: model } }
-      it "creates a HTTP request with empty headers" do
-        expect(Net::HTTP::Post::Multipart).to receive(:new).with(anything, anything, {})
-        subject
-      end
-    end
-  end
-end

data/spec/lib/http_stub/configurer/request/omittable_spec.rb DELETED Viewed

@@ -1,70 +0,0 @@
-describe HttpStub::Configurer::Request::Omittable do
-  describe "::format" do
-    context "when the value is a hash" do
-      context "that contains entries with values that are :omitted" do
-        let(:value) do
-          (1..5).reduce({}) do |result, i|
-            result["key#{i}"] = (i % 2 == 0) ? "value#{i}" : :omitted
-            result
-          end
-        end
-        it "returns a hash containing the omitted values converted to 'control:omitted'" do
-          expected_hash = (1..5).reduce({}) do |result, i|
-            result["key#{i}"] = (i % 2 == 0) ? "value#{i}" : "control:omitted"
-            result
-          end
-          expect(perform_format).to eql(expected_hash)
-        end
-      end
-      context "that contains no entries to be omitted" do
-        let(:value) do
-          (1..3).reduce({}) do |result, i|
-            result["key#{i}"] = "value#{i}"
-            result
-          end
-        end
-        it "returns the hash unchanged" do
-          expect(perform_format).to eql(value)
-        end
-      end
-      context "that is empty" do
-        let(:value) { {} }
-        it "returns the hash unchanged" do
-          expect(perform_format).to eql({})
-        end
-      end
-    end
-    context "when the value is not a hash" do
-      let(:value) { "not a hash" }
-      it "returns the value unchanged" do
-        expect(perform_format).to eql(value)
-      end
-    end
-    def perform_format
-      HttpStub::Configurer::Request::Omittable.format(value)
-    end
-  end
-end

data/spec/lib/http_stub/configurer/request/regexpable_spec.rb DELETED Viewed

@@ -1,77 +0,0 @@
-describe HttpStub::Configurer::Request::Regexpable do
-  describe "#format" do
-    describe "when the value is a string" do
-      let(:value) { "some string value" }
-      it "returns the value unaltered" do
-        expect(HttpStub::Configurer::Request::Regexpable.format(value)).to eql(value)
-      end
-    end
-    describe "when the value is a regular expression" do
-      let(:value) { /.+?[a-z]/ }
-      it "returns a string prefixed by 'regexp:'" do
-        expect(HttpStub::Configurer::Request::Regexpable.format(value)).to start_with("regexp:")
-      end
-      it "contains the regular expression converted to a string" do
-        expect(HttpStub::Configurer::Request::Regexpable.format(value)).to end_with(".+?[a-z]")
-      end
-      describe "and the regular expression contain escaped meta characters" do
-        let(:value) { /\^\+\[/ }
-        it "returns a string that retains the escape characters" do
-          expect(HttpStub::Configurer::Request::Regexpable.format(value)).to include("\\^\\+\\[")
-        end
-      end
-      describe "and the regular expression contain path separators" do
-        let(:value) { /\/some\/path/ }
-        it "represents the path separators as a single forward-slash" do
-          expect(HttpStub::Configurer::Request::Regexpable.format(value)).to end_with("/some/path")
-        end
-      end
-    end
-    describe "when the value is a hash" do
-      describe "and the hash has multiple entries" do
-        let(:value) { { key1: "value1", key2: /^.*value2$/, key3: "value3" } }
-        it "returns a json representation of the hash whose values are their regexpable form" do
-          expected_formatted_hash = {key1: "value1", key2: "regexp:^.*value2$", key3: "value3"}
-          expect(HttpStub::Configurer::Request::Regexpable.format(value)).to eql(expected_formatted_hash)
-        end
-      end
-      describe "and the hash is empty" do
-        let(:value) { {} }
-        it "returns an empty hash" do
-          expect(HttpStub::Configurer::Request::Regexpable.format(value)).to eql({})
-        end
-      end
-    end
-  end
-end

data/spec/lib/http_stub/configurer/request/scenario_spec.rb DELETED Viewed

@@ -1,69 +0,0 @@
-describe HttpStub::Configurer::Request::Scenario do
-  let(:name)                     { "Some scenario name" }
-  let(:stubs)                    { (1..3).map { instance_double(HttpStub::Configurer::Request::Stub) } }
-  let(:triggered_scenario_names) { (1..3).map { |i| "Triggered scenario name #{i}" } }
-  let(:scenario) do
-    HttpStub::Configurer::Request::Scenario.new(
-      name: name, stubs: stubs, triggered_scenario_names: triggered_scenario_names
-    )
-  end
-  describe "#payload" do
-    let(:stub_payloads) { stubs.each_with_index.map { |_stub, i| { stub_payload_key: "stub payload value #{i}" } } }
-    subject { scenario.payload }
-    before(:example) do
-      stubs.zip(stub_payloads).each { |stub, payload| allow(stub).to receive(:payload).and_return(payload) }
-    end
-    it "returns a hash containing the scenario's name" do
-      expect(subject).to include(name: name)
-    end
-    it "returns a hash containing the stub payloads" do
-      expect(subject).to include(stubs: stub_payloads)
-    end
-    it "returns a hash containing the uris to activate" do
-      expect(subject).to include(triggered_scenario_names: triggered_scenario_names)
-    end
-  end
-  describe "#response_files" do
-    let(:stub_response_files) do
-      stubs.map { (1..3).map { instance_double(HttpStub::Configurer::Request::StubResponseFile) } }
-    end
-    subject { scenario.response_files }
-    before(:example) do
-      stubs.zip(stub_response_files).each { |stub, files| allow(stub).to receive(:response_files).and_return(files) }
-    end
-    it "delegates to the stubs" do
-      stubs.zip(stub_response_files).each { |stub, files| expect(stub).to receive(:response_files).and_return(files) }
-      subject
-    end
-    it "returns the accummulation of all stub files" do
-      expect(subject).to eql(stub_response_files.flatten)
-    end
-  end
-  describe "#to_s" do
-    it "returns the scenario's name" do
-      expect(scenario.to_s).to eql(name)
-    end
-  end
-end

data/spec/lib/http_stub/configurer/request/stub_response_spec.rb DELETED Viewed

@@ -1,195 +0,0 @@
-describe HttpStub::Configurer::Request::StubResponse do
-  let(:stub_fixture) { HttpStub::StubFixture.new }
-  let(:fixture)      { stub_fixture.response }
-  let(:stub_response) { HttpStub::Configurer::Request::StubResponse.new(stub_fixture.id, fixture.symbolized) }
-  describe "#payload" do
-    subject { stub_response.payload }
-    context "when a status response argument is provided" do
-      it "has a response entry for the argument" do
-        expect(subject).to include(status: fixture.status)
-      end
-    end
-    context "when no status response argument is provided" do
-      before(:example) { fixture.status = nil }
-      it "has a response entry with an empty status code" do
-        expect(subject).to include(status: "")
-      end
-    end
-    context "when response headers are provided" do
-      it "has a headers response entry containing the the provided headers" do
-        expect(subject).to include(headers: fixture.headers)
-      end
-    end
-    context "when response headers are omitted" do
-      before(:example) { fixture.headers = nil }
-      it "has a headers response entry containing an empty hash" do
-        expect(subject).to include(headers: {})
-      end
-    end
-    context "when a response body argument is provided" do
-      before(:example) do
-        fixture.body = "some body"
-        fixture.json = nil
-      end
-      it "has a response body entry that contains the body argument" do
-        expect(subject).to include(body: fixture.body)
-      end
-    end
-    context "when a response json argument is provided" do
-      let(:json_object) { { some_key: "some value" } }
-      before(:example) do
-        fixture.body = nil
-        fixture.json = json_object
-      end
-      it "has a response body entry that contains the json argument converted to JSON" do
-        expect(subject).to include(body: json_object.to_json)
-      end
-    end
-    context "when a delay option is provided" do
-      it "has a response entry for the argument" do
-        expect(subject).to include(delay_in_seconds: fixture.delay_in_seconds)
-      end
-    end
-    context "when a delay option is omitted" do
-      before(:example) { fixture.delay_in_seconds = nil }
-      it "has a response entry with an empty delay" do
-        expect(subject).to include(delay_in_seconds: "")
-      end
-    end
-  end
-  describe "#file" do
-    subject { stub_response.file }
-    context "when the body contains a file hash" do
-      let(:content_type_key)   { "content-type" }
-      let(:content_type_value) { "some-content-type" }
-      let(:file_path)          { "some/file/path" }
-      let(:file_name)          { "some_file.name" }
-      before(:example) do
-        fixture.headers = { content_type_key => content_type_value }
-        fixture.body    = { file: { path: file_path, name: file_name } }
-      end
-      it "creates a response file containing the stub id" do
-        expect_response_file_to_be_created_with(id: stub_fixture.id)
-        subject
-      end
-      it "creates a response file containing the provided file path" do
-        expect_response_file_to_be_created_with(path: file_path)
-        subject
-      end
-      it "creates a response file containing the provided file name" do
-        expect_response_file_to_be_created_with(name: file_name)
-        subject
-      end
-      context "when the content type header key is provided" do
-        context "in lower case" do
-          let(:content_type_key) { "content-type" }
-          it "creates a response file whose type is the content-type response header" do
-            expect_response_file_to_be_created_with(type: content_type_value)
-            subject
-          end
-        end
-        context "in upper case" do
-          let(:content_type_key) { "Content-Type" }
-          it "creates a response file whose type is the content-type response header" do
-            expect_response_file_to_be_created_with(type: content_type_value)
-            subject
-          end
-        end
-      end
-      context "when the content type header is not provided" do
-        let(:content_type_value) { nil }
-        it "creates a response file whose type is nil, which allows the server to default the value" do
-          expect_response_file_to_be_created_with(type: nil)
-          subject
-        end
-      end
-      it "returns the created response file" do
-        response_file = instance_double(HttpStub::Configurer::Request::StubResponseFile)
-        allow(HttpStub::Configurer::Request::StubResponseFile).to receive(:new).and_return(response_file)
-        expect(subject).to eql(response_file)
-      end
-      def expect_response_file_to_be_created_with(hash)
-        expect(HttpStub::Configurer::Request::StubResponseFile).to receive(:new).with(hash_including(hash))
-      end
-    end
-    context "when the body contains text" do
-      before(:example) { fixture.body = "some text" }
-      it "returns nil" do
-        expect(subject).to be(nil)
-      end
-    end
-  end
-end