cybrid_api_organization_ruby 0.124.85 → 0.124.86

data/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/easy_factory_spec.rb

@@ -1,143 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::EasyFactory do
-  let(:base_url) { "http://localhost:3001" }
-  let(:hydra) { Typhoeus::Hydra.new(:max_concurrency => 1) }
-  let(:options) { {} }
-  let(:request) { Typhoeus::Request.new(base_url, options) }
-  let(:easy_factory) { described_class.new(request, hydra) }
-
-  describe "#get" do
-    context "when option[:cache_ttl]" do
-      let(:options) { {:cache_ttl => 1} }
-
-      it "creates Ethon::Easy" do
-        expect(easy_factory.get).to be_a(Ethon::Easy)
-      end
-    end
-    
-    context "timeouts" do
-      it "sets nosignal to true by default" do
-        expect(easy_factory.easy).to receive(:http_request).with(anything(), anything(), hash_including(:nosignal => true))
-        easy_factory.get
-      end
-
-      context "when timeout is not a whole number and timeout_ms is not set" do
-        let(:options) { {:timeout => 0.1} }
-        it "ceils timeout and sets timeout_ms" do
-          expect(easy_factory.easy).to receive(:http_request).with(anything(), anything(), hash_including(:timeout_ms => 100, :timeout => 1))
-          easy_factory.get
-        end
-      end
-
-      context "when timeout is not a whole number and timeout_ms is set" do
-        let(:options) { {:timeout => 0.1, :timeout_ms => 123} }
-        it "ceils timeout and does not change timeout_ms" do
-          expect(easy_factory.easy).to receive(:http_request).with(anything(), anything(), hash_including(:timeout_ms => 123, :timeout => 1))
-          easy_factory.get
-        end
-      end
-
-      context "when connecttimeout is not a whole number and connecttimeout_ms is not set" do
-        let(:options) { {:connecttimeout => 0.1} }
-        it "ceils connecttimeout and sets connecttimeout_ms" do
-          expect(easy_factory.easy).to receive(:http_request).with(anything(), anything(), hash_including(:connecttimeout_ms => 100, :connecttimeout => 1))
-          easy_factory.get
-        end
-      end
-
-      context "when connecttimeout is not a whole number and connecttimeout_ms is set" do
-        let(:options) { {:connecttimeout => 0.1, :connecttimeout_ms => 123} }
-        it "ceils connecttimeout and does not change connecttimeout_ms" do
-          expect(easy_factory.easy).to receive(:http_request).with(anything(), anything(), hash_including(:connecttimeout_ms => 123, :connecttimeout => 1))
-          easy_factory.get
-        end
-      end
-
-
-    end
-
-    context "when invalid option" do
-      let(:options) { {:invalid => 1} }
-
-      it "reraises" do
-        expect{ easy_factory.get }.to raise_error(Ethon::Errors::InvalidOption)
-      end
-    end
-
-    context "when removed option" do
-      let(:options) { {:cache_timeout => 1} }
-
-      it "reraises with help" do
-        expect{ easy_factory.get }.to raise_error(
-          Ethon::Errors::InvalidOption, /The option cache_timeout was removed/
-        )
-      end
-    end
-
-    context "when changed option" do
-      let(:options) { {:proxy_auth_method => 1} }
-
-      it "reraises with help" do
-        expect{ easy_factory.get }.to raise_error(
-          Ethon::Errors::InvalidOption, /Please try proxyauth instead of proxy_auth_method/
-        )
-      end
-    end
-
-    context "when renamed option" do
-      let(:options) { {:connect_timeout => 1} }
-
-      it "warns" do
-        expect(easy_factory).to receive(:warn).with(
-          "Deprecated option connect_timeout. Please use connecttimeout instead."
-        )
-        easy_factory.get
-      end
-
-      it "passes correct option" do
-        expect(easy_factory).to receive(:warn)
-        expect(easy_factory.easy).to receive(:connecttimeout=).with(1)
-        easy_factory.get
-      end
-    end
-  end
-
-  describe "#set_callback" do
-    it "sets easy.on_progress callback when an on_progress callback is provided" do
-      request.on_progress { 1 }
-      expect(easy_factory.easy).to receive(:on_progress)
-      easy_factory.send(:set_callback)
-    end
-
-    it "sets easy.on_complete callback" do
-      expect(easy_factory.easy).to receive(:on_complete)
-      easy_factory.send(:set_callback)
-    end
-
-    it "finishes request" do
-      easy_factory.send(:set_callback)
-      expect(request).to receive(:finish)
-      easy_factory.easy.complete
-    end
-
-    it "resets easy" do
-      easy_factory.send(:set_callback)
-      expect(easy_factory.easy).to receive(:reset)
-      easy_factory.easy.complete
-    end
-
-    it "pushes easy back into the pool" do
-      easy_factory.send(:set_callback)
-      easy_factory.easy.complete
-      expect(Typhoeus::Pool.send(:easies)).to include(easy_factory.easy)
-    end
-
-    it "adds next request" do
-      easy_factory.hydra.instance_variable_set(:@queued_requests, [request])
-      expect(easy_factory.hydra).to receive(:add).with(request)
-      easy_factory.send(:set_callback)
-      easy_factory.easy.complete
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/errors/no_stub_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Errors::NoStub do
-  let(:base_url) { "localhost:3001" }
-  let(:request) { Typhoeus::Request.new(base_url) }
-  let(:message) { "The connection is blocked and no stub defined: " }
-
-  subject { Typhoeus::Errors::NoStub }
-
-  it "displays the request url" do
-    expect { raise subject.new(request) }.to raise_error(subject, message + base_url)
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/expectation_spec.rb

