cybrid_api_bank_ruby 0.127.21 → 0.127.23

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

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Ethon::Easy::ResponseCallbacks do
-  let(:easy) { Ethon::Easy.new }
-
-  [:on_complete, :on_headers, :on_body, :on_progress].each do |callback_type|
-    describe "##{callback_type}" do
-      it "responds" do
-        expect(easy).to respond_to("#{callback_type}")
-      end
-
-      context "when no block given" do
-        it "returns @#{callback_type}" do
-          expect(easy.send("#{callback_type}")).to eq([])
-        end
-      end
-
-      context "when block given" do
-        it "stores" do
-          easy.send(callback_type) { p 1 }
-          expect(easy.instance_variable_get("@#{callback_type}").size).to eq(1)
-        end
-      end
-
-      context "when multiple blocks given" do
-        it "stores" do
-          easy.send(callback_type) { p 1 }
-          easy.send(callback_type) { p 2 }
-          expect(easy.instance_variable_get("@#{callback_type}").size).to eq(2)
-        end
-      end
-    end
-  end
-
-  describe "#complete" do
-    before do
-      easy.on_complete {|r| String.new(r.url) }
-    end
-
-    it "executes blocks and passes self" do
-      expect(String).to receive(:new).with(easy.url)
-      easy.complete
-    end
-
-    context "when @on_complete nil" do
-      it "doesn't raise" do
-        easy.instance_variable_set(:@on_complete, nil)
-        expect{ easy.complete }.to_not raise_error
-      end
-    end
-  end
-
-  describe "#headers" do
-    before do
-      easy.on_headers {|r| String.new(r.url) }
-    end
-
-    it "executes blocks and passes self" do
-      expect(String).to receive(:new).with(easy.url)
-      easy.headers
-    end
-
-    context "when @on_headers nil" do
-      it "doesn't raise" do
-        easy.instance_variable_set(:@on_headers, nil)
-        expect{ easy.headers }.to_not raise_error
-      end
-    end
-  end
-
-  describe "#progress" do
-    context "when requesting for realz" do
-      it "executes callback" do
-        post = Ethon::Easy::Http::Post.new("http://localhost:3001", {:body => "bar=fu"})
-        post.setup(easy)
-        @called = false
-        @has_dltotal = false
-        @has_ultotal = false
-        easy.on_progress { @called = true }
-        easy.on_progress { |dltotal, _, _, _| @has_dltotal ||= true }
-        easy.on_progress { |_, _, ultotal, _| @has_ultotal ||= true }
-        easy.perform
-        expect(@called).to be true
-        expect(@has_dltotal).to be true
-        expect(@has_ultotal).to be true
-      end
-    end
-
-    context "when pretending" do
-      before do
-        @dltotal = nil
-        @dlnow = nil
-        @ultotal = nil
-        @ulnow = nil
-        easy.on_progress { |dltotal, dlnow, ultotal, ulnow| @dltotal = dltotal ; @dlnow = dlnow; @ultotal = ultotal; @ulnow = ulnow }
-      end
-
-      it "executes blocks and passes dltotal" do
-        easy.progress(1, 2, 3, 4)
-        expect(@dltotal).to eq(1)
-      end
-
-      it "executes blocks and passes dlnow" do
-        easy.progress(1, 2, 3, 4)
-        expect(@dlnow).to eq(2)
-      end
-
-      it "executes blocks and passes ultotal" do
-        easy.progress(1, 2, 3, 4)
-        expect(@ultotal).to eq(3)
-      end
-
-      it "executes blocks and passes ulnow" do
-        easy.progress(1, 2, 3, 4)
-        expect(@ulnow).to eq(4)
-      end
-
-      context "when @on_progress nil" do
-        it "doesn't raise" do
-          easy.instance_variable_set(:@on_progress, nil)
-          expect{ easy.progress(1, 2, 3, 4) }.to_not raise_error
-        end
-      end
-    end
-  end
-
-  describe "#body" do
-    before do
-      @chunk = nil
-      @r = nil
-      easy.on_body { |chunk, r| @chunk = chunk ; @r = r }
-    end
-
-    it "executes blocks and passes self" do
-      easy.body("the chunk")
-      expect(@r).to be(easy)
-    end
-
-    it "executes blocks and passes chunk" do
-      easy.body("the chunk")
-      expect(@chunk).to eq("the chunk")
-    end
-
-    context "when @on_body nil" do
-      it "doesn't raise" do
-        easy.instance_variable_set(:@on_body, nil)
-        expect{ easy.body("the chunk") }.to_not raise_error
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Ethon::Easy::Util do
-  class Dummy
-    include Ethon::Easy::Util
-  end
-
-  let(:klass) { Dummy.new }
-
-  describe "escape_zero_byte" do
-    context "when value has no zero byte" do
-      let(:value) { "hello world" }
-
-      it "returns same value" do
-        expect(klass.escape_zero_byte(value)).to be(value)
-      end
-    end
-
-    context "when value has zero byte" do
-      let(:value) { "hello \0world" }
-
-      it "returns escaped" do
-        expect(klass.escape_zero_byte(value)).to eq("hello \\0world")
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.15.0/spec/ethon/easy_spec.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Ethon::Easy do
-  let(:easy) { Ethon::Easy.new }
-
-  describe ".new" do
-    it "inits curl" do
-      expect(Ethon::Curl).to receive(:init)
-      easy
-    end
-
-    context "when options are empty" do
-      it "sets only callbacks" do
-        expect_any_instance_of(Ethon::Easy).to receive(:set_callbacks)
-        expect(Ethon::Easy).to receive(:set_option).never
-        easy
-      end
-    end
-
-    context "when options not empty" do
-      context "when followlocation is set" do
-        let(:options) { { :followlocation => true } }
-        let(:easy) { Ethon::Easy.new(options) }
-
-        it "sets followlocation" do
-          expect_any_instance_of(Ethon::Easy).to receive(:set_callbacks)
-          expect(Ethon::Curl).to receive(:set_option).with(:followlocation, true, anything)
-          easy
-        end
-      end
-    end
-  end
-
-  describe "#set_attributes" do
-    context "when options are empty" do
-      it "sets only callbacks" do
-        expect_any_instance_of(Ethon::Easy).to receive(:set_callbacks)
-        expect(Ethon::Easy).to receive(:set_option).never
-        easy
-      end
-    end
-
-    context "when options aren't empty" do
-      context "when valid key" do
-        it "sets" do
-          expect(easy).to receive(:verbose=).with(true)
-          easy.set_attributes({:verbose => true})
-        end
-      end
-
-      context "when invalid key" do
-        it "raises invalid option error" do
-          expect{ easy.set_attributes({:fubar => 1}) }.to raise_error(Ethon::Errors::InvalidOption)
-        end
-      end
-    end
-  end
-
-  describe "#reset" do
-    before { easy.url = "www.example.com" }
-
-    it "resets url" do
-      easy.reset
-      expect(easy.url).to be_nil
-    end
-
-    it "resets escape?" do
-      easy.escape = false
-      easy.reset
-      expect(easy.escape?).to be_truthy
-    end
-
-    it "resets hash" do
-      easy.reset
-      expect(easy.instance_variable_get(:@hash)).to be_nil
-    end
-
-    it "resets easy handle" do
-      expect(Ethon::Curl).to receive(:easy_reset)
-      easy.reset
-    end
-
-    it "resets on_complete" do
-      easy.on_complete { p 1 }
-      easy.reset
-      expect(easy.on_complete).to be_empty
-    end
-
-    it "resets on_headers" do
-      easy.on_headers { p 1 }
-      easy.reset
-      expect(easy.on_headers).to be_empty
-    end
-
-    it "resets on_body" do
-      easy.on_body { p 1 }
-      easy.reset
-      expect(easy.on_body).to be_empty
-    end
-  end
-
-  describe "#dup" do
-    let!(:easy) do
-      easy = Ethon::Easy.new
-      easy.url = "http://localhost:3001/"
-      easy.on_complete { 'on_complete' }
-      easy.on_headers { 'on_headers' }
-      easy.on_progress { 'on_progress' }
-      easy.response_body = String.new('test_body')
-      easy.response_headers = String.new('test_headers')
-      easy
-    end
-    let!(:e) { easy.dup }
-
-    it "sets a new handle" do
-      expect(e.handle).not_to eq(easy.handle)
-    end
-
-    it "preserves url" do
-      expect(e.url).to eq(easy.url)
-    end
-
-    it "preserves on_complete callback" do
-      expect(e.on_complete).to be(easy.on_complete)
-    end
-
-    it "preserves on_headers callback" do
-      expect(e.on_headers).to be(easy.on_headers)
-    end
-
-    it 'preserves body_write_callback of original handle' do
-      expect { easy.perform }.to change { easy.response_body }
-      expect { easy.perform }.not_to change { e.response_body }
-    end
-
-    it "preserves on_progress callback" do
-      expect(e.on_progress).to be(easy.on_progress)
-    end
-
-    it 'sets new body_write_callback of duplicated handle' do
-      expect { e.perform }.to change { e.response_body }
-      expect { e.perform }.not_to change { easy.response_body }
-    end
-
-    it 'preserves headers_write_callback of original handle' do
-      expect { easy.perform }.to change { easy.response_headers }
-      expect { easy.perform }.not_to change { e.response_headers }
-    end
-
-    it 'sets new headers_write_callback of duplicated handle' do
-      expect { e.perform }.to change { e.response_headers }
-      expect { e.perform }.not_to change { easy.response_headers }
-    end
-
-    it "resets response_body" do
-      expect(e.response_body).to be_empty
-    end
-
-    it "resets response_headers" do
-      expect(e.response_headers).to be_empty
-    end
-
-    it "sets response_body for duplicated Easy" do
-      e.perform
-      expect(e.response_body).not_to be_empty
-    end
-
-    it "sets response_headers for duplicated Easy" do
-      e.perform
-      expect(e.response_headers).not_to be_empty
-    end
-
-    it "preserves response_body for original Easy" do
-      e.perform
-      expect(easy.response_body).to eq('test_body')
-    end
-
-    it "preserves response_headers for original Easy" do
-      e.perform
-      expect(easy.response_headers).to eq('test_headers')
-    end
-  end
-
-  describe "#mirror" do
-    it "returns a Mirror" do
-      expect(easy.mirror).to be_a(Ethon::Easy::Mirror)
-    end
-
-    it "builds from easy" do
-      expect(Ethon::Easy::Mirror).to receive(:from_easy).with(easy)
-      easy.mirror
-    end
-  end
-
-  describe "#log_inspect" do
-    [ :url, :response_code, :return_code, :total_time ].each do |name|
-      it "contains #{name}" do
-        expect(easy.log_inspect).to match name.to_s
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.15.0/spec/ethon/libc_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Ethon::Libc do
-  describe "#getdtablesize", :if => !Ethon::Curl.windows? do
-    it "returns an integer" do
-      expect(Ethon::Libc.getdtablesize).to be_a(Integer)
-    end
-
-    it "returns bigger zero", :if => !Ethon::Curl.windows? do
-      expect(Ethon::Libc.getdtablesize).to_not be_zero
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.15.0/spec/ethon/loggable_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe Ethon::Loggable do
-
-  describe "#logger=" do
-
-    let(:logger) do
-      Logger.new($stdout).tap do |log|
-        log.level = Logger::INFO
-      end
-    end
-
-    before do
-      Ethon.logger = logger
-    end
-
-    it "sets the logger" do
-      expect(Ethon.logger).to eq(logger)
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/ethon-0.15.0/spec/ethon/multi/operations_spec.rb

