talon_one 6.0.0 → 7.0.0

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/request/cacheable_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+describe Typhoeus::Request::Cacheable do
+  let(:cache) { MemoryCache.new }
+  let(:options) { {} }
+  let(:request) { Typhoeus::Request.new("http://localhost:3001", options) }
+  let(:response) { Typhoeus::Response.new }
+
+  before { Typhoeus::Config.cache = cache }
+  after { Typhoeus::Config.cache = false }
+
+  describe "#response=" do
+    context "when cache activated" do
+      context "when request new" do
+        it "caches response" do
+          request.response = response
+          expect(cache.memory[request]).to be
+        end
+
+        it "doesn't set cached on response" do
+          request.response = response
+          expect(request.response.cached?).to be_falsey
+        end
+      end
+
+      context "when request in memory" do
+        before { cache.memory[request] = response }
+
+        it "finishes request" do
+          expect(request).to receive(:finish).with(response)
+          request.run
+        end
+
+        it "sets cached to true for response" do
+          request.run
+          expect(request.response.cached?).to be_truthy
+        end
+      end
+    end
+  end
+
+  describe "#run" do
+    context "when cache activated" do
+      context "when request new" do
+        it "fetches response" do
+          expect(request.response).to_not be(response)
+        end
+      end
+
+      context "when request in memory" do
+        before { cache.memory[request] = response }
+
+        it "finishes request" do
+          expect(request).to receive(:finish).with(response)
+          request.run
+        end
+      end
+
+      context "when cache is specified on a request" do
+        before { Typhoeus::Config.cache = false }
+
+        context "when cache is false" do
+          let(:options) { { :cache => false } }
+
+          it "finishes request" do
+            expect(request.response).to_not be(response)
+            request.run
+          end
+        end
+
+        context "when cache is defined" do
+          let(:options) { { :cache => cache } }
+
+          before { cache.memory[request] = response }
+
+          it "finishes request" do
+            expect(request).to receive(:finish).with(response)
+            request.run
+          end
+        end
+      end
+    end
+  end
+
+  describe "#cache_ttl" do
+    context "when option[:cache_ttl]" do
+      let(:options) { {:cache_ttl => 1} }
+
+      it "returns" do
+        expect(request.cache_ttl).to be(1)
+      end
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/request/callbacks_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Typhoeus::Request::Callbacks do
+  let(:request) { Typhoeus::Request.new("fubar") }
+
+  [:on_complete, :on_success, :on_failure, :on_progress].each do |callback|
+    describe "##{callback}" do
+      it "responds" do
+        expect(request).to respond_to(callback)
+      end
+
+      context "when no block given" do
+        it "returns @#{callback}" do
+          expect(request.method(callback).call).to eq([])
+        end
+      end
+
+      context "when block given" do
+        it "stores" do
+          request.method(callback).call { p 1 }
+          expect(request.instance_variable_get("@#{callback}").size).to eq(1)
+        end
+      end
+
+      context "when multiple blocks given" do
+        it "stores" do
+          request.method(callback).call { p 1 }
+          request.method(callback).call { p 2 }
+          expect(request.instance_variable_get("@#{callback}").size).to eq(2)
+        end
+      end
+    end
+  end
+
+  describe "#execute_callbacks" do
+    [:on_complete, :on_success, :on_failure, :on_progress].each do |callback|
+      context "when #{callback}" do
+        context "when local callback" do
+          before do
+            code = if callback == :on_failure
+              500
+            else
+              200
+            end
+            request.response = Typhoeus::Response.new(:mock => true, :response_code => code)
+            request.method(callback).call {|r| expect(r).to be_a(Typhoeus::Response) }
+          end
+
+          it "executes blocks and passes response" do
+            request.execute_callbacks
+          end
+
+          it "sets handled_response" do
+            request.method(callback).call { 1 }
+            request.execute_callbacks
+            expect(request.response.handled_response).to be(1)
+          end
+        end
+
+        context "when global callback" do
+          before do
+            request.response = Typhoeus::Response.new
+            Typhoeus.method(callback).call {|r| expect(r).to be_a(Typhoeus::Response) }
+          end
+
+          it "executes blocks and passes response" do
+            request.execute_callbacks
+          end
+        end
+
+        context "when global and local callbacks" do
+          before do
+            request.response = Typhoeus::Response.new
+            Typhoeus.method(callback).call {|r| r.instance_variable_set(:@fu, 1) }
+            request.method(callback).call {|r| expect(r.instance_variable_get(:@fu)).to eq(1) }
+          end
+
+          it "runs global first" do
+            request.execute_callbacks
+          end
+        end
+      end
+    end
+
+    context "when local on_complete and gobal on_success" do
+      it "runs all global callbacks first" do
+        skip
+      end
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/request/marshal_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Typhoeus::Request::Marshal do
+  let(:base_url) { "localhost:3001" }
+  let(:request) { Typhoeus::Request.new(base_url) }
+
+  describe "#marshal_dump" do
+    %w(on_complete on_success on_failure on_progress).each do |name|
+      context "when #{name} handler" do
+        before { request.instance_variable_set("@#{name}", Proc.new{}) }
+
+        it "doesn't include @#{name}" do
+          expect(request.send(:marshal_dump).map(&:first)).to_not include("@#{name}")
+        end
+
+        it "doesn't raise when dumped" do
+          expect { Marshal.dump(request) }.to_not raise_error
+        end
+
+        context "when loading" do
+          let(:loaded) { Marshal.load(Marshal.dump(request)) }
+
+          it "includes base_url" do
+            expect(loaded.base_url).to eq(request.base_url)
+          end
+
+          it "doesn't include #{name}" do
+            expect(loaded.instance_variables).to_not include("@#{name}")
+          end
+        end
+      end
+    end
+
+    context 'when run through hydra' do
+      let(:options) { {} }
+      let(:hydra) { Typhoeus::Hydra.new(options) }
+
+      before(:each) do
+        hydra.queue(request)
+        hydra.run
+      end
+
+      it "doesn't include @hydra" do
+        expect(request.send(:marshal_dump).map(&:first)).to_not include("@hydra")
+      end
+
+      context 'when loading' do
+        let(:loaded) { Marshal.load(Marshal.dump(request)) }
+
+        it "includes base_url" do
+          expect(loaded.base_url).to eq(request.base_url)
+        end
+
+        it "doesn't include #{name}" do
+          expect(loaded.instance_variables).to_not include("@hydra")
+        end
+      end
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/request/memoizable_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Typhoeus::Request::Memoizable do
+  let(:options) { {} }
+  let(:request) { Typhoeus::Request.new("fu", options) }
+  let(:response) { Typhoeus::Response.new }
+  let(:hydra) { Typhoeus::Hydra.new }
+
+  describe "#response=" do
+    context "when memoization activated" do
+      before { Typhoeus::Config.memoize = true }
+      after { Typhoeus::Config.memoize = false }
+
+      context "when GET request" do
+        let(:options) { {:method => :get} }
+        before { request.hydra = hydra }
+
+        it "stores response in memory" do
+          request.response = response
+          expect(hydra.memory[request]).to be
+        end
+      end
+
+      context "when no GET request" do
+        let(:options) { {:method => :post} }
+
+        it "doesn't store response in memory" do
+          request.response = response
+          expect(hydra.memory[request]).to be_nil
+        end
+      end
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/request/operations_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Typhoeus::Request::Operations do
+  let(:base_url) { "localhost:3001" }
+  let(:options) { {} }
+  let(:request) { Typhoeus::Request.new(base_url, options) }
+
+  describe "#run" do
+    let(:easy) { Ethon::Easy.new }
+    before { expect(Typhoeus::Pool).to receive(:get).and_return(easy) }
+
+    it "grabs an easy" do
+      request.run
+    end
+
+    it "generates settings" do
+      expect(easy).to receive(:http_request)
+      request.run
+    end
+
+    it "performs" do
+      expect(easy).to receive(:perform)
+      request.run
+    end
+
+    it "sets response" do
+      request.run
+      expect(request.response).to be
+    end
+
+    it "releases easy" do
+      expect(Typhoeus::Pool).to receive(:release)
+      request.run
+    end
+
+    it "calls on_body" do
+      on_body_called = false
+      request.on_body { |body, response| on_body_called = true }
+      request.run
+      expect(on_body_called).to be_truthy
+      expect(request.response.body).to satisfy { |v| v.nil? || v == '' }
+    end
+
+    it "makes response headers available to on_body" do
+      headers = nil
+      request.on_body { |body, response| headers = response.headers }
+      request.run
+      expect(headers).to be
+      expect(headers).to eq(request.response.headers)
+    end
+
+    it "calls on_headers and on_body" do
+      headers = nil
+      request.on_headers { |response| headers = response.headers }
+      request.on_body { |body, response| expect(headers).not_to be_nil ; expect(response.headers).to eq(headers) }
+      request.on_complete { |response| expect(response).not_to be_nil ; expect(response.headers).to eq(headers) ; expect(response.body).to be_empty }
+      request.run
+    end
+
+    it "calls on_headers and on_complete" do
+      headers = nil
+      request.on_headers { |response| headers = response.headers }
+      request.on_complete { |response| expect(response).not_to be_nil ; expect(response.headers).to eq(headers) ; expect(response.body).not_to be_empty }
+      request.run
+    end
+
+    it "calls on_complete" do
+      callback = double(:call)
+      expect(callback).to receive(:call)
+      request.instance_variable_set(:@on_complete, [callback])
+      request.run
+    end
+
+    it "returns a response" do
+      expect(request.run).to be_a(Typhoeus::Response)
+    end
+  end
+
+  describe "#finish" do
+    let(:response) { Typhoeus::Response.new }
+
+    it "assigns response" do
+      request.finish(response)
+      expect(request.response).to be(response)
+    end
+
+    it "assigns request to response" do
+      request.finish(response)
+      expect(request.response.request).to be(request)
+    end
+
+    it "executes callbacks" do
+      expect(request).to receive(:execute_callbacks)
+      request.finish(response)
+    end
+
+    it "returns response" do
+      expect(request.finish(response)).to be(response)
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/request/responseable_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Typhoeus::Request::Responseable do
+  let(:request) { Typhoeus::Request.new("base_url", {}) }
+  let(:response) { Typhoeus::Response.new }
+
+  describe "#response=" do
+    it "stores response" do
+      request.response = response
+      expect(request.response).to eq(response)
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/request/stubbable_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Typhoeus::Request::Stubbable do
+  let(:base_url) { "localhost:3001" }
+  let(:request) { Typhoeus::Request.new(base_url) }
+  let(:response) { Typhoeus::Response.new }
+
+  before { Typhoeus.stub(base_url).and_return(response) }
+
+  describe "#run" do
+    it "checks expectations" do
+      request.run
+    end
+
+    context "when expectation found" do
+      it "calls on_headers callbacks" do
+        canary = :not_called
+        request.on_headers do
+          canary = :called
+        end
+        request.run
+        expect(canary).to eq(:called)
+      end
+
+      it "calls on_body callbacks" do
+        canary = :not_called
+        request.on_body do
+          canary = :called
+        end
+        request.run
+        expect(canary).to eq(:called)
+      end
+
+      it "finishes request" do
+        expect(request).to receive(:finish)
+        request.run
+      end
+
+      it "sets mock on response" do
+        request.run
+        expect(request.response.mock).to be(true)
+      end
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/typhoeus-1.4.1/spec/typhoeus/request_spec.rb

@@ -0,0 +1,256 @@
+require 'spec_helper'
+
+describe Typhoeus::Request do
+  let(:base_url) { "localhost:3001" }
+  let(:options) do
+    {
+      verbose: true,
+      headers: { "User-Agent" => "Fubar", "Expect" => "" },
+      maxredirs: 50
+    }
+  end
+  let(:request) { Typhoeus::Request.new(base_url, options) }
+
+  describe ".url" do
+    context "when no parameters" do
+      it "returns base_url" do
+        expect(request.url).to eq(request.base_url)
+      end
+    end
+
+    context "when parameters" do
+      let(:options) { {:params => {:a => 1}} }
+
+      it "returns full url" do
+        expect(request.url).to eq("#{request.base_url}?a=1")
+      end
+    end
+
+    it "pushes an easy back into the pool" do
+      easy = double.as_null_object
+      allow(Typhoeus::Pool).to receive(:get).and_return(easy)
+      expect(Typhoeus::Pool).to receive(:release).with(easy)
+      request.url
+    end
+  end
+
+  describe ".new" do
+    it "stores base_url" do
+      expect(request.base_url).to eq(base_url)
+    end
+
+    it "stores options" do
+      expect(request.options).to eq(options)
+    end
+
+    it "stores original options" do
+      expect(request.original_options).to eq(options)
+      expect(request.original_options).to_not be(request.options)
+    end
+
+    it "sets defaults" do
+      expect(request.options[:headers]['User-Agent']).to be
+    end
+  end
+
+  describe "set_defaults" do
+    context "when header with user agent" do
+      let(:options) { {:headers => {'User-Agent' => "Custom"} } }
+
+      it "doesn't modify user agent" do
+        expect(request.options[:headers]['User-Agent']).to eq("Custom")
+      end
+    end
+
+    context "when header without user agent" do
+      let(:options) { {:headers => {} } }
+
+      it "add user agent" do
+        agent = request.options[:headers]['User-Agent']
+        expect(agent).to eq(Typhoeus::USER_AGENT)
+      end
+    end
+
+    context "when Config.user_agent set" do
+      before { Typhoeus.configure { |config| config.user_agent = "Default" } }
+      after { Typhoeus.configure { |config| config.user_agent = nil } }
+
+      context "with headers" do
+        let(:options) { {:headers => { "User-Agent" => "Fubar" } } }
+
+        it "uses the request options' user agent" do
+          expect(request.options[:headers]["User-Agent"]).to eq("Fubar")
+        end
+      end
+
+      context "without headers" do
+        let(:options) { {:headers => {} } }
+
+        it "uses the global options' user agent" do
+          expect(request.options[:headers]["User-Agent"]).to eq("Default")
+        end
+      end
+    end
+
+    context "when Config.verbose set" do
+      before { Typhoeus.configure { |config| config.verbose = true} }
+      after { Typhoeus.configure { |config| config.verbose = false} }
+
+      it "respects" do
+        expect(request.options[:verbose]).to be_truthy
+      end
+    end
+
+    context "when Config.timeout set" do
+      before { Typhoeus.configure { |config| config.timeout = 10 } }
+      after { Typhoeus.configure { |config| config.timeout = nil } }
+
+      it "respects configuration" do
+        expect(request.options[:timeout]).to eq(10)
+      end
+    end
+
+    context "when Config.connecttimeout set" do
+      before { Typhoeus.configure { |config| config.connecttimeout = 10 } }
+      after { Typhoeus.configure { |config| config.connecttimeout = nil } }
+
+      it "respects configuration" do
+        expect(request.options[:connecttimeout]).to eq(10)
+      end
+    end
+
+    context "when maxredirs" do
+      context "when not set" do
+        it "defaults to 50" do
+          expect(request.options[:maxredirs]).to be(50)
+        end
+      end
+
+      context "when set" do
+        let(:options) { {:maxredirs => 1} }
+
+        it "respects" do
+          expect(request.options[:maxredirs]).to be(1)
+        end
+      end
+    end
+
+    context "when Config.proxy set" do
+      before { Typhoeus.configure { |config| config.proxy = "http://proxy.internal" } }
+      after { Typhoeus.configure { |config| config.proxy = nil } }
+
+      it "respects" do
+        expect(request.options[:proxy]).to eq("http://proxy.internal")
+      end
+
+      context "when option proxy set" do
+        let(:options) { {:proxy => nil} }
+
+        it "does not override" do
+          expect(request.options[:proxy]).to be_nil
+        end
+      end
+    end
+  end
+
+  describe "#eql?" do
+    context "when another class" do
+      let(:other) { "" }
+
+      it "returns false" do
+        expect(request).to_not eql other
+      end
+    end
+
+    context "when same class" do
+      let(:other) { Typhoeus::Request.new("base_url", options) }
+
+      context "when other base_url" do
+        it "returns false" do
+          expect(request).to_not eql other
+        end
+      end
+
+      context "when same base_url and other options" do
+        let(:other) { Typhoeus::Request.new(base_url, {}) }
+
+        it "returns false" do
+          expect(request).to_not eql other
+        end
+      end
+
+
+      context "when same base_url and options" do
+        context "when same order" do
+          let(:other) { Typhoeus::Request.new(base_url, options) }
+
+          it "returns true" do
+            expect(request).to eql other
+          end
+        end
+
+        context "when different order" do
+          let(:other_options) {
+            {:headers => { 'User-Agent' => "Fubar", 'Expect' => ""}, :verbose => true }
+          }
+          let(:other) { Typhoeus::Request.new(base_url, other_options)}
+
+          it "returns true" do
+            expect(request).to eql other
+          end
+        end
+      end
+    end
+  end
+
+  describe "#hash" do
+    context "when request.eql?(other)" do
+      context "when different order" do
+        let(:other_options) {
+          {:headers => { 'User-Agent' => "Fubar", 'Expect' => "" }, :verbose => true }
+        }
+        let(:other) { Typhoeus::Request.new(base_url, other_options)}
+
+        it "has same hashes" do
+          expect(request.hash).to eq(other.hash)
+        end
+      end
+
+      context "when same order" do
+        let(:other) { Typhoeus::Request.new(base_url, options) }
+
+        it "has same hashes" do
+          expect(request.hash).to eq(other.hash)
+        end
+      end
+
+      context "when hashes with different orders are contained in arrays" do
+        let(:request) { Typhoeus::Request.new(base_url, :params => [{:b => 2, :a => 1}]) }
+        let(:other) { Typhoeus::Request.new(base_url, :params => [{:a => 1, :b => 2}]) }
+        it "has different hashes" do
+          expect(request.hash).to eq(other.hash)
+        end
+      end
+    end
+
+    context "when not request.eql?(other)" do
+      let(:request) { Typhoeus::Request.new(base_url, :params => {:foo => 'bar'}) }
+      let(:other) { Typhoeus::Request.new(base_url, :params => {:foo => 'baz'}) }
+
+      it "has different hashes" do
+        expect(request.hash).to_not eq(other.hash)
+      end
+    end
+  end
+
+  describe "#encoded_body" do
+    let(:request) {
+      Typhoeus::Request.new("www.example.com",:body => {:a => 1})
+    }
+
+    it "returns encoded body" do
+      expect(request.encoded_body).to eq("a=1")
+    end
+  end
+
+end