cybrid_api_organization_ruby 0.124.85 → 0.124.86

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

@@ -0,0 +1,317 @@
+# 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/3.3.0/gems/ethon-0.15.0/spec/ethon/easy/http/put_spec.rb

@@ -0,0 +1,168 @@
+# 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/3.3.0/gems/ethon-0.15.0/spec/ethon/easy/http_spec.rb

@@ -0,0 +1,64 @@
+# 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/3.3.0/gems/ethon-0.15.0/spec/ethon/easy/informations_spec.rb

@@ -0,0 +1,120 @@
+# 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/3.3.0/gems/ethon-0.15.0/spec/ethon/easy/mirror_spec.rb

@@ -0,0 +1,47 @@
+# 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