cloudsmith-api 2.0.24 → 2.0.25

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.15.0/spec/ethon/easy/http/post_spec.rb

@@ -1,317 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Ethon::Easy::Http::Post do
-  let(:easy) { Ethon::Easy.new }
-  let(:url) { "http://localhost:3001/" }
-  let(:params) { nil }
-  let(:form) { nil }
-  let(:options) { Hash.new }
-  let(:post) { described_class.new(url, options.merge({:params => params, :body => form})) }
-
-  describe "#setup" do
-    context "when nothing" do
-      it "sets url" do
-        post.setup(easy)
-        expect(easy.url).to eq(url)
-      end
-
-      it "sets postfield_size" do
-        expect(easy).to receive(:postfieldsize=).with(0)
-        post.setup(easy)
-      end
-
-      it "sets copy_postfields" do
-        expect(easy).to receive(:copypostfields=).with("")
-        post.setup(easy)
-      end
-
-      it "makes a post request" do
-        post.setup(easy)
-        easy.perform
-        expect(easy.response_body).to include('"REQUEST_METHOD":"POST"')
-      end
-    end
-
-    context "when params" do
-      let(:params) { {:a => "1&"} }
-
-      it "attaches escaped to url" do
-        post.setup(easy)
-        expect(easy.url).to eq("#{url}?a=1%26")
-      end
-
-      context "with arrays" do
-        let(:params) { {:a => %w( foo bar )} }
-
-        context "by default" do
-          it "encodes them with indexes" do
-            post.setup(easy)
-            expect(easy.url).to eq("#{url}?a%5B0%5D=foo&a%5B1%5D=bar")
-          end
-        end
-
-        context "when params_encoding is :rack" do
-          let(:options) { {:params_encoding => :rack} }
-          it "encodes them without indexes" do
-            post.setup(easy)
-            expect(easy.url).to eq("#{url}?a%5B%5D=foo&a%5B%5D=bar")
-          end
-        end
-      end
-
-      context "with :escape" do
-        context 'missing' do
-          it "escapes values" do
-            post.setup(easy)
-            expect(easy.url).to eq("#{url}?a=1%26")
-          end
-        end
-
-        context 'nil' do
-          let(:options) { {:escape => nil} }
-
-          it "escapes values" do
-            post.setup(easy)
-            expect(easy.url).to eq("#{url}?a=1%26")
-          end
-        end
-
-        context 'true' do
-          let(:options) { {:escape => true} }
-
-          it "escapes values" do
-            post.setup(easy)
-            expect(easy.url).to eq("#{url}?a=1%26")
-          end
-        end
-
-        context 'false' do
-          let(:options) { {:escape => false} }
-
-          it "sends raw values" do
-            post.setup(easy)
-            expect(easy.url).to eq("#{url}?a=1&")
-          end
-        end
-      end
-
-      it "sets postfieldsize" do
-        expect(easy).to receive(:postfieldsize=).with(0)
-        post.setup(easy)
-      end
-
-      it "sets copypostfields" do
-        expect(easy).to receive(:copypostfields=).with("")
-        post.setup(easy)
-      end
-
-      context "when requesting" do
-        let(:postredir) { nil }
-
-        before do
-          easy.headers = { 'Expect' => '' }
-          post.setup(easy)
-          easy.postredir = postredir
-          easy.followlocation = true
-          easy.perform
-        end
-
-        it "is a post" do
-          expect(easy.response_body).to include('"REQUEST_METHOD":"POST"')
-        end
-
-        it "uses application/x-www-form-urlencoded content type" do
-          expect(easy.response_body).to include('"CONTENT_TYPE":"application/x-www-form-urlencoded"')
-        end
-
-        it "requests parameterized url" do
-          expect(easy.response_body).to include('"REQUEST_URI":"http://localhost:3001/?a=1%26"')
-        end
-
-        context "when redirection" do
-          let(:url) { "localhost:3001/redirect" }
-
-          context "when no postredirs" do
-            it "is a get" do
-              expect(easy.response_body).to include('"REQUEST_METHOD":"GET"')
-            end
-          end
-
-          unless ENV['TRAVIS']
-            context "when postredirs" do
-              let(:postredir) { :post_all }
-
-              it "is a post" do
-                expect(easy.response_body).to include('"REQUEST_METHOD":"POST"')
-              end
-            end
-          end
-        end
-      end
-    end
-
-    context "when body" do
-      context "when multipart" do
-        let(:form) { {:a => File.open(__FILE__, 'r')} }
-
-        it "sets httppost" do
-          expect(easy).to receive(:httppost=)
-          post.setup(easy)
-        end
-
-        context "when requesting" do
-          before do
-            easy.headers = { 'Expect' => '' }
-            post.setup(easy)
-            easy.perform
-          end
-
-          it "returns ok" do
-            expect(easy.return_code).to eq(:ok)
-          end
-
-          it "is a post" do
-            expect(easy.response_body).to include('"REQUEST_METHOD":"POST"')
-          end
-
-          it "uses multipart/form-data content type" do
-            expect(easy.response_body).to include('"CONTENT_TYPE":"multipart/form-data')
-          end
-
-          it "submits a body" do
-            expect(easy.response_body).to match('"body":".+"')
-          end
-
-          it "submits the data" do
-            expect(easy.response_body).to include('"filename":"post_spec.rb"')
-          end
-        end
-      end
-
-      context "when not multipart" do
-        let(:form) { {:a => "1&b=2"} }
-        let(:encoded) { "a=1%26b%3D2" }
-
-        it "sets escaped copypostfields" do
-          expect(easy).to receive(:copypostfields=).with(encoded)
-          post.setup(easy)
-        end
-
-        it "sets postfieldsize" do
-          expect(easy).to receive(:postfieldsize=).with(encoded.bytesize)
-          post.setup(easy)
-        end
-
-        context "when requesting" do
-          before do
-            easy.headers = { 'Expect' => '' }
-            post.setup(easy)
-            easy.perform
-          end
-
-          it "returns ok" do
-            expect(easy.return_code).to eq(:ok)
-          end
-
-          it "is a post" do
-            expect(easy.response_body).to include('"REQUEST_METHOD":"POST"')
-          end
-
-          it "uses multipart/form-data content type" do
-            expect(easy.response_body).to include('"CONTENT_TYPE":"application/x-www-form-urlencoded')
-          end
-
-          it "submits a body" do
-            expect(easy.response_body).to match('"body":"a=1%26b%3D2"')
-          end
-
-          it "submits the data" do
-            expect(easy.response_body).to include('"rack.request.form_hash":{"a":"1&b=2"}')
-          end
-        end
-      end
-
-      context "when string" do
-        let(:form) { "{a: 1}" }
-
-        context "when requesting" do
-          before do
-            easy.headers = { 'Expect' => '' }
-            post.setup(easy)
-            easy.perform
-          end
-
-          it "returns ok" do
-            expect(easy.return_code).to eq(:ok)
-          end
-
-          it "sends string" do
-            expect(easy.response_body).to include('"body":"{a: 1}"')
-          end
-        end
-      end
-
-      context "when binary with null bytes" do
-        let(:form) { [1, 0, 1].pack('c*') }
-
-        context "when requesting" do
-          before do
-            easy.headers = { 'Expect' => '' }
-            post.setup(easy)
-            easy.perform
-          end
-
-          it "returns ok" do
-            expect(easy.return_code).to eq(:ok)
-          end
-
-          it "sends binary data" do
-            expect(easy.response_body).to include('"body":"\\u0001\\u0000\\u0001"')
-          end
-        end
-      end
-
-      context "when arrays" do
-        let(:form) { {:a => %w( foo bar )} }
-
-        context "by default" do
-          it "sets copypostfields with indexed, escaped representation" do
-            expect(easy).to receive(:copypostfields=).with('a%5B0%5D=foo&a%5B1%5D=bar')
-            post.setup(easy)
-          end
-        end
-
-        context "when params_encoding is :rack" do
-          let(:options) { {:params_encoding => :rack} }
-
-          it "sets copypostfields with non-indexed, escaped representation" do
-            expect(easy).to receive(:copypostfields=).with('a%5B%5D=foo&a%5B%5D=bar')
-            post.setup(easy)
-          end
-        end
-      end
-    end
-
-    context "when params and body" do
-      let(:form) { {:a => "1"} }
-      let(:params) { {:b => "2"} }
-
-      context "when requesting" do
-        before do
-          easy.headers = { 'Expect' => '' }
-          post.setup(easy)
-          easy.perform
-        end
-
-        it "url contains params" do
-          expect(easy.response_body).to include('"REQUEST_URI":"http://localhost:3001/?b=2"')
-        end
-
-        it "body contains form" do
-          expect(easy.response_body).to include('"body":"a=1"')
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.15.0/spec/ethon/easy/http/put_spec.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Ethon::Easy::Http::Put do
-  let(:easy) { Ethon::Easy.new }
-  let(:url) { "http://localhost:3001/" }
-  let(:params) { nil }
-  let(:form) { nil }
-  let(:options) { Hash.new }
-  let(:put) { described_class.new(url, options.merge({:params => params, :body => form})) }
-
-  describe "#setup" do
-    context "when nothing" do
-      it "sets url" do
-        put.setup(easy)
-        expect(easy.url).to eq(url)
-      end
-
-      it "sets upload" do
-        expect(easy).to receive(:upload=).with(true)
-        put.setup(easy)
-      end
-
-      it "sets infilesize" do
-        expect(easy).to receive(:infilesize=).with(0)
-        put.setup(easy)
-      end
-
-      context "when requesting" do
-        it "makes a put request" do
-          put.setup(easy)
-          easy.perform
-          expect(easy.response_body).to include('"REQUEST_METHOD":"PUT"')
-        end
-      end
-    end
-
-    context "when params" do
-      let(:params) { {:a => "1&"} }
-
-      it "attaches escaped to url" do
-        put.setup(easy)
-        expect(easy.url).to eq("#{url}?a=1%26")
-      end
-
-      context "with arrays" do
-        let(:params) { {:a => %w( foo bar )} }
-
-        context "by default" do
-          it "encodes them with indexes" do
-            put.setup(easy)
-            expect(easy.url).to eq("#{url}?a%5B0%5D=foo&a%5B1%5D=bar")
-          end
-        end
-
-        context "when params_encoding is :rack" do
-          let(:options) { {:params_encoding => :rack} }
-          it "encodes them without indexes" do
-            put.setup(easy)
-            expect(easy.url).to eq("#{url}?a%5B%5D=foo&a%5B%5D=bar")
-          end
-        end
-      end
-
-      it "sets upload" do
-        expect(easy).to receive(:upload=).with(true)
-        put.setup(easy)
-      end
-
-      it "sets infilesize" do
-        expect(easy).to receive(:infilesize=).with(0)
-        put.setup(easy)
-      end
-
-      context "when requesting" do
-        before do
-          put.setup(easy)
-          easy.perform
-        end
-
-        it "makes a put request" do
-          expect(easy.response_body).to include('"REQUEST_METHOD":"PUT"')
-        end
-      end
-    end
-
-    context "when body" do
-      let(:form) { {:a => "1&b=2"} }
-
-      it "sets infilesize" do
-        expect(easy).to receive(:infilesize=).with(11)
-        put.setup(easy)
-      end
-
-      it "sets readfunction" do
-        expect(easy).to receive(:readfunction)
-        put.setup(easy)
-      end
-
-      it "sets upload" do
-        expect(easy).to receive(:upload=).with(true)
-        put.setup(easy)
-      end
-
-      context "when requesting" do
-        context "sending string body" do
-          before do
-            easy.headers = { 'Expect' => '' }
-            put.setup(easy)
-            easy.perform
-          end
-
-          it "makes a put request" do
-            expect(easy.response_body).to include('"REQUEST_METHOD":"PUT"')
-          end
-
-          it "submits a body" do
-            expect(easy.response_body).to include('"body":"a=1%26b%3D2"')
-          end
-        end
-
-        context "when injecting a file as body" do
-          let(:file) { File.open(__FILE__) }
-          let(:easy) do
-            e = Ethon::Easy.new(:url => url, :upload => true)
-            e.set_read_callback(file)
-            e.infilesize = File.size(file.path)
-            e
-          end
-
-          before do
-            easy.headers = { 'Expect' => '' }
-            easy.perform
-          end
-
-          it "submits file" do
-            expect(easy.response_body).to include("injecting")
-          end
-        end
-      end
-
-      context "when arrays" do
-        let(:form) { {:a => %w( foo bar )} }
-
-        before do
-          put.setup(easy)
-          easy.perform
-        end
-
-        context "by default" do
-          it "submits an indexed, escaped representation" do
-            expect(easy.response_body).to include('"body":"a%5B0%5D=foo&a%5B1%5D=bar"')
-          end
-        end
-
-        context "when params_encoding is :rack" do
-          let(:options) { {:params_encoding => :rack} }
-
-          it "submits an non-indexed, escaped representation" do
-            expect(easy.response_body).to include('"body":"a%5B%5D=foo&a%5B%5D=bar"')
-          end
-        end
-      end
-    end
-
-    context "when params and body"
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.15.0/spec/ethon/easy/http_spec.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Ethon::Easy::Http do
-  let(:easy) { Ethon::Easy.new }
-
-  describe "#http_request" do
-    let(:url) { "http://localhost:3001/" }
-    let(:action_name) { :get }
-    let(:options) { {} }
-
-    let(:get) { double(:setup) }
-    let(:get_class) { Ethon::Easy::Http::Get }
-
-    it "instanciates action" do
-      expect(get).to receive(:setup)
-      expect(get_class).to receive(:new).and_return(get)
-      easy.http_request(url, action_name, options)
-    end
-
-    context "when requesting" do
-      [ :get, :post, :put, :delete, :head, :patch, :options ].map do |action|
-        it "returns ok" do
-          easy.http_request(url, action, options)
-          easy.perform
-          expect(easy.return_code).to be(:ok)
-        end
-
-        unless action == :head
-          it "makes a #{action.to_s.upcase} request" do
-            easy.http_request(url, action, options)
-            easy.perform
-            expect(easy.response_body).to include("\"REQUEST_METHOD\":\"#{action.to_s.upcase}\"")
-          end
-
-          it "streams the response body from the #{action.to_s.upcase} request" do
-            bytes_read = 0
-            easy.on_body { |chunk, response| bytes_read += chunk.bytesize }
-            easy.http_request(url, action, options)
-            easy.perform
-            content_length = ((easy.response_headers =~ /Content-Length: (\d+)/) && $1.to_i)
-            expect(bytes_read).to eq(content_length)
-            expect(easy.response_body).to eq("")
-          end
-
-          it "notifies when headers are ready" do
-            headers = []
-            easy.on_headers { |r| headers << r.response_headers }
-            easy.http_request(url, action, options)
-            easy.perform
-            expect(headers).to eq([easy.response_headers])
-            expect(headers.first).to match(/Content-Length: (\d+)/)
-          end
-        end
-      end
-
-      it "makes requests with custom HTTP verbs" do
-        easy.http_request(url, :purge, options)
-        easy.perform
-        expect(easy.response_body).to include(%{"REQUEST_METHOD":"PURGE"})
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.15.0/spec/ethon/easy/informations_spec.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Ethon::Easy::Informations do
-  let(:easy) { Ethon::Easy.new }
-
-  before do
-    easy.url = "http://localhost:3001"
-    easy.perform
-  end
-
-  describe "#httpauth_avail" do
-    it "returns" do
-      expect(easy.httpauth_avail).to be
-    end
-  end
-
-  describe "#total_time" do
-    it "returns float" do
-      expect(easy.total_time).to be_a(Float)
-    end
-  end
-
-  describe "#starttransfer_time" do
-    it "returns float" do
-      expect(easy.starttransfer_time).to be_a(Float)
-    end
-  end
-
-  describe "#appconnect_time" do
-    it "returns float" do
-      expect(easy.appconnect_time).to be_a(Float)
-    end
-  end
-
-  describe "#pretransfer_time" do
-    it "returns float" do
-      expect(easy.pretransfer_time).to be_a(Float)
-    end
-  end
-
-  describe "#connect_time" do
-    it "returns float" do
-      expect(easy.connect_time).to be_a(Float)
-    end
-  end
-
-  describe "#namelookup_time" do
-    it "returns float" do
-      expect(easy.namelookup_time).to be_a(Float)
-    end
-  end
-
-  describe "#redirect_time" do
-    it "returns float" do
-      expect(easy.redirect_time).to be_a(Float)
-    end
-  end
-
-  describe "#effective_url" do
-    it "returns url" do
-      expect(easy.effective_url).to match(/^http:\/\/localhost:3001\/?/)
-    end
-  end
-
-  describe "#primary_ip" do
-    it "returns localhost" do
-      expect(easy.primary_ip).to match(/::1|127\.0\.0\.1/)
-    end
-  end
-
-  describe "#response_code" do
-    it "returns 200" do
-      expect(easy.response_code).to eq(200)
-    end
-  end
-
-  describe "#redirect_count" do
-    it "returns 0" do
-      expect(easy.redirect_count).to eq(0)
-    end
-  end
-
-  describe "#request_size" do
-    it "returns 53" do
-      expect(easy.request_size).to eq(53)
-    end
-  end
-
-  describe "#supports_zlib?" do
-    it "returns true" do
-      expect(Kernel).to receive(:warn)
-      expect(easy.supports_zlib?).to be_truthy
-    end
-  end
-
-  describe "#size_upload" do
-    it "returns float" do
-      expect(easy.size_upload).to be_a(Float)
-    end
-  end
-
-  describe "#size_download" do
-    it "returns float" do
-      expect(easy.size_download).to be_a(Float)
-    end
-  end
-
-  describe "#speed_upload" do
-    it "returns float" do
-      expect(easy.speed_upload).to be_a(Float)
-    end
-  end
-
-  describe "#speed_download" do
-    it "returns float" do
-      expect(easy.speed_download).to be_a(Float)
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.15.0/spec/ethon/easy/mirror_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Ethon::Easy::Mirror do
-  let(:options) { nil }
-  let(:mirror) { described_class.new(options) }
-
-  describe "::INFORMATIONS_TO_LOG" do
-    [
-      :return_code, :response_code, :response_body, :response_headers,
-      :total_time, :starttransfer_time, :appconnect_time,
-      :pretransfer_time, :connect_time, :namelookup_time, :redirect_time,
-      :size_upload, :size_download, :speed_upload, :speed_upload,
-      :effective_url, :primary_ip, :redirect_count, :debug_info
-    ].each do |name|
-      it "contains #{name}" do
-        expect(described_class::INFORMATIONS_TO_MIRROR).to include(name)
-      end
-    end
-  end
-
-  describe "#to_hash" do
-    let(:options) { {:return_code => 1} }
-
-    it "returns mirror as hash" do
-      expect(mirror.to_hash).to eq(options)
-    end
-  end
-
-  describe "#log_informations" do
-    let(:options) { {:return_code => 1} }
-
-    it "returns hash" do
-      expect(mirror.log_informations).to be_a(Hash)
-    end
-
-    it "only calls methods that exist" do
-      described_class::INFORMATIONS_TO_LOG.each do |method_name|
-        expect(mirror.respond_to? method_name).to eql(true)
-      end
-    end
-
-    it "includes return code" do
-      expect(mirror.log_informations).to include(options)
-    end
-  end
-end