@@ -1,280 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Expectation do
-  let(:options) { {} }
-  let(:base_url) { "www.example.com" }
-  let(:expectation) { described_class.new(base_url, options) }
-
-  describe ".new" do
-    it "sets base_url" do
-      expect(expectation.instance_variable_get(:@base_url)).to eq(base_url)
-    end
-
-    it "sets options" do
-      expect(expectation.instance_variable_get(:@options)).to eq(options)
-    end
-
-    it "initializes response_counter" do
-      expect(expectation.instance_variable_get(:@response_counter)).to eq(0)
-    end
-  end
-
-  describe ".all" do
-    context "when @expectations nil" do
-      it "returns empty array" do
-        expect(Typhoeus::Expectation.all).to eq([])
-      end
-    end
-
-    context "when @expectations not nil" do
-      let(:expectations) { [1] }
-
-      it "returns @expectations" do
-        Typhoeus::Expectation.instance_variable_set(:@expectations, expectations)
-        expect(Typhoeus::Expectation.all).to be(expectations)
-      end
-    end
-  end
-
-  describe ".clear" do
-    let(:expectations) { double(:clear) }
-
-    it "clears all" do
-      expect(expectations).to receive(:clear)
-      Typhoeus::Expectation.instance_variable_set(:@expectations, expectations)
-      Typhoeus::Expectation.clear
-      Typhoeus::Expectation.instance_variable_set(:@expectations, nil)
-    end
-  end
-
-  describe ".response_for" do
-    let(:request) { Typhoeus::Request.new("") }
-    let(:stubbed_response) { Typhoeus::Response.new }
-
-    it "finds a matching expectation and returns its next response" do
-      Typhoeus::Expectation.all << expectation
-      expect(expectation).to receive(:matches?).with(request).and_return(true)
-      expect(expectation).to receive(:response).with(request).and_return(stubbed_response)
-
-      response = Typhoeus::Expectation.response_for(request)
-
-      expect(response).to be(stubbed_response)
-    end
-
-    it "returns nil if no matching expectation is found" do
-      response = Typhoeus::Expectation.response_for(request)
-      expect(response).to be(nil)
-    end
-  end
-
-  describe "#stubbed_from" do
-    it "sets value" do
-      expectation.stubbed_from(:webmock)
-      expect(expectation.from).to eq(:webmock)
-    end
-
-    it "returns self" do
-      expect(expectation.stubbed_from(:webmock)).to be(expectation)
-    end
-  end
-
-  describe "#and_return" do
-    context "when value" do
-      it "adds to responses" do
-        expectation.and_return(1)
-        expect(expectation.responses).to eq([1])
-      end
-    end
-
-    context "when array" do
-      it "adds to responses" do
-        expectation.and_return([1, 2])
-        expect(expectation.responses).to eq([1, 2])
-      end
-    end
-
-    context "when block" do
-      it "adds to responses" do
-        block = Proc.new {}
-        expectation.and_return(&block)
-        expect(expectation.responses).to eq([block])
-      end
-    end
-  end
-
-  describe "#responses" do
-    it "returns responses" do
-      expect(expectation.responses).to be_a(Array)
-    end
-  end
-
-  describe "#response" do
-    let(:request) { Typhoeus::Request.new("") }
-
-    before { expectation.instance_variable_set(:@responses, responses) }
-
-    context "when one response" do
-      context "is pre-constructed" do
-        let(:responses) { [Typhoeus::Response.new] }
-
-        it "returns response" do
-          expect(expectation.response(request)).to be(responses[0])
-        end
-      end
-
-      context "is lazily-constructed" do
-        def construct_response(request)
-          @request_from_response_construction = request
-          lazily_constructed_response
-        end
-
-        let(:lazily_constructed_response) { Typhoeus::Response.new }
-        let(:responses) { [ Proc.new { |request| construct_response(request) } ] }
-
-        it "returns response" do
-          expect(expectation.response(request)).to be(lazily_constructed_response)
-          expect(@request_from_response_construction).to be(request)
-        end
-      end
-    end
-
-    context "when multiple responses" do
-      let(:responses) { [Typhoeus::Response.new, Typhoeus::Response.new, Typhoeus::Response.new] }
-
-      it "returns one by one" do
-        3.times do |i|
-          expect(expectation.response(request)).to be(responses[i])
-        end
-      end
-    end
-  end
-
-  describe "#matches?" do
-    let(:request) { double(:base_url => nil) }
-
-    it "calls url_match?" do
-      expect(expectation).to receive(:url_match?)
-      expectation.matches?(request)
-    end
-
-    it "calls options_match?" do
-      expect(expectation).to receive(:url_match?).and_return(true)
-      expect(expectation).to receive(:options_match?)
-      expectation.matches?(request)
-    end
-  end
-
-  describe "#url_match?" do
-    let(:request_url) { "www.example.com" }
-    let(:request) { Typhoeus::Request.new(request_url) }
-    let(:url_match) { expectation.method(:url_match?).call(request.base_url) }
-
-    context "when string" do
-      context "when match" do
-        it "returns true" do
-          expect(url_match).to be_truthy
-        end
-      end
-
-      context "when no match" do
-        let(:base_url) { "no_match" }
-
-        it "returns false" do
-          expect(url_match).to be_falsey
-        end
-      end
-    end
-
-    context "when regexp" do
-      context "when match" do
-        let(:base_url) { /example/ }
-
-        it "returns true" do
-          expect(url_match).to be_truthy
-        end
-      end
-
-      context "when no match" do
-        let(:base_url) { /nomatch/ }
-
-        it "returns false" do
-          expect(url_match).to be_falsey
-        end
-
-        context "with nil request_url" do
-          let(:request_url) { nil }
-
-          it "returns false" do
-            expect(url_match).to be_falsey
-          end
-        end
-      end
-    end
-
-    context "when nil" do
-      let(:base_url) { nil }
-
-      it "returns true" do
-        expect(url_match).to be_truthy
-      end
-    end
-
-    context "when not string, regexp, nil" do
-      let(:base_url) { 1 }
-
-      it "returns false" do
-        expect(url_match).to be_falsey
-      end
-    end
-  end
-
-  describe "options_match?" do
-    let(:request_options) { {} }
-    let(:request) { Typhoeus::Request.new(nil, request_options) }
-    let(:options_match) { expectation.method(:options_match?).call(request) }
-
-    context "when match" do
-      let(:options) { { :a => 1 } }
-      let(:request_options) { options }
-
-      it "returns true" do
-        expect(options_match).to be_truthy
-      end
-    end
-
-    context "when options are a subset from request_options" do
-      let(:options) { { :a => 1 } }
-      let(:request_options) { { :a => 1, :b => 2 } }
-
-      it "returns true" do
-        expect(options_match).to be_truthy
-      end
-    end
-
-    context "when options are nested" do
-      let(:options) { { :a => { :b => 1 } } }
-      let(:request_options) { options }
-
-      it "returns true" do
-        expect(options_match).to be_truthy
-      end
-    end
-
-    context "when options contains an array" do
-      let(:options) { { :a => [1, 2] } }
-      let(:request_options) { options }
-
-      it "returns true" do
-        expect(options_match).to be_truthy
-      end
-    end
-
-    context "when no match" do
-      let(:options) { { :a => 1 } }
-
-      it "returns false" do
-        expect(options_match).to be_falsey
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/hydra/addable_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Hydra::Addable do
-  let(:hydra) { Typhoeus::Hydra.new() }
-  let(:request) { Typhoeus::Request.new("localhost:3001", {:method => :get}) }
-
-  it "asks easy factory for an easy" do
-    multi = double
-    expect(Typhoeus::EasyFactory).to receive(:new).with(request, hydra).and_return(double(:get => 1))
-    expect(hydra).to receive(:multi).and_return(multi)
-    expect(multi).to receive(:add).with(1)
-    hydra.add(request)
-  end
-
-  it "adds easy to multi" do
-    multi = double
-    expect(Typhoeus::EasyFactory).to receive(:new).with(request, hydra).and_return(double(:get => 1))
-    expect(hydra).to receive(:multi).and_return(multi)
-    expect(multi).to receive(:add).with(1)
-    hydra.add(request)
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/hydra/before_spec.rb

