wallee-ruby-sdk 3.0.5 → 3.1.2

data/vendor/bundle/ruby/2.4.0/gems/ethon-0.15.0/spec/ethon/easy/operations_spec.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Ethon::Easy::Operations do
+  let(:easy) { Ethon::Easy.new }
+
+  describe "#handle" do
+    it "returns a pointer" do
+      expect(easy.handle).to be_a(FFI::Pointer)
+    end
+  end
+
+
+  describe "#perform" do
+    let(:url) { nil }
+    let(:timeout) { nil }
+    let(:connect_timeout) { nil }
+    let(:follow_location) { nil }
+    let(:max_redirs) { nil }
+    let(:user_pwd) { nil }
+    let(:http_auth) { nil }
+    let(:headers) { nil }
+    let(:protocols) { nil }
+    let(:redir_protocols) { nil }
+    let(:username) { nil }
+    let(:password) { nil }
+
+    before do
+      Ethon.logger.level = Logger::DEBUG
+      easy.url = url
+      easy.timeout = timeout
+      easy.connecttimeout = connect_timeout
+      easy.followlocation = follow_location
+      easy.maxredirs = max_redirs
+      easy.httpauth = http_auth
+      easy.headers = headers
+      easy.protocols = protocols
+      easy.redir_protocols = redir_protocols
+
+      if user_pwd
+        easy.userpwd = user_pwd
+      else
+        easy.username = username
+        easy.password = password
+      end
+
+      easy.perform
+    end
+
+    it "calls Curl.easy_perform" do
+      expect(Ethon::Curl).to receive(:easy_perform)
+      easy.perform
+    end
+
+    it "calls Curl.easy_cleanup" do
+      expect_any_instance_of(FFI::AutoPointer).to receive(:free)
+      easy.cleanup
+    end
+
+    it "logs" do
+      expect(Ethon.logger).to receive(:debug)
+      easy.perform
+    end
+
+    it "doesn't log after completing because completing could reset" do
+      easy.on_complete{ expect(Ethon.logger).to receive(:debug).never }
+      easy.perform
+    end
+
+    context "when url" do
+      let(:url) { "http://localhost:3001/" }
+
+      it "returns ok" do
+        expect(easy.return_code).to eq(:ok)
+      end
+
+      it "sets response body" do
+        expect(easy.response_body).to be
+      end
+
+      it "sets response headers" do
+        expect(easy.response_headers).to be
+      end
+
+      context "when request timed out" do
+        let(:url) { "http://localhost:3001/?delay=1" }
+        let(:timeout) { 1 }
+
+        it "returns operation_timedout" do
+          expect(easy.return_code).to eq(:operation_timedout)
+        end
+      end
+
+      context "when connection timed out" do
+        let(:url) { "http://localhost:3009" }
+        let(:connect_timeout) { 1 }
+
+        it "returns couldnt_connect" do
+          expect(easy.return_code).to eq(:couldnt_connect)
+        end
+      end
+
+      context "when no follow location" do
+        let(:url) { "http://localhost:3001/redirect" }
+        let(:follow_location) { false }
+
+        it "doesn't follow" do
+          expect(easy.response_code).to eq(302)
+        end
+      end
+
+      context "when follow location" do
+        let(:url) { "http://localhost:3001/redirect" }
+        let(:follow_location) { true }
+
+        it "follows" do
+          expect(easy.response_code).to eq(200)
+        end
+
+        context "when infinite redirect loop" do
+          let(:url) { "http://localhost:3001/bad_redirect" }
+          let(:max_redirs) { 5 }
+
+          context "when max redirect set" do
+            it "follows only x times" do
+              expect(easy.response_code).to eq(302)
+            end
+          end
+        end
+      end
+
+      context "when user agent" do
+        let(:headers) { { 'User-Agent' => 'Ethon' } }
+
+        it "sets" do
+          expect(easy.response_body).to include('"HTTP_USER_AGENT":"Ethon"')
+        end
+      end
+    end
+
+    context "when auth url" do
+      before { easy.url = url }
+
+      context "when basic auth" do
+        let(:url) { "http://localhost:3001/auth_basic/username/password" }
+
+        context "when no user_pwd" do
+          it "returns 401" do
+            expect(easy.response_code).to eq(401)
+          end
+        end
+
+        context "when invalid user_pwd" do
+          let(:user_pwd) { "invalid:invalid" }
+
+          it "returns 401" do
+            expect(easy.response_code).to eq(401)
+          end
+        end
+
+        context "when valid user_pwd" do
+          let(:user_pwd) { "username:password" }
+
+          it "returns 200" do
+            expect(easy.response_code).to eq(200)
+          end
+        end
+
+        context "when user and password" do
+          let(:username) { "username" }
+          let(:password) { "password" }
+
+          it "returns 200" do
+            expect(easy.response_code).to eq(200)
+          end
+        end
+      end
+
+      context "when ntlm" do
+        let(:url) { "http://localhost:3001/auth_ntlm" }
+        let(:http_auth) { :ntlm }
+
+        context "when no user_pwd" do
+          it "returns 401" do
+            expect(easy.response_code).to eq(401)
+          end
+        end
+
+        context "when user_pwd" do
+          let(:user_pwd) { "username:password" }
+
+          it "returns 200" do
+            expect(easy.response_code).to eq(200)
+          end
+        end
+      end
+    end
+
+    context "when protocols" do
+      context "when asking for a allowed url" do
+        let(:url) { "http://localhost:3001" }
+        let(:protocols) { :http }
+
+        it "returns ok" do
+          expect(easy.return_code).to be(:ok)
+        end
+      end
+
+      context "when asking for a not allowed url" do
+        let(:url) { "http://localhost:3001" }
+        let(:protocols) { :https }
+
+        it "returns unsupported_protocol" do
+          expect(easy.return_code).to be(:unsupported_protocol)
+        end
+      end
+    end
+
+    context "when multiple protocols" do
+      context "when asking for a allowed url" do
+        let(:protocols) { [:http, :https] }
+
+        context "when http" do
+          let(:url) { "http://localhost:3001" }
+
+          it "returns ok for http" do
+            expect(easy.return_code).to be(:ok)
+          end
+        end
+
+        context "when https" do
+          let(:url) { "https://localhost:3001" }
+
+          it "returns ssl_connect_error for https" do
+            expect(easy.return_code).to be(:ssl_connect_error)
+          end
+        end
+      end
+
+      context "when asking for a not allowed url" do
+        let(:url) { "ssh://localhost" }
+        let(:protocols) { [:https, :http] }
+
+        it "returns unsupported_protocol" do
+          expect(easy.return_code).to be(:unsupported_protocol)
+        end
+      end
+    end
+
+    context "when redir_protocols" do
+      context "when redirecting to a not allowed url" do
+        let(:url) { "http://localhost:3001/redirect" }
+        let(:follow_location) { true }
+        let(:redir_protocols) { :https }
+
+        it "returns unsupported_protocol" do
+          expect(easy.return_code).to be(:unsupported_protocol)
+        end
+      end
+    end
+
+    context "when no url" do
+      it "returns url_malformat" do
+        expect(easy.perform).to eq(:url_malformat)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.4.0/gems/ethon-0.15.0/spec/ethon/easy/options_spec.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+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, :dns_shuffle_addresses, :path_as_is
+  ].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.4.0/gems/ethon-0.15.0/spec/ethon/easy/queryable_spec.rb

@@ -0,0 +1,235 @@
+# encoding: utf-8
+# frozen_string_literal: true
+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