cybrid_api_bank_ruby 0.124.78 → 0.124.80

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.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, :redirect_url, :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

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/spec/ethon/easy/operations_spec.rb

@@ -1,271 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Ethon::Easy::Operations do
-  let(:easy) { Ethon::Easy.new }
-
-  describe "#handle" do
-    it "returns a pointer" do
-      expect(easy.handle).to be_a(FFI::Pointer)
-    end
-  end
-
-
-  describe "#perform" do
-    let(:url) { nil }
-    let(:timeout) { nil }
-    let(:connect_timeout) { nil }
-    let(:follow_location) { nil }
-    let(:max_redirs) { nil }
-    let(:user_pwd) { nil }
-    let(:http_auth) { nil }
-    let(:headers) { nil }
-    let(:protocols) { nil }
-    let(:redir_protocols) { nil }
-    let(:username) { nil }
-    let(:password) { nil }
-
-    before do
-      Ethon.logger.level = Logger::DEBUG
-      easy.url = url
-      easy.timeout = timeout
-      easy.connecttimeout = connect_timeout
-      easy.followlocation = follow_location
-      easy.maxredirs = max_redirs
-      easy.httpauth = http_auth
-      easy.headers = headers
-      easy.protocols = protocols
-      easy.redir_protocols = redir_protocols
-
-      if user_pwd
-        easy.userpwd = user_pwd
-      else
-        easy.username = username
-        easy.password = password
-      end
-
-      easy.perform
-    end
-
-    it "calls Curl.easy_perform" do
-      expect(Ethon::Curl).to receive(:easy_perform)
-      easy.perform
-    end
-
-    it "calls Curl.easy_cleanup" do
-      expect_any_instance_of(FFI::AutoPointer).to receive(:free)
-      easy.cleanup
-    end
-
-    it "logs" do
-      expect(Ethon.logger).to receive(:debug)
-      easy.perform
-    end
-
-    it "doesn't log after completing because completing could reset" do
-      easy.on_complete{ expect(Ethon.logger).to receive(:debug).never }
-      easy.perform
-    end
-
-    context "when url" do
-      let(:url) { "http://localhost:3001/" }
-
-      it "returns ok" do
-        expect(easy.return_code).to eq(:ok)
-      end
-
-      it "sets response body" do
-        expect(easy.response_body).to be
-      end
-
-      it "sets response headers" do
-        expect(easy.response_headers).to be
-      end
-
-      context "when request timed out" do
-        let(:url) { "http://localhost:3001/?delay=1" }
-        let(:timeout) { 1 }
-
-        it "returns operation_timedout" do
-          expect(easy.return_code).to eq(:operation_timedout)
-        end
-      end
-
-      context "when connection timed out" do
-        let(:url) { "http://localhost:3009" }
-        let(:connect_timeout) { 1 }
-
-        it "returns couldnt_connect" do
-          expect(easy.return_code).to eq(:couldnt_connect)
-        end
-      end
-
-      context "when no follow location" do
-        let(:url) { "http://localhost:3001/redirect" }
-        let(:follow_location) { false }
-
-        it "doesn't follow" do
-          expect(easy.response_code).to eq(302)
-          expect(easy.redirect_url).to eq("http://localhost:3001/")
-        end
-      end
-
-      context "when follow location" do
-        let(:url) { "http://localhost:3001/redirect" }
-        let(:follow_location) { true }
-
-        it "follows" do
-          expect(easy.response_code).to eq(200)
-          expect(easy.redirect_url).to eq(nil)
-        end
-
-        context "when infinite redirect loop" do
-          let(:url) { "http://localhost:3001/bad_redirect" }
-          let(:max_redirs) { 5 }
-
-          context "when max redirect set" do
-            it "follows only x times" do
-              expect(easy.response_code).to eq(302)
-              expect(easy.redirect_url).to eq("http://localhost:3001/bad_redirect")
-            end
-          end
-        end
-      end
-
-      context "when user agent" do
-        let(:headers) { { 'User-Agent' => 'Ethon' } }
-
-        it "sets" do
-          expect(easy.response_body).to include('"HTTP_USER_AGENT":"Ethon"')
-        end
-      end
-    end
-
-    context "when auth url" do
-      before { easy.url = url }
-
-      context "when basic auth" do
-        let(:url) { "http://localhost:3001/auth_basic/username/password" }
-
-        context "when no user_pwd" do
-          it "returns 401" do
-            expect(easy.response_code).to eq(401)
-          end
-        end
-
-        context "when invalid user_pwd" do
-          let(:user_pwd) { "invalid:invalid" }
-
-          it "returns 401" do
-            expect(easy.response_code).to eq(401)
-          end
-        end
-
-        context "when valid user_pwd" do
-          let(:user_pwd) { "username:password" }
-
-          it "returns 200" do
-            expect(easy.response_code).to eq(200)
-          end
-        end
-
-        context "when user and password" do
-          let(:username) { "username" }
-          let(:password) { "password" }
-
-          it "returns 200" do
-            expect(easy.response_code).to eq(200)
-          end
-        end
-      end
-
-      context "when ntlm" do
-        let(:url) { "http://localhost:3001/auth_ntlm" }
-        let(:http_auth) { :ntlm }
-
-        context "when no user_pwd" do
-          it "returns 401" do
-            expect(easy.response_code).to eq(401)
-          end
-        end
-
-        context "when user_pwd" do
-          let(:user_pwd) { "username:password" }
-
-          it "returns 200" do
-            expect(easy.response_code).to eq(200)
-          end
-        end
-      end
-    end
-
-    context "when protocols" do
-      context "when asking for a allowed url" do
-        let(:url) { "http://localhost:3001" }
-        let(:protocols) { :http }
-
-        it "returns ok" do
-          expect(easy.return_code).to be(:ok)
-        end
-      end
-
-      context "when asking for a not allowed url" do
-        let(:url) { "http://localhost:3001" }
-        let(:protocols) { :https }
-
-        it "returns unsupported_protocol" do
-          expect(easy.return_code).to be(:unsupported_protocol)
-        end
-      end
-    end
-
-    context "when multiple protocols" do
-      context "when asking for a allowed url" do
-        let(:protocols) { [:http, :https] }
-
-        context "when http" do
-          let(:url) { "http://localhost:3001" }
-
-          it "returns ok for http" do
-            expect(easy.return_code).to be(:ok)
-          end
-        end
-
-        context "when https" do
-          let(:url) { "https://localhost:3001" }
-
-          it "returns ssl_connect_error for https" do
-            expect(easy.return_code).to be(:ssl_connect_error)
-          end
-        end
-      end
-
-      context "when asking for a not allowed url" do
-        let(:url) { "ssh://localhost" }
-        let(:protocols) { [:https, :http] }
-
-        it "returns unsupported_protocol" do
-          expect(easy.return_code).to be(:unsupported_protocol)
-        end
-      end
-    end
-
-    context "when redir_protocols" do
-      context "when redirecting to a not allowed url" do
-        let(:url) { "http://localhost:3001/redirect" }
-        let(:follow_location) { true }
-        let(:redir_protocols) { :https }
-
-        it "returns unsupported_protocol" do
-          expect(easy.return_code).to be(:unsupported_protocol)
-        end
-      end
-    end
-
-    context "when no url" do
-      it "returns url_malformat" do
-        expect(easy.perform).to eq(:url_malformat)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/spec/ethon/easy/options_spec.rb

