paynow_sdk 1.0.9 → 1.1.2

data/vendor/cache/ruby/2.7.0/gems/rest-client-2.1.0/spec/integration/integration_spec.rb

@@ -1,118 +0,0 @@
-# -*- coding: utf-8 -*-
-require_relative '_lib'
-require 'base64'
-
-describe RestClient do
-
-  it "a simple request" do
-    body = 'abc'
-    stub_request(:get, "www.example.com").to_return(:body => body, :status => 200)
-    response = RestClient.get "www.example.com"
-    expect(response.code).to eq 200
-    expect(response.body).to eq body
-  end
-
-  it "a 404" do
-    body = "Ho hai ! I'm not here !"
-    stub_request(:get, "www.example.com").to_return(:body => body, :status => 404)
-    begin
-      RestClient.get "www.example.com"
-      raise
-    rescue RestClient::ResourceNotFound => e
-      expect(e.http_code).to eq 404
-      expect(e.response.code).to eq 404
-      expect(e.response.body).to eq body
-      expect(e.http_body).to eq body
-    end
-  end
-
-  describe 'charset parsing' do
-    it 'handles utf-8' do
-      body = "λ".force_encoding('ASCII-8BIT')
-      stub_request(:get, "www.example.com").to_return(
-        :body => body, :status => 200, :headers => {
-          'Content-Type' => 'text/plain; charset=UTF-8'
-      })
-      response = RestClient.get "www.example.com"
-      expect(response.encoding).to eq Encoding::UTF_8
-      expect(response.valid_encoding?).to eq true
-    end
-
-    it 'handles windows-1252' do
-      body = "\xff".force_encoding('ASCII-8BIT')
-      stub_request(:get, "www.example.com").to_return(
-        :body => body, :status => 200, :headers => {
-          'Content-Type' => 'text/plain; charset=windows-1252'
-      })
-      response = RestClient.get "www.example.com"
-      expect(response.encoding).to eq Encoding::WINDOWS_1252
-      expect(response.encode('utf-8')).to eq "ÿ"
-      expect(response.valid_encoding?).to eq true
-    end
-
-    it 'handles binary' do
-      body = "\xfe".force_encoding('ASCII-8BIT')
-      stub_request(:get, "www.example.com").to_return(
-        :body => body, :status => 200, :headers => {
-          'Content-Type' => 'application/octet-stream; charset=binary'
-      })
-      response = RestClient.get "www.example.com"
-      expect(response.encoding).to eq Encoding::BINARY
-      expect {
-        response.encode('utf-8')
-      }.to raise_error(Encoding::UndefinedConversionError)
-      expect(response.valid_encoding?).to eq true
-    end
-
-    it 'handles euc-jp' do
-      body = "\xA4\xA2\xA4\xA4\xA4\xA6\xA4\xA8\xA4\xAA".
-        force_encoding(Encoding::BINARY)
-      body_utf8 = 'あいうえお'
-      expect(body_utf8.encoding).to eq Encoding::UTF_8
-
-      stub_request(:get, 'www.example.com').to_return(
-        :body => body, :status => 200, :headers => {
-          'Content-Type' => 'text/plain; charset=EUC-JP'
-      })
-      response = RestClient.get 'www.example.com'
-      expect(response.encoding).to eq Encoding::EUC_JP
-      expect(response.valid_encoding?).to eq true
-      expect(response.length).to eq 5
-      expect(response.encode('utf-8')).to eq body_utf8
-    end
-
-    it 'defaults to the default encoding' do
-      stub_request(:get, 'www.example.com').to_return(
-        body: 'abc', status: 200, headers: {
-          'Content-Type' => 'text/plain'
-        })
-
-      response = RestClient.get 'www.example.com'
-      # expect(response.encoding).to eq Encoding.default_external
-      expect(response.encoding).to eq Encoding::UTF_8
-    end
-
-    it 'handles invalid encoding' do
-      stub_request(:get, 'www.example.com').to_return(
-        body: 'abc', status: 200, headers: {
-          'Content-Type' => 'text; charset=plain'
-        })
-
-      response = RestClient.get 'www.example.com'
-      # expect(response.encoding).to eq Encoding.default_external
-      expect(response.encoding).to eq Encoding::UTF_8
-    end
-
-    it 'leaves images as binary' do
-      gif = Base64.strict_decode64('R0lGODlhAQABAAAAADs=')
-
-      stub_request(:get, 'www.example.com').to_return(
-        body: gif, status: 200, headers: {
-          'Content-Type' => 'image/gif'
-        })
-
-      response = RestClient.get 'www.example.com'
-      expect(response.encoding).to eq Encoding::BINARY
-    end
-  end
-end