@@ -1,98 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Hydra::Before do
-  let(:request) { Typhoeus::Request.new("") }
-  let(:hydra) { Typhoeus::Hydra.new }
-  let(:receive_counter) { double :mark => :twain }
-
-  describe "#add" do
-    context "when before" do
-      context "when one" do
-        it "executes" do
-          Typhoeus.before { |r| receive_counter.mark }
-          expect(receive_counter).to receive(:mark)
-          hydra.add(request)
-        end
-
-        context "when true" do
-          it "calls super" do
-            Typhoeus.before { true }
-            expect(Typhoeus::Expectation).to receive(:response_for)
-            hydra.add(request)
-          end
-        end
-
-        context "when falsy" do
-          context "when queue requests" do
-            let(:queued_request) { Typhoeus::Request.new("") }
-
-            before { hydra.queue(queued_request) }
-
-            it "dequeues" do
-              Typhoeus.before { false }
-              hydra.add(request)
-              expect(hydra.queued_requests).to be_empty
-            end
-          end
-
-          context "when false" do
-            it "doesn't call super" do
-              Typhoeus.before { false }
-              expect(Typhoeus::Expectation).to receive(:response_for).never
-              hydra.add(request)
-            end
-          end
-
-          context "when response" do
-            it "doesn't call super" do
-              Typhoeus.before { Typhoeus::Response.new }
-              expect(Typhoeus::Expectation).to receive(:response_for).never
-              hydra.add(request)
-            end
-          end
-        end
-      end
-
-      context "when multi" do
-        context "when all true" do
-          before { 3.times { Typhoeus.before { |r| receive_counter.mark } } }
-
-          it "calls super" do
-            expect(Typhoeus::Expectation).to receive(:response_for)
-            hydra.add(request)
-          end
-
-          it "executes all" do
-            expect(receive_counter).to receive(:mark).exactly(3).times
-            hydra.add(request)
-          end
-        end
-
-        context "when middle false" do
-          before do
-            Typhoeus.before { |r| receive_counter.mark }
-            Typhoeus.before { |r| receive_counter.mark; nil }
-            Typhoeus.before { |r| receive_counter.mark }
-          end
-
-          it "doesn't call super" do
-            expect(Typhoeus::Expectation).to receive(:response_for).never
-            hydra.add(request)
-          end
-
-          it "executes only two" do
-            expect(receive_counter).to receive(:mark).exactly(2).times
-            hydra.add(request)
-          end
-        end
-      end
-    end
-
-    context "when no before" do
-      it "calls super" do
-        expect(Typhoeus::Expectation).to receive(:response_for)
-        hydra.add(request)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/hydra/block_connection_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Hydra::BlockConnection do
-  let(:base_url) { "localhost:3001" }
-  let(:hydra) { Typhoeus::Hydra.new() }
-  let(:request) { Typhoeus::Request.new(base_url, {:method => :get}) }
-
-  describe "add" do
-    context "when block_connection activated" do
-      before { Typhoeus::Config.block_connection = true }
-      after { Typhoeus::Config.block_connection = false }
-
-      it "raises" do
-        expect{ hydra.add(request) }.to raise_error(Typhoeus::Errors::NoStub)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/hydra/cacheable_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Hydra::Cacheable do
-  let(:base_url) { "localhost:3001" }
-  let(:hydra) { Typhoeus::Hydra.new() }
-  let(:request) { Typhoeus::Request.new(base_url, {:method => :get}) }
-  let(:response) { Typhoeus::Response.new }
-  let(:cache) { MemoryCache.new }
-
-  describe "add" do
-    context "when cache activated" do
-      before { Typhoeus::Config.cache = cache }
-      after { Typhoeus::Config.cache = false }
-
-      context "when request new" do
-        it "sets no response" do
-          hydra.add(request)
-          expect(request.response).to be_nil
-        end
-
-        it "doesn't call complete" do
-          expect(request).to receive(:complete).never
-          hydra.add(request)
-        end
-      end
-
-      context "when request in memory" do
-        before { cache.memory[request] = response }
-
-        it "returns response with cached status" do
-          hydra.add(request)
-          expect(response.cached?).to be_truthy
-        end
-
-        context "when no queued requests" do
-          it "finishes request" do
-            expect(request).to receive(:finish).with(response)
-            hydra.add(request)
-            expect(response.cached?).to be_truthy
-          end
-        end
-
-        context "when queued requests" do
-          let(:queued_request) { Typhoeus::Request.new(base_url, {:method => :get}) }
-
-          before { cache.memory[queued_request] = response }
-
-          it "finishes both requests" do
-            hydra.queue(queued_request)
-            expect(request).to receive(:finish).with(response)
-            expect(queued_request).to receive(:finish).with(response)
-            hydra.add(request)
-          end
-        end
-      end
-
-      context "when cache is specified on a request" do
-        before { Typhoeus::Config.cache = false }
-
-        context "when cache is false" do
-          let(:non_cached_request) { Typhoeus::Request.new(base_url, {:method => :get, :cache => false}) }
-
-          it "initiates an HTTP call" do
-            expect(Typhoeus::EasyFactory).to receive(:new).with(non_cached_request, hydra).and_call_original
-
-            hydra.add(non_cached_request)
-          end
-        end
-
-        context "when cache is defined" do
-          let(:cached_request) { Typhoeus::Request.new(base_url, {:method => :get, :cache => cache}) }
-
-          before { cache.memory[cached_request] = response }
-
-          it "uses the cache instead of making a new request" do
-            expect(Typhoeus::EasyFactory).not_to receive(:new)
-
-            hydra.add(cached_request)
-
-            expect(cached_request.response).to be_cached
-            expect(cached_request.response).to eq(response)
-          end
-        end
-      end
-
-    end
-  end
-end