@@ -1,193 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Ethon::Easy::Options do
-  let(:easy) { Ethon::Easy.new }
-
-  [
-    :accept_encoding, :cainfo, :capath, :connecttimeout, :connecttimeout_ms, :cookie,
-    :cookiejar, :cookiefile, :copypostfields, :customrequest, :dns_cache_timeout,
-    :followlocation, :forbid_reuse, :http_version, :httpauth, :httpget, :httppost,
-    :infilesize, :interface, :keypasswd, :maxredirs, :nobody, :nosignal,
-    :postfieldsize, :postredir, :protocols, :proxy, :proxyauth, :proxyport, :proxytype,
-    :proxyuserpwd, :readdata, :readfunction, :redir_protocols, :ssl_verifyhost,
-    :ssl_verifypeer, :sslcert, :sslcerttype, :sslkey, :sslkeytype, :sslversion,
-    :timeout, :timeout_ms, :unrestricted_auth, :upload, :url, :useragent,
-    :userpwd, :verbose, :pipewait, :dns_shuffle_addresses, :path_as_is
-  ].each do |name|
-    describe "#{name}=" do
-      it "responds_to" do
-        expect(easy).to respond_to("#{name}=")
-      end
-
-      it "sets option" do
-        expect_any_instance_of(Ethon::Easy).to receive(:set_callbacks)
-        expect(Ethon::Curl).to receive(:set_option).with(name, anything, anything)
-        value = case name
-        when :http_version
-          :httpv1_0
-        when :httpauth
-          :basic
-        when :protocols, :redir_protocols
-          :http
-        when :postredir
-          :post_301
-        when :proxytype
-          :http
-        when :sslversion
-          :default
-        when :httppost
-          FFI::Pointer::NULL
-        else
-          1
-        end
-        easy.method("#{name}=").call(value)
-      end
-    end
-  end
-
-  describe '#escape?' do
-    context 'by default' do
-      it 'returns true' do
-        expect(easy.escape?).to be_truthy
-      end
-    end
-
-    context 'when #escape=nil' do
-      it 'returns true' do
-        easy.escape = nil
-        expect(easy.escape?).to be_truthy
-      end
-    end
-
-    context 'when #escape=true' do
-      it 'returns true' do
-        easy.escape = true
-        expect(easy.escape?).to be_truthy
-      end
-    end
-
-    context 'when #escape=false' do
-      it 'returns true' do
-        easy.escape = false
-        expect(easy.escape?).to be_falsey
-      end
-    end
-  end
-
-  describe '#multipart?' do
-    context 'by default' do
-      it 'returns false' do
-        expect(easy.multipart?).to be_falsey
-      end
-    end
-
-    context 'when #multipart=nil' do
-      it 'returns false' do
-        easy.multipart = nil
-        expect(easy.multipart?).to be_falsey
-      end
-    end
-
-    context 'when #multipart=true' do
-      it 'returns true' do
-        easy.multipart = true
-        expect(easy.multipart?).to be_truthy
-      end
-    end
-
-    context 'when #multipart=false' do
-      it 'returns false' do
-        easy.multipart = false
-        expect(easy.multipart?).to be_falsey
-      end
-    end
-  end
-
-  describe "#httppost=" do
-    it "raises unless given a FFI::Pointer" do
-      expect{ easy.httppost = 1 }.to raise_error(Ethon::Errors::InvalidValue)
-    end
-  end
-
-  context "when requesting" do
-    let(:url) { "localhost:3001" }
-    let(:timeout) { nil }
-    let(:timeout_ms) { nil }
-    let(:connecttimeout) { nil }
-    let(:connecttimeout_ms) { nil }
-    let(:userpwd) { nil }
-
-    before do
-      easy.url = url
-      easy.timeout = timeout
-      easy.timeout_ms = timeout_ms
-      easy.connecttimeout = connecttimeout
-      easy.connecttimeout_ms = connecttimeout_ms
-      easy.userpwd = userpwd
-      easy.perform
-    end
-
-    context "when userpwd" do
-      context "when contains /" do
-        let(:url) { "localhost:3001/auth_basic/test/te%2Fst" }
-        let(:userpwd) { "test:te/st" }
-
-        it "works" do
-          expect(easy.response_code).to eq(200)
-        end
-      end
-    end
-
-    context "when timeout" do
-      let(:timeout) { 1 }
-
-      context "when request takes longer" do
-        let(:url) { "localhost:3001?delay=2" }
-
-        it "times out" do
-          expect(easy.return_code).to eq(:operation_timedout)
-        end
-      end
-    end
-
-    context "when connecttimeout" do
-      let(:connecttimeout) { 1 }
-
-      context "when cannot connect" do
-        let(:url) { "localhost:3002" }
-
-        it "times out" do
-          expect(easy.return_code).to eq(:couldnt_connect)
-        end
-      end
-    end
-
-    if Ethon::Easy.supports_timeout_ms?
-      context "when timeout_ms" do
-        let(:timeout_ms) { 100 }
-
-        context "when request takes longer" do
-          let(:url) { "localhost:3001?delay=1" }
-
-          it "times out" do
-            expect(easy.return_code).to eq(:operation_timedout)
-          end
-        end
-      end
-
-      context "when connecttimeout_ms" do
-        let(:connecttimeout_ms) { 100 }
-
-        context "when cannot connect" do
-          let(:url) { "localhost:3002" }
-
-          it "times out" do
-            # this can either lead to a timeout or couldnt connect depending on which happens first
-            expect([:couldnt_connect, :operation_timedout]).to include(easy.return_code)
-          end
-        end
-      end
-    end
-  end
-end