@@ -1,298 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-describe Ethon::Multi::Operations do
-  let(:multi) { Ethon::Multi.new }
-  let(:easy) { Ethon::Easy.new }
-  let(:pointer) { FFI::MemoryPointer.new(:int) }
-
-  describe "#handle" do
-    it "returns a pointer" do
-      expect(multi.handle).to be_a(FFI::Pointer)
-    end
-  end
-
-  describe "#running_count" do
-    context "when hydra has no easy" do
-      it "returns nil" do
-        expect(multi.send(:running_count)).to be_nil
-      end
-    end
-
-    context "when hydra has easy" do
-      before do
-        easy.url = "http://localhost:3001/"
-        multi.add(easy)
-        multi.send(:trigger, pointer)
-      end
-
-      it "returns 1" do
-        expect(multi.send(:running_count)).to eq(1)
-      end
-    end
-
-    context "when hydra has more easys" do
-      let(:another_easy) { Ethon::Easy.new }
-
-      before do
-        easy.url = "http://localhost:3001/"
-        another_easy.url = "http://localhost:3001/"
-        multi.add(easy)
-        multi.add(another_easy)
-        multi.send(:trigger, pointer)
-      end
-
-      it "returns 2" do
-        expect(multi.send(:running_count)).to eq(2)
-      end
-    end
-  end
-
-  describe "#get_timeout" do
-    context "when code ok" do
-      let(:timeout) { 1 }
-
-      before do
-        expect(Ethon::Curl).to receive(:multi_timeout).and_return(:ok)
-        multi.instance_variable_set(:@timeout, double(:read_long => timeout))
-      end
-
-      it "doesn't raise" do
-        expect{ multi.send(:get_timeout) }.to_not raise_error
-      end
-
-      context "when timeout smaller zero" do
-        let(:timeout) { -1 }
-
-        it "returns 1" do
-          expect(multi.send(:get_timeout)).to eq(1)
-        end
-      end
-
-      context "when timeout bigger or equal zero" do
-        let(:timeout) { 2 }
-
-        it "returns timeout" do
-          expect(multi.send(:get_timeout)).to eq(timeout)
-        end
-      end
-    end
-
-    context "when code not ok" do
-      before { expect(Ethon::Curl).to receive(:multi_timeout).and_return(:not_ok) }
-
-      it "raises MultiTimeout error" do
-        expect{ multi.send(:get_timeout) }.to raise_error(Ethon::Errors::MultiTimeout)
-      end
-    end
-  end
-
-  describe "#set_fds" do
-    let(:timeout) { 1 }
-    let(:max_fd) { 1 }
-
-    context "when code ok" do
-      before { expect(Ethon::Curl).to receive(:multi_fdset).and_return(:ok) }
-
-      it "doesn't raise" do
-        expect{ multi.method(:set_fds).call(timeout) }.to_not raise_error
-      end
-
-      context "when max_fd -1" do
-        let(:max_fd) { -1 }
-
-        before do
-          multi.instance_variable_set(:@max_fd, double(:read_int => max_fd))
-          expect(multi).to receive(:sleep).with(0.001)
-        end
-
-        it "waits 100ms" do
-          multi.method(:set_fds).call(timeout)
-        end
-      end
-
-      context "when max_fd not -1" do
-        context "when code smaller zero" do
-          before { expect(Ethon::Curl).to receive(:select).and_return(-1) }
-
-          it "raises Select error" do
-            expect{ multi.method(:set_fds).call(timeout) }.to raise_error(Ethon::Errors::Select)
-          end
-        end
-
-        context "when code bigger or equal zero" do
-          before { expect(Ethon::Curl).to receive(:select).and_return(0) }
-
-          it "doesn't raise" do
-            expect{ multi.method(:set_fds).call(timeout) }.to_not raise_error
-          end
-        end
-      end
-    end
-
-    context "when code not ok" do
-      before { expect(Ethon::Curl).to receive(:multi_fdset).and_return(:not_ok) }
-
-      it "raises MultiFdset error" do
-        expect{ multi.method(:set_fds).call(timeout) }.to raise_error(Ethon::Errors::MultiFdset)
-      end
-    end
-  end
-
-  describe "#perform" do
-    context "when no easy handles" do
-      it "returns nil" do
-        expect(multi.perform).to be_nil
-      end
-
-      it "logs" do
-        expect(Ethon.logger).to receive(:debug).twice
-        multi.perform
-      end
-    end
-
-    context "when easy handle" do
-      before do
-        easy.url = "http://localhost:3001/"
-        multi.add(easy)
-      end
-
-      it "requests" do
-        multi.perform
-      end
-
-      it "sets easy" do
-        multi.perform
-        expect(easy.response_code).to eq(200)
-      end
-    end
-
-    context "when four easy handles" do
-      let(:easies) do
-        ary = []
-        4.times do
-          ary << another_easy = Ethon::Easy.new
-          another_easy.url = "http://localhost:3001/"
-        end
-        ary
-      end
-
-      before do
-        easies.each { |e| multi.add(e) }
-        multi.perform
-      end
-
-      it "sets response codes" do
-        expect(easies.all?{ |e| e.response_code == 200 }).to be_truthy
-      end
-    end
-  end
-
-  describe "#ongoing?" do
-    context "when easy_handles" do
-      before { multi.easy_handles << 1 }
-
-      context "when running_count not greater 0" do
-        before { multi.instance_variable_set(:@running_count, 0) }
-
-        it "returns true" do
-          expect(multi.method(:ongoing?).call).to be_truthy
-        end
-      end
-
-      context "when running_count greater 0" do
-        before { multi.instance_variable_set(:@running_count, 1) }
-
-        it "returns true" do
-          expect(multi.method(:ongoing?).call).to be_truthy
-        end
-      end
-    end
-
-    context "when no easy_handles" do
-      context "when running_count not greater 0" do
-        before { multi.instance_variable_set(:@running_count, 0) }
-
-        it "returns false" do
-          expect(multi.method(:ongoing?).call).to be_falsey
-        end
-      end
-
-      context "when running_count greater 0" do
-        before { multi.instance_variable_set(:@running_count, 1) }
-
-        it "returns true" do
-          expect(multi.method(:ongoing?).call).to be_truthy
-        end
-      end
-    end
-  end
-
-  describe "#init_vars" do
-    it "sets @timeout" do
-      expect(multi.instance_variable_get(:@timeout)).to be_a(FFI::MemoryPointer)
-    end
-
-    it "sets @timeval" do
-      expect(multi.instance_variable_get(:@timeval)).to be_a(Ethon::Curl::Timeval)
-    end
-
-    it "sets @fd_read" do
-      expect(multi.instance_variable_get(:@fd_read)).to be_a(Ethon::Curl::FDSet)
-    end
-
-    it "sets @fd_write" do
-      expect(multi.instance_variable_get(:@fd_write)).to be_a(Ethon::Curl::FDSet)
-    end
-
-    it "sets @fd_excep" do
-      expect(multi.instance_variable_get(:@fd_excep)).to be_a(Ethon::Curl::FDSet)
-    end
-
-    it "sets @max_fd" do
-      expect(multi.instance_variable_get(:@max_fd)).to be_a(FFI::MemoryPointer)
-    end
-  end
-
-  describe "#reset_fds" do
-    after { multi.method(:reset_fds).call }
-
-    it "resets @fd_read" do
-      expect(multi.instance_variable_get(:@fd_read)).to receive(:clear)
-    end
-
-    it "resets @fd_write" do
-      expect(multi.instance_variable_get(:@fd_write)).to receive(:clear)
-    end
-
-    it "resets @fd_excep" do
-      expect(multi.instance_variable_get(:@fd_excep)).to receive(:clear)
-    end
-  end
-
-  describe "#check" do
-    it { skip("untested") }
-  end
-
-  describe "#run" do
-    it { skip("untested") }
-  end
-
-  describe "#trigger" do
-    it "calls multi perform" do
-      expect(Ethon::Curl).to receive(:multi_perform)
-      multi.send(:trigger, pointer)
-    end
-
-    it "sets running count" do
-      multi.instance_variable_set(:@running_count, nil)
-      multi.send(:trigger, pointer)
-      expect(multi.instance_variable_get(:@running_count)).to_not be_nil
-    end
-
-    it "returns multi perform code" do
-      expect(Ethon::Curl).to receive(:multi_perform).and_return(:ok)
-      expect(multi.send(:trigger, pointer)).to eq(:ok)
-    end
-  end
-end