cloudsmith-api 2.0.21 → 2.0.22

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.1/spec/typhoeus/response/status_spec.rb

@@ -1,256 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Response::Status do
-  let(:response) { Typhoeus::Response.new(options) }
-  let(:options) { {} }
-
-  describe "timed_out?" do
-    context "when return code is operation_timedout" do
-      let(:options) { {:return_code => :operation_timedout} }
-
-      it "return true" do
-        expect(response).to be_timed_out
-      end
-    end
-  end
-
-  describe "#status_message" do
-    context "when no header" do
-      it "returns nil" do
-        expect(response.status_message).to be_nil
-      end
-    end
-
-    context "when header" do
-      context "when no message" do
-        let(:options) { {:response_headers => "HTTP/1.1 200\r\n"} }
-
-        it "returns nil" do
-          expect(response.status_message).to be_nil
-        end
-      end
-
-      context "when messsage" do
-        let(:options) { {:response_headers => "HTTP/1.1 200 message\r\n"} }
-
-        it "returns message" do
-          expect(response.status_message).to eq("message")
-        end
-      end
-    end
-  end
-
-  describe "#http_version" do
-    context "when no header" do
-      it "returns nil" do
-        expect(response.http_version).to be_nil
-      end
-    end
-
-    context "when header" do
-      context "when no http version" do
-        let(:options) { {:response_headers => "HTTP OK"} }
-
-        it "returns nil" do
-          expect(response.http_version).to be_nil
-        end
-      end
-
-      context "when invalid http_version" do
-        let(:options) { {:response_headers => "HTTP foo/bar OK"} }
-
-        it "returns nil" do
-          expect(response.http_version).to be_nil
-        end
-      end
-
-      context "when valid http_version" do
-        let(:options) { {:response_headers => "HTTP/1.1 OK"} }
-
-        it "returns http_version" do
-          expect(response.http_version).to eq("1.1")
-        end
-      end
-    end
-  end
-
-  describe "#success?" do
-    context "when response code 200-299" do
-      let(:options) { {:return_code => return_code, :response_code => 201} }
-
-      context "when mock" do
-        before { response.mock = true }
-
-        context "when return_code :ok" do
-          let(:return_code) { :ok }
-
-          it "returns true" do
-            expect(response.success?).to be_truthy
-          end
-        end
-
-        context "when return_code nil" do
-          let(:return_code) { nil }
-
-          it "returns true" do
-            expect(response.success?).to be_truthy
-          end
-        end
-      end
-
-      context "when no mock" do
-        before { response.mock = nil }
-
-        context "when return_code :ok" do
-          let(:return_code) { :ok }
-
-          it "returns true" do
-            expect(response.success?).to be_truthy
-          end
-        end
-
-        context "when return_code nil" do
-          let(:return_code) { nil }
-
-          it "returns false" do
-            expect(response.success?).to be_falsey
-          end
-        end
-      end
-    end
-
-    context "when response code is not 200-299" do
-      let(:options) { {:return_code => :ok, :response_code => 500} }
-
-      it "returns false" do
-        expect(response.success?).to be_falsey
-      end
-    end
-  end
-
-  describe "#failure?" do
-    context "when response code between 300-526 and 100-300" do
-      let(:options) { {:return_code => return_code, :response_code => 300} }
-
-      context "when mock" do
-        before { response.mock = true }
-
-        context "when return_code :internal_server_error" do
-          let(:return_code) { :internal_server_error }
-
-          it "returns true" do
-            expect(response.failure?).to be_truthy
-          end
-        end
-
-        context "when return_code nil" do
-          let(:return_code) { nil }
-
-          it "returns true" do
-            expect(response.failure?).to be_truthy
-          end
-        end
-      end
-
-      context "when no mock" do
-        before { response.mock = nil }
-
-        context "when return_code :internal_server_error" do
-          let(:return_code) { :internal_server_error }
-
-          it "returns true" do
-            expect(response.failure?).to be_truthy
-          end
-        end
-
-        context "when return_code nil" do
-          let(:return_code) { nil }
-
-          it "returns false" do
-            expect(response.failure?).to be_falsey
-          end
-        end
-      end
-    end
-
-    context "when response code is not 300-526" do
-      let(:options) { {:return_code => :ok, :response_code => 200} }
-
-      it "returns false" do
-        expect(response.failure?).to be_falsey
-      end
-    end
-  end
-
-  describe "#modified?" do
-    context "when response code 304" do
-      let(:options) { {:return_code => :ok, :response_code => 304} }
-
-      context "when mock" do
-        before { response.mock = true }
-
-        context "when return_code :ok" do
-          let(:return_code) { :ok }
-
-          it "returns false" do
-            expect(response.modified?).to be_falsey
-          end
-        end
-
-        context "when return_code nil" do
-          let(:return_code) { nil }
-
-          it "returns false" do
-            expect(response.modified?).to be_falsey
-          end
-        end
-      end
-
-      context "when no mock" do
-        before { response.mock = nil }
-
-        context "when return_code :ok" do
-          let(:return_code) { :ok }
-
-          it "returns false" do
-            expect(response.modified?).to be_falsey
-          end
-        end
-
-        context "when return_code nil" do
-          let(:return_code) { nil }
-
-          it "returns true" do
-            expect(response.modified?).to be_falsey
-          end
-        end
-      end
-    end
-
-    context "when response code is not 304" do
-      let(:options) { {:return_code => :ok, :response_code => 500} }
-
-      it "returns true" do
-        expect(response.modified?).to be_truthy
-      end
-    end
-  end
-
-  describe "#first_header_line" do
-    context "when multiple header" do
-      let(:options) { {:response_headers => "1\r\n\r\n2\r\nbla"} }
-
-      it "returns first line of last block" do
-        expect(response.method(:first_header_line).call).to eq("2")
-      end
-    end
-
-    context "when single header" do
-      let(:options) { {:response_headers => "1"} }
-
-      it "returns first line" do
-        expect(response.method(:first_header_line).call).to eq("1")
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.1/spec/typhoeus/response_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Response do
-  let(:response) { Typhoeus::Response.new(options) }
-  let(:options) { {} }
-
-  describe ".new" do
-    context "when options" do
-      context "when return_code" do
-        let(:options) { {:return_code => 2} }
-
-        it "stores" do
-          expect(response.options[:return_code]).to be(2)
-        end
-      end
-
-      context "when headers" do
-        let(:options) { {:headers => {'A' => 'B'}} }
-
-        it "stores unmodified" do
-          expect(response.options[:headers]).to be(options[:headers])
-        end
-
-        it "sets @headers to a Typhoeus::Response::Header" do
-          expect(response.instance_variable_get(:@headers)).to be_a(Typhoeus::Response::Header)
-        end
-
-        it "has key" do
-          expect(response.headers['A']).to eq('B')
-        end
-      end
-    end
-  end
-
-  describe "#mock" do
-    context "when @mock" do
-      before { response.mock = true }
-
-      it "returns @mock" do
-        expect(response.mock).to be_truthy
-      end
-    end
-
-    context "when options[:mock]" do
-      let(:options) { {:mock => true} }
-
-      it "returns options[:mock]" do
-        expect(response.mock).to be_truthy
-      end
-    end
-
-    context "when @mock and options[:mock]" do
-      let(:options) { {:mock => 1} }
-      before { response.mock = 2 }
-
-      it "returns @mock" do
-        expect(response.mock).to be(2)
-      end
-    end
-  end
-
-  describe "#handled_response" do
-    let(:handled_response) { Typhoeus::Response.new }
-
-    context "when @handled_response" do
-      before { response.handled_response = handled_response }
-
-      it "returns @handled_response" do
-        expect(response.handled_response).to be(handled_response)
-      end
-    end
-
-    context "when @handled_response is nil" do
-      before { response.handled_response = nil }
-
-      it "returns response" do
-        expect(response.handled_response).to be(response)
-      end
-    end
-  end
-
-  describe "#cached" do
-    context "when @cached" do
-      before { response.cached = true }
-
-      it "returns cached status" do
-        expect(response.cached?).to be_truthy
-      end
-    end
-
-    context "when @cached is nil" do
-      before { response.cached = nil }
-
-      it "returns false" do
-        expect(response.cached?).to be_falsey
-      end
-    end
-
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.1/spec/typhoeus_spec.rb

@@ -1,105 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus do
-  before(:each) do
-    Typhoeus.configure { |config| config.verbose = false; config.block_connection = false }
-  end
-
-  describe ".configure" do
-    it "yields config" do
-      Typhoeus.configure do |config|
-        expect(config).to be_a(Typhoeus::Config)
-      end
-    end
-
-    it "sets values config" do
-      Typhoeus::Config.verbose = true
-      expect(Typhoeus::Config.verbose).to be_truthy
-    end
-  end
-
-  describe ".stub" do
-    let(:base_url) { "www.example.com" }
-
-    shared_examples "lazy response construction" do
-      it "calls the block to construct a response when a request matches the stub" do
-        expected_response = Typhoeus::Response.new
-        Typhoeus.stub(base_url) do |request|
-          expected_response
-        end
-
-        response = Typhoeus.get(base_url)
-
-        expect(response).to be(expected_response)
-      end
-    end
-
-    context "when no similar expectation exists" do
-      include_examples "lazy response construction"
-
-      it "returns expectation" do
-        expect(Typhoeus.stub(base_url)).to be_a(Typhoeus::Expectation)
-      end
-
-      it "adds expectation" do
-        Typhoeus.stub(:get, "")
-        expect(Typhoeus::Expectation.all.size).to eq(1)
-      end
-    end
-
-    context "when similar expectation exists" do
-      include_examples "lazy response construction"
-
-      let(:expectation) { Typhoeus::Expectation.new(base_url) }
-      before { Typhoeus::Expectation.all << expectation }
-
-      it "returns expectation" do
-        expect(Typhoeus.stub(base_url)).to be_a(Typhoeus::Expectation)
-      end
-
-      it "doesn't add expectation" do
-        Typhoeus.stub(base_url)
-        expect(Typhoeus::Expectation.all.size).to eq(1)
-      end
-    end
-  end
-
-  describe ".before" do
-    it "adds callback" do
-      Typhoeus.before { true }
-      expect(Typhoeus.before.size).to eq(1)
-    end
-  end
-
-  describe ".with_connection" do
-    it "executes block with block connection is false" do
-      Typhoeus.with_connection { expect(Typhoeus::Config.block_connection).to be(false) }
-    end
-
-    it "sets block connection back to previous value" do
-      Typhoeus::Config.block_connection = true
-      Typhoeus.with_connection {}
-      expect(Typhoeus::Config.block_connection).to be(true)
-    end
-
-    it "returns result of block" do
-      expect(Typhoeus.with_connection { "123" }).to eq("123")
-    end
-  end
-
-  [:get, :post, :put, :delete, :head, :patch, :options].each do |name|
-    describe ".#{name}" do
-      let(:response) { Typhoeus::Request.method(name).call("http://localhost:3001") }
-
-      it "returns ok" do
-        expect(response.return_code).to eq(:ok)
-      end
-
-      unless name == :head
-        it "makes #{name.to_s.upcase} requests" do
-          expect(response.response_body).to include("\"REQUEST_METHOD\":\"#{name.to_s.upcase}\"")
-        end
-      end
-    end
-  end
-end