data/vendor/cache/ruby/2.7.0/gems/rest-client-2.1.0/spec/integration/request_spec.rb

@@ -1,127 +0,0 @@
-require_relative '_lib'
-
-describe RestClient::Request do
-  before(:all) do
-    WebMock.disable!
-  end
-
-  after(:all) do
-    WebMock.enable!
-  end
-
-  describe "ssl verification" do
-    it "is successful with the correct ca_file" do
-      request = RestClient::Request.new(
-        :method => :get,
-        :url => 'https://www.mozilla.org',
-        :ssl_ca_file => File.join(File.dirname(__FILE__), "certs", "digicert.crt")
-      )
-      expect { request.execute }.to_not raise_error
-    end
-
-    it "is successful with the correct ca_path" do
-      request = RestClient::Request.new(
-        :method => :get,
-        :url => 'https://www.mozilla.org',
-        :ssl_ca_path => File.join(File.dirname(__FILE__), "capath_digicert")
-      )
-      expect { request.execute }.to_not raise_error
-    end
-
-    # TODO: deprecate and remove RestClient::SSLCertificateNotVerified and just
-    # pass through OpenSSL::SSL::SSLError directly. See note in
-    # lib/restclient/request.rb.
-    #
-    # On OS X, this test fails since Apple has patched OpenSSL to always fall
-    # back on the system CA store.
-    it "is unsuccessful with an incorrect ca_file", :unless => RestClient::Platform.mac_mri? do
-      request = RestClient::Request.new(
-        :method => :get,
-        :url => 'https://www.mozilla.org',
-        :ssl_ca_file => File.join(File.dirname(__FILE__), "certs", "verisign.crt")
-      )
-      expect { request.execute }.to raise_error(RestClient::SSLCertificateNotVerified)
-    end
-
-    # On OS X, this test fails since Apple has patched OpenSSL to always fall
-    # back on the system CA store.
-    it "is unsuccessful with an incorrect ca_path", :unless => RestClient::Platform.mac_mri? do
-      request = RestClient::Request.new(
-        :method => :get,
-        :url => 'https://www.mozilla.org',
-        :ssl_ca_path => File.join(File.dirname(__FILE__), "capath_verisign")
-      )
-      expect { request.execute }.to raise_error(RestClient::SSLCertificateNotVerified)
-    end
-
-    it "is successful using the default system cert store" do
-      request = RestClient::Request.new(
-        :method => :get,
-        :url => 'https://www.mozilla.org',
-        :verify_ssl => true,
-      )
-      expect {request.execute }.to_not raise_error
-    end
-
-    it "executes the verify_callback" do
-      ran_callback = false
-      request = RestClient::Request.new(
-        :method => :get,
-        :url => 'https://www.mozilla.org',
-        :verify_ssl => true,
-        :ssl_verify_callback => lambda { |preverify_ok, store_ctx|
-          ran_callback = true
-          preverify_ok
-        },
-      )
-      expect {request.execute }.to_not raise_error
-      expect(ran_callback).to eq(true)
-    end
-
-    it "fails verification when the callback returns false",
-       :unless => RestClient::Platform.mac_mri? do
-      request = RestClient::Request.new(
-        :method => :get,
-        :url => 'https://www.mozilla.org',
-        :verify_ssl => true,
-        :ssl_verify_callback => lambda { |preverify_ok, store_ctx| false },
-      )
-      expect { request.execute }.to raise_error(RestClient::SSLCertificateNotVerified)
-    end
-
-    it "succeeds verification when the callback returns true",
-       :unless => RestClient::Platform.mac_mri? do
-      request = RestClient::Request.new(
-        :method => :get,
-        :url => 'https://www.mozilla.org',
-        :verify_ssl => true,
-        :ssl_ca_file => File.join(File.dirname(__FILE__), "certs", "verisign.crt"),
-        :ssl_verify_callback => lambda { |preverify_ok, store_ctx| true },
-      )
-      expect { request.execute }.to_not raise_error
-    end
-  end
-
-  describe "timeouts" do
-    it "raises OpenTimeout when it hits an open timeout" do
-      request = RestClient::Request.new(
-        :method => :get,
-        :url => 'http://www.mozilla.org',
-        :open_timeout => 1e-10,
-      )
-      expect { request.execute }.to(
-        raise_error(RestClient::Exceptions::OpenTimeout))
-    end
-
-    it "raises ReadTimeout when it hits a read timeout via :read_timeout" do
-      request = RestClient::Request.new(
-        :method => :get,
-        :url => 'https://www.mozilla.org',
-        :read_timeout => 1e-10,
-      )
-      expect { request.execute }.to(
-        raise_error(RestClient::Exceptions::ReadTimeout))
-    end
-  end
-
-end

data/vendor/cache/ruby/2.7.0/gems/rest-client-2.1.0/spec/spec_helper.rb

@@ -1,29 +0,0 @@
-require 'webmock/rspec'
-require 'rest-client'
-
-require_relative './helpers'
-
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-  config.raise_errors_for_deprecations!
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = 'random'
-
-  # always run with ruby warnings enabled
-  # TODO: figure out why this is so obscenely noisy (rspec bug?)
-  # config.warnings = true
-
-  # add helpers
-  config.include Helpers, :include_helpers
-
-  config.mock_with :rspec do |mocks|
-    mocks.yield_receiver_to_any_instance_implementation_blocks = true
-  end
-end
-
-# always run with ruby warnings enabled (see above)
-$VERBOSE = true

data/vendor/cache/ruby/2.7.0/gems/rest-client-2.1.0/spec/unit/_lib.rb

@@ -1 +0,0 @@
-require_relative '../spec_helper'

data/vendor/cache/ruby/2.7.0/gems/rest-client-2.1.0/spec/unit/abstract_response_spec.rb

@@ -1,145 +0,0 @@
-require_relative '_lib'
-
-describe RestClient::AbstractResponse, :include_helpers do
-
-  # Sample class implementing AbstractResponse used for testing.
-  class MyAbstractResponse
-
-    include RestClient::AbstractResponse
-
-    attr_accessor :size
-
-    def initialize(net_http_res, request)
-      response_set_vars(net_http_res, request, Time.now - 1)
-    end
-
-  end
-
-  before do
-    @net_http_res = res_double()
-    @request = request_double(url: 'http://example.com', method: 'get')
-    @response = MyAbstractResponse.new(@net_http_res, @request)
-  end
-
-  it "fetches the numeric response code" do
-    expect(@net_http_res).to receive(:code).and_return('200')
-    expect(@response.code).to eq 200
-  end
-
-  it "has a nice description" do
-    expect(@net_http_res).to receive(:to_hash).and_return({'Content-Type' => ['application/pdf']})
-    expect(@net_http_res).to receive(:code).and_return('200')
-    expect(@response.description).to eq "200 OK | application/pdf  bytes\n"
-  end
-
-  describe '.beautify_headers' do
-    it "beautifies the headers by turning the keys to symbols" do
-      h = RestClient::AbstractResponse.beautify_headers('content-type' => [ 'x' ])
-      expect(h.keys.first).to eq :content_type
-    end
-
-    it "beautifies the headers by turning the values to strings instead of one-element arrays" do
-      h = RestClient::AbstractResponse.beautify_headers('x' => [ 'text/html' ] )
-      expect(h.values.first).to eq 'text/html'
-    end
-
-    it 'joins multiple header values by comma' do
-      expect(RestClient::AbstractResponse.beautify_headers(
-        {'My-Header' => ['one', 'two']}
-      )).to eq({:my_header => 'one, two'})
-    end
-
-    it 'leaves set-cookie headers as array' do
-      expect(RestClient::AbstractResponse.beautify_headers(
-        {'Set-Cookie' => ['cookie1=foo', 'cookie2=bar']}
-      )).to eq({:set_cookie => ['cookie1=foo', 'cookie2=bar']})
-    end
-  end
-
-  it "fetches the headers" do
-    expect(@net_http_res).to receive(:to_hash).and_return('content-type' => [ 'text/html' ])
-    expect(@response.headers).to eq({ :content_type => 'text/html' })
-  end
-
-  it "extracts cookies from response headers" do
-    expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
-    expect(@response.cookies).to eq({ 'session_id' => '1' })
-  end
-
-  it "extract strange cookies" do
-    expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=ZJ/HQVH6YE+rVkTpn0zvTQ==; path=/'])
-    expect(@response.headers).to eq({:set_cookie => ['session_id=ZJ/HQVH6YE+rVkTpn0zvTQ==; path=/']})
-    expect(@response.cookies).to eq({ 'session_id' => 'ZJ/HQVH6YE+rVkTpn0zvTQ==' })
-  end
-
-  it "doesn't escape cookies" do
-    expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=BAh7BzoNYXBwX25hbWUiEGFwcGxpY2F0aW9uOgpsb2dpbiIKYWRtaW4%3D%0A--08114ba654f17c04d20dcc5228ec672508f738ca; path=/'])
-    expect(@response.cookies).to eq({ 'session_id' => 'BAh7BzoNYXBwX25hbWUiEGFwcGxpY2F0aW9uOgpsb2dpbiIKYWRtaW4%3D%0A--08114ba654f17c04d20dcc5228ec672508f738ca' })
-  end
-
-  describe '.cookie_jar' do
-    it 'extracts cookies into cookie jar' do
-      expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
-      expect(@response.cookie_jar).to be_a HTTP::CookieJar
-
-      cookie = @response.cookie_jar.cookies.first
-      expect(cookie.domain).to eq 'example.com'
-      expect(cookie.name).to eq 'session_id'
-      expect(cookie.value).to eq '1'
-      expect(cookie.path).to eq '/'
-    end
-
-    it 'handles cookies when URI scheme is implicit' do
-      net_http_res = double('net http response')
-      expect(net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
-      request = double('request', url: 'example.com', uri: URI.parse('http://example.com'),
-                       method: 'get', cookie_jar: HTTP::CookieJar.new, redirection_history: nil)
-      response = MyAbstractResponse.new(net_http_res, request)
-      expect(response.cookie_jar).to be_a HTTP::CookieJar
-
-      cookie = response.cookie_jar.cookies.first
-      expect(cookie.domain).to eq 'example.com'
-      expect(cookie.name).to eq 'session_id'
-      expect(cookie.value).to eq '1'
-      expect(cookie.path).to eq '/'
-    end
-  end
-
-  it "can access the net http result directly" do
-    expect(@response.net_http_res).to eq @net_http_res
-  end
-
-  describe "#return!" do
-    it "should return the response itself on 200-codes" do
-      expect(@net_http_res).to receive(:code).and_return('200')
-      expect(@response.return!).to be_equal(@response)
-    end
-
-    it "should raise RequestFailed on unknown codes" do
-      expect(@net_http_res).to receive(:code).and_return('1000')
-      expect { @response.return! }.to raise_error RestClient::RequestFailed
-    end
-
-    it "should raise an error on a redirection after non-GET/HEAD requests" do
-      expect(@net_http_res).to receive(:code).and_return('301')
-      expect(@request).to receive(:method).and_return('put')
-      expect(@response).not_to receive(:follow_redirection)
-      expect { @response.return! }.to raise_error RestClient::RequestFailed
-    end
-
-    it "should follow 302 redirect" do
-      expect(@net_http_res).to receive(:code).and_return('302')
-      expect(@response).to receive(:check_max_redirects).and_return('fake-check')
-      expect(@response).to receive(:follow_redirection).and_return('fake-redirection')
-      expect(@response.return!).to eq 'fake-redirection'
-    end
-
-    it "should gracefully handle 302 redirect with no location header" do
-      @net_http_res = res_double(code: 302)
-      @request = request_double()
-      @response = MyAbstractResponse.new(@net_http_res, @request)
-      expect(@response).to receive(:check_max_redirects).and_return('fake-check')
-      expect { @response.return! }.to raise_error RestClient::Found
-    end
-  end
-end

data/vendor/cache/ruby/2.7.0/gems/rest-client-2.1.0/spec/unit/exceptions_spec.rb

@@ -1,108 +0,0 @@
-require_relative '_lib'
-
-describe RestClient::Exception do
-  it "returns a 'message' equal to the class name if the message is not set, because 'message' should not be nil" do
-    e = RestClient::Exception.new
-    expect(e.message).to eq "RestClient::Exception"
-  end
-
-  it "returns the 'message' that was set" do
-    e = RestClient::Exception.new
-    message = "An explicitly set message"
-    e.message = message
-    expect(e.message).to eq message
-  end
-
-  it "sets the exception message to ErrorMessage" do
-    expect(RestClient::ResourceNotFound.new.message).to eq 'Not Found'
-  end
-
-  it "contains exceptions in RestClient" do
-    expect(RestClient::Unauthorized.new).to be_a_kind_of(RestClient::Exception)
-    expect(RestClient::ServerBrokeConnection.new).to be_a_kind_of(RestClient::Exception)
-  end
-end
-
-describe RestClient::ServerBrokeConnection do
-  it "should have a default message of 'Server broke connection'" do
-    e = RestClient::ServerBrokeConnection.new
-    expect(e.message).to eq 'Server broke connection'
-  end
-end
-
-describe RestClient::RequestFailed do
-  before do
-    @response = double('HTTP Response', :code => '502')
-  end
-
-  it "stores the http response on the exception" do
-    response = "response"
-    begin
-      raise RestClient::RequestFailed, response
-    rescue RestClient::RequestFailed => e
-      expect(e.response).to eq response
-    end
-  end
-
-  it "http_code convenience method for fetching the code as an integer" do
-    expect(RestClient::RequestFailed.new(@response).http_code).to eq 502
-  end
-
-  it "http_body convenience method for fetching the body (decoding when necessary)" do
-    expect(RestClient::RequestFailed.new(@response).http_code).to eq 502
-    expect(RestClient::RequestFailed.new(@response).message).to eq 'HTTP status code 502'
-  end
-
-  it "shows the status code in the message" do
-    expect(RestClient::RequestFailed.new(@response).to_s).to match(/502/)
-  end
-end
-
-describe RestClient::ResourceNotFound do
-  it "also has the http response attached" do
-    response = "response"
-    begin
-      raise RestClient::ResourceNotFound, response
-    rescue RestClient::ResourceNotFound => e
-      expect(e.response).to eq response
-    end
-  end
-
-  it 'stores the body on the response of the exception' do
-    body = "body"
-    stub_request(:get, "www.example.com").to_return(:body => body, :status => 404)
-    begin
-      RestClient.get "www.example.com"
-      raise
-    rescue RestClient::ResourceNotFound => e
-      expect(e.response.body).to eq body
-    end
-  end
-end
-
-describe "backwards compatibility" do
-  it 'aliases RestClient::NotFound as ResourceNotFound' do
-    expect(RestClient::ResourceNotFound).to eq RestClient::NotFound
-  end
-
-  it 'aliases old names for HTTP 413, 414, 416' do
-    expect(RestClient::RequestEntityTooLarge).to eq RestClient::PayloadTooLarge
-    expect(RestClient::RequestURITooLong).to eq RestClient::URITooLong
-    expect(RestClient::RequestedRangeNotSatisfiable).to eq RestClient::RangeNotSatisfiable
-  end
-
-  it 'subclasses NotFound from RequestFailed, ExceptionWithResponse' do
-    expect(RestClient::NotFound).to be < RestClient::RequestFailed
-    expect(RestClient::NotFound).to be < RestClient::ExceptionWithResponse
-  end
-
-  it 'subclasses timeout from RestClient::RequestTimeout, RequestFailed, EWR' do
-    expect(RestClient::Exceptions::OpenTimeout).to be < RestClient::Exceptions::Timeout
-    expect(RestClient::Exceptions::ReadTimeout).to be < RestClient::Exceptions::Timeout
-
-    expect(RestClient::Exceptions::Timeout).to be < RestClient::RequestTimeout
-    expect(RestClient::Exceptions::Timeout).to be < RestClient::RequestFailed
-    expect(RestClient::Exceptions::Timeout).to be < RestClient::ExceptionWithResponse
-  end
-
-end

data/vendor/cache/ruby/2.7.0/gems/rest-client-2.1.0/spec/unit/params_array_spec.rb

@@ -1,36 +0,0 @@
-require_relative '_lib'
-
-describe RestClient::ParamsArray do
-
-  describe '.new' do
-    it 'accepts various types of containers' do
-      as_array = [[:foo, 123], [:foo, 456], [:bar, 789], [:empty, nil]]
-      [
-        [[:foo, 123], [:foo, 456], [:bar, 789], [:empty, nil]],
-        [{foo: 123}, {foo: 456}, {bar: 789}, {empty: nil}],
-        [{foo: 123}, {foo: 456}, {bar: 789}, {empty: nil}],
-        [{foo: 123}, [:foo, 456], {bar: 789}, {empty: nil}],
-        [{foo: 123}, [:foo, 456], {bar: 789}, [:empty]],
-      ].each do |input|
-        expect(RestClient::ParamsArray.new(input).to_a).to eq as_array
-      end
-
-      expect(RestClient::ParamsArray.new([]).to_a).to eq []
-      expect(RestClient::ParamsArray.new([]).empty?).to eq true
-    end
-
-    it 'rejects various invalid input' do
-      expect {
-        RestClient::ParamsArray.new([[]])
-      }.to raise_error(IndexError)
-
-      expect {
-        RestClient::ParamsArray.new([[1,2,3]])
-      }.to raise_error(ArgumentError)
-
-      expect {
-        RestClient::ParamsArray.new([1,2,3])
-      }.to raise_error(NoMethodError)
-    end
-  end
-end