approveapi 1.0.7 → 1.0.8

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.3.1/spec/typhoeus/cache/dalli_spec.rb

@@ -0,0 +1,41 @@
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("1.9.0")
+  require 'dalli'
+  require 'typhoeus/cache/dalli'
+  require 'spec_helper'
+
+  describe Typhoeus::Cache::Dalli do
+    let(:dalli) { instance_double(Dalli::Client) }
+    let(:cache) { Typhoeus::Cache::Dalli.new(dalli) }
+
+    let(:base_url) { "localhost:3001" }
+    let(:request) { Typhoeus::Request.new(base_url, {:method => :get}) }
+    let(:response) { Typhoeus::Response.new(:response_code => 0, :return_code => 0, :mock => true) }
+
+    describe "#set" do
+      it "sends the request to Dalli" do
+        expect(dalli).to receive(:set).with(request.cache_key, response, nil)
+
+        cache.set(request, response)
+      end
+    end
+
+    describe "#get" do
+      it "returns nil when the key is not in the cache" do
+        expect(dalli).to receive(:get).with(request.cache_key).and_return(nil)
+
+        expect(cache.get(request)).to be_nil
+      end
+
+      it "returns the cached response when the key is in cache" do
+        expect(dalli).to receive(:get).with(request.cache_key).and_return(response)
+
+        result = cache.get(request)
+        expect(result).to_not be_nil
+        expect(result.response_code).to eq(response.response_code)
+        expect(result.return_code).to eq(response.return_code)
+        expect(result.headers).to eq(response.headers)
+        expect(result.body).to eq(response.body)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.3.1/spec/typhoeus/cache/redis_spec.rb

@@ -0,0 +1,41 @@
+require 'redis'
+require 'typhoeus/cache/redis'
+require 'spec_helper'
+
+describe Typhoeus::Cache::Redis do
+  let(:redis) { instance_double(Redis) }
+  let(:cache) { Typhoeus::Cache::Redis.new(redis) }
+
+  let(:base_url) { "localhost:3001" }
+  let(:request) { Typhoeus::Request.new(base_url, {:method => :get}) }
+  let(:response) { Typhoeus::Response.new(:response_code => 0, :return_code => 0, :mock => true) }
+  let(:serialized_response) { Marshal.dump(response) }
+
+  describe "#set" do
+    it "sends the serialized request to Redis" do
+      expect(redis).to receive(:set).with(request.cache_key, serialized_response)
+      expect(redis).to_not receive(:expire).with(request.cache_key, request.cache_ttl)
+
+      cache.set(request, response)
+    end
+  end
+
+  describe "#get" do
+    it "returns nil when the key is not in Redis" do
+      expect(redis).to receive(:get).with(request.cache_key).and_return(nil)
+
+      expect(cache.get(request)).to be_nil
+    end
+
+    it "returns the cached response when the key is in Redis" do
+      expect(redis).to receive(:get).with(request.cache_key).and_return(serialized_response)
+
+      result = cache.get(request)
+      expect(result).to_not be_nil
+      expect(result.response_code).to eq(response.response_code)
+      expect(result.return_code).to eq(response.return_code)
+      expect(result.headers).to eq(response.headers)
+      expect(result.body).to eq(response.body)
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.3.1/spec/typhoeus/config_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Typhoeus::Config do
+  let(:config) { Typhoeus::Config }
+
+  [:block_connection, :memoize, :verbose, :cache, :user_agent, :proxy].each do |name|
+    it "responds to #{name}" do
+      expect(config).to respond_to(name)
+    end
+
+    it "responds to #{name}=" do
+      expect(config).to respond_to("#{name}=")
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.3.1/spec/typhoeus/easy_factory_spec.rb

@@ -0,0 +1,143 @@
+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/2.6.0/gems/typhoeus-1.3.1/spec/typhoeus/errors/no_stub_spec.rb

@@ -0,0 +1,13 @@
+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/2.6.0/gems/typhoeus-1.3.1/spec/typhoeus/expectation_spec.rb

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