approveapi 1.0.5 → 1.0.6

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.12.0/spec/ethon/easy/options_spec.rb

@@ -1,192 +0,0 @@
-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
-  ].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

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.12.0/spec/ethon/easy/queryable_spec.rb

@@ -1,234 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Ethon::Easy::Queryable do
-  let(:hash) { {} }
-  let!(:easy) { Ethon::Easy.new }
-  let(:params) { Ethon::Easy::Params.new(easy, hash) }
-
-  describe "#to_s" do
-    context "when query_pairs empty" do
-      before { params.instance_variable_set(:@query_pairs, []) }
-
-      it "returns empty string" do
-        expect(params.to_s).to eq("")
-      end
-    end
-
-    context "when query_pairs not empty" do
-      context "when escape" do
-        before do
-          params.escape = true
-        end
-
-        {
-          '!' => '%21', '*' => '%2A', "'" => '%27', '(' => '%28',
-          ')'  => '%29', ';' => '%3B', ':' => '%3A', '@' => '%40',
-          '&' => '%26', '=' => '%3D', '+' => '%2B', '$' => '%24',
-          ',' => '%2C', '/' => '%2F', '?' => '%3F', '#' => '%23',
-          '[' => '%5B', ']' => '%5D',
-
-          '<' => '%3C', '>' => '%3E', '"' => '%22', '{' => '%7B',
-          '}' => '%7D', '|' => '%7C', '\\' => '%5C', '`' => '%60',
-          '^' => '%5E', '%' => '%25', ' ' => '%20', "\0" => '%00',
-
-          'まつもと' => '%E3%81%BE%E3%81%A4%E3%82%82%E3%81%A8',
-        }.each do |value, percent|
-          it "turns #{value.inspect} into #{percent}" do
-            params.instance_variable_set(:@query_pairs, [[:a, value]])
-            expect(params.to_s).to eq("a=#{percent}")
-          end
-        end
-
-        {
-          '.' => '%2E', '-' => '%2D', '_' => '%5F', '~' => '%7E',
-        }.each do |value, percent|
-          it "leaves #{value.inspect} instead of turning into #{percent}" do
-            params.instance_variable_set(:@query_pairs, [[:a, value]])
-            expect(params.to_s).to eq("a=#{value}")
-          end
-        end
-      end
-
-      context "when no escape" do
-        before { params.instance_variable_set(:@query_pairs, [[:a, 1], [:b, 2]]) }
-
-        it "returns concatenated query string" do
-          expect(params.to_s).to eq("a=1&b=2")
-        end
-      end
-    end
-
-    context "when query_pairs contains a string" do
-      before { params.instance_variable_set(:@query_pairs, ["{a: 1}"]) }
-
-      it "returns correct string" do
-        expect(params.to_s).to eq("{a: 1}")
-      end
-    end
-  end
-
-  describe "#build_query_pairs" do
-    let(:pairs) { params.method(:build_query_pairs).call(hash) }
-
-    context "when params is empty" do
-      it "returns empty array" do
-        expect(pairs).to eq([])
-      end
-    end
-
-    context "when params is string" do
-      let(:hash) { "{a: 1}" }
-
-      it "wraps it in an array" do
-        expect(pairs).to eq([hash])
-      end
-    end
-
-    context "when params is simple hash" do
-      let(:hash) { {:a => 1, :b => 2} }
-
-      it "transforms" do
-        expect(pairs).to include([:a, 1])
-        expect(pairs).to include([:b, 2])
-      end
-    end
-
-    context "when params is a nested hash" do
-      let(:hash) { {:a => 1, :b => {:c => 2}} }
-
-      it "transforms" do
-        expect(pairs).to include([:a, 1])
-        expect(pairs).to include(["b[c]", 2])
-      end
-    end
-
-    context "when params contains an array" do
-      let(:hash) { {:a => 1, :b => [2, 3]} }
-
-      context "by default" do
-        it "transforms" do
-          expect(pairs).to include([:a, 1])
-          expect(pairs).to include(["b[0]", 2])
-          expect(pairs).to include(["b[1]", 3])
-        end
-      end
-
-      context "when params_encoding is :rack" do
-        before { params.params_encoding = :rack }
-        it "transforms without indexes" do
-          expect(pairs).to include([:a, 1])
-          expect(pairs).to include(["b[]", 2])
-          expect(pairs).to include(["b[]", 3])
-        end
-      end
-
-      context "when params_encoding is :none" do
-        before { params.params_encoding = :none }
-        it "does no transformation" do
-          expect(pairs).to include([:a, 1])
-          expect(pairs).to include([:b, [2, 3]])
-        end
-      end
-    end
-
-    context "when params contains something nested in an array" do
-      context "when string" do
-        let(:hash) { {:a => {:b => ["hello", "world"]}} }
-
-        it "transforms" do
-          expect(pairs).to eq([["a[b][0]", "hello"], ["a[b][1]", "world"]])
-        end
-      end
-
-      context "when hash" do
-        let(:hash) { {:a => {:b => [{:c =>1}, {:d => 2}]}} }
-
-        it "transforms" do
-          expect(pairs).to eq([["a[b][0][c]", 1], ["a[b][1][d]", 2]])
-        end
-      end
-
-      context "when file" do
-        let(:file) { File.open("spec/spec_helper.rb") }
-        let(:file_info) { params.method(:file_info).call(file) }
-        let(:hash) { {:a => {:b => [file]}} }
-        let(:mime_type) { file_info[1] }
-
-        it "transforms" do
-          expect(pairs).to eq([["a[b][0]", file_info]])
-        end
-
-        context "when MIME" do
-          if defined?(MIME)
-            context "when mime type" do
-              it "sets mime type to text" do
-                expect(mime_type).to eq("application/x-ruby")
-              end
-            end
-          end
-
-          context "when no mime type" do
-            let(:file) { Tempfile.new("fubar") }
-
-            it "sets mime type to default application/octet-stream" do
-              expect(mime_type).to eq("application/octet-stream")
-            end
-          end
-        end
-
-        context "when no MIME" do
-          before { hide_const("MIME") }
-
-          it "sets mime type to default application/octet-stream" do
-            expect(mime_type).to eq("application/octet-stream")
-          end
-        end
-      end
-    end
-
-
-    context "when params contains file" do
-      let(:file) { Tempfile.new("fubar") }
-      let(:file_info) { params.method(:file_info).call(file) }
-      let(:hash) { {:a => 1, :b => file} }
-
-      it "transforms" do
-        expect(pairs).to include([:a, 1])
-        expect(pairs).to include([:b, file_info])
-      end
-    end
-
-    context "when params key contains a null byte" do
-      let(:hash) { {:a => "1\0" } }
-
-      it "preserves" do
-        expect(pairs).to eq([[:a, "1\0"]])
-      end
-    end
-
-    context "when params value contains a null byte" do
-      let(:hash) { {"a\0" => 1 } }
-
-      it "preserves" do
-        expect(pairs).to eq([["a\0", 1]])
-      end
-    end
-  end
-
-  describe "#empty?" do
-    context "when params empty" do
-      it "returns true" do
-        expect(params.empty?).to be_truthy
-      end
-    end
-
-    context "when params not empty" do
-      let(:hash) { {:a => 1} }
-
-      it "returns false" do
-        expect(params.empty?).to be_falsey
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/ethon-0.12.0/spec/ethon/easy/response_callbacks_spec.rb

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