tdiary 5.2.1 → 5.2.2

data/vendor/bundle/ruby/3.1.0/gems/faraday-1.10.0/spec/faraday/utils/headers_spec.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Utils::Headers do
-  subject { Faraday::Utils::Headers.new }
-
-  context 'when Content-Type is set to application/json' do
-    before { subject['Content-Type'] = 'application/json' }
-
-    it { expect(subject.keys).to eq(['Content-Type']) }
-    it { expect(subject['Content-Type']).to eq('application/json') }
-    it { expect(subject['CONTENT-TYPE']).to eq('application/json') }
-    it { expect(subject['content-type']).to eq('application/json') }
-    it { is_expected.to include('content-type') }
-  end
-
-  context 'when Content-Type is set to application/xml' do
-    before { subject['Content-Type'] = 'application/xml' }
-
-    it { expect(subject.keys).to eq(['Content-Type']) }
-    it { expect(subject['Content-Type']).to eq('application/xml') }
-    it { expect(subject['CONTENT-TYPE']).to eq('application/xml') }
-    it { expect(subject['content-type']).to eq('application/xml') }
-    it { is_expected.to include('content-type') }
-  end
-
-  describe '#fetch' do
-    before { subject['Content-Type'] = 'application/json' }
-
-    it { expect(subject.fetch('Content-Type')).to eq('application/json') }
-    it { expect(subject.fetch('CONTENT-TYPE')).to eq('application/json') }
-    it { expect(subject.fetch(:content_type)).to eq('application/json') }
-    it { expect(subject.fetch('invalid', 'default')).to eq('default') }
-    it { expect(subject.fetch('invalid', false)).to eq(false) }
-    it { expect(subject.fetch('invalid', nil)).to be_nil }
-    it { expect(subject.fetch('Invalid') { |key| "#{key} key" }).to eq('Invalid key') }
-    it 'calls a block when provided' do
-      block_called = false
-      expect(subject.fetch('content-type') { block_called = true }).to eq('application/json')
-      expect(block_called).to be_falsey
-    end
-    it 'raises an error if key not found' do
-      expected_error = defined?(KeyError) ? KeyError : IndexError
-      expect { subject.fetch('invalid') }.to raise_error(expected_error)
-    end
-  end
-
-  describe '#delete' do
-    before do
-      subject['Content-Type'] = 'application/json'
-      @deleted = subject.delete('content-type')
-    end
-
-    it { expect(@deleted).to eq('application/json') }
-    it { expect(subject.size).to eq(0) }
-    it { is_expected.not_to include('content-type') }
-    it { expect(subject.delete('content-type')).to be_nil }
-  end
-
-  describe '#parse' do
-    before { subject.parse(headers) }
-
-    context 'when response headers leave http status line out' do
-      let(:headers) { "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n" }
-
-      it { expect(subject.keys).to eq(%w[Content-Type]) }
-      it { expect(subject['Content-Type']).to eq('text/html') }
-      it { expect(subject['content-type']).to eq('text/html') }
-    end
-
-    context 'when response headers values include a colon' do
-      let(:headers) { "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nLocation: http://sushi.com/\r\n\r\n" }
-
-      it { expect(subject['location']).to eq('http://sushi.com/') }
-    end
-
-    context 'when response headers include a blank line' do
-      let(:headers) { "HTTP/1.1 200 OK\r\n\r\nContent-Type: text/html\r\n\r\n" }
-
-      it { expect(subject['content-type']).to eq('text/html') }
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/faraday-1.10.0/spec/faraday/utils_spec.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Faraday::Utils do
-  describe 'headers parsing' do
-    let(:multi_response_headers) do
-      "HTTP/1.x 500 OK\r\nContent-Type: text/html; charset=UTF-8\r\n" \
-      "HTTP/1.x 200 OK\r\nContent-Type: application/json; charset=UTF-8\r\n\r\n"
-    end
-
-    it 'parse headers for aggregated responses' do
-      headers = Faraday::Utils::Headers.new
-      headers.parse(multi_response_headers)
-
-      result = headers.to_hash
-
-      expect(result['Content-Type']).to eq('application/json; charset=UTF-8')
-    end
-  end
-
-  describe 'URI parsing' do
-    let(:url) { 'http://example.com/abc' }
-
-    it 'escapes safe buffer' do
-      str = FakeSafeBuffer.new('$32,000.00')
-      expect(Faraday::Utils.escape(str)).to eq('%2432%2C000.00')
-    end
-
-    it 'parses with default parser' do
-      with_default_uri_parser(nil) do
-        uri = normalize(url)
-        expect(uri.host).to eq('example.com')
-      end
-    end
-
-    it 'parses with URI' do
-      with_default_uri_parser(::URI) do
-        uri = normalize(url)
-        expect(uri.host).to eq('example.com')
-      end
-    end
-
-    it 'parses with block' do
-      with_default_uri_parser(->(u) { "booya#{'!' * u.size}" }) do
-        expect(normalize(url)).to eq('booya!!!!!!!!!!!!!!!!!!!!!!')
-      end
-    end
-
-    it 'replaces headers hash' do
-      headers = Faraday::Utils::Headers.new('authorization' => 't0ps3cr3t!')
-      expect(headers).to have_key('authorization')
-
-      headers.replace('content-type' => 'text/plain')
-      expect(headers).not_to have_key('authorization')
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/faraday-1.10.0/spec/support/fake_safe_buffer.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-# emulates ActiveSupport::SafeBuffer#gsub
-FakeSafeBuffer = Struct.new(:string) do
-  def to_s
-    self
-  end
-
-  def gsub(regex)
-    string.gsub(regex) do
-      match, = $&, '' =~ /a/
-      yield(match)
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/faraday-1.10.0/spec/support/helper_methods.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require 'multipart_parser/reader'
-
-module Faraday
-  module HelperMethods
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      def features(*features)
-        @features = features
-      end
-
-      def on_feature(name)
-        yield if block_given? && feature?(name)
-      end
-
-      def feature?(name)
-        if @features.nil?
-          superclass.feature?(name) if superclass.respond_to?(:feature?)
-        elsif @features.include?(name)
-          true
-        end
-      end
-
-      def method_with_body?(method)
-        METHODS_WITH_BODY.include?(method.to_s)
-      end
-    end
-
-    def ssl_mode?
-      ENV['SSL'] == 'yes'
-    end
-
-    def normalize(url)
-      Faraday::Utils::URI(url)
-    end
-
-    def with_default_uri_parser(parser)
-      old_parser = Faraday::Utils.default_uri_parser
-      begin
-        Faraday::Utils.default_uri_parser = parser
-        yield
-      ensure
-        Faraday::Utils.default_uri_parser = old_parser
-      end
-    end
-
-    def with_env(new_env)
-      old_env = {}
-
-      new_env.each do |key, value|
-        old_env[key] = ENV.fetch(key, false)
-        ENV[key] = value
-      end
-
-      begin
-        yield
-      ensure
-        old_env.each do |key, value|
-          value == false ? ENV.delete(key) : ENV[key] = value
-        end
-      end
-    end
-
-    def with_env_proxy_disabled
-      Faraday.ignore_env_proxy = true
-
-      begin
-        yield
-      ensure
-        Faraday.ignore_env_proxy = false
-      end
-    end
-
-    def capture_warnings
-      old = $stderr
-      $stderr = StringIO.new
-      begin
-        yield
-        $stderr.string
-      ensure
-        $stderr = old
-      end
-    end
-
-    def multipart_file
-      Faraday::FilePart.new(__FILE__, 'text/x-ruby')
-    end
-
-    # parse boundary out of a Content-Type header like:
-    #   Content-Type: multipart/form-data; boundary=gc0p4Jq0M2Yt08jU534c0p
-    def parse_multipart_boundary(ctype)
-      MultipartParser::Reader.extract_boundary_value(ctype)
-    end
-
-    # parse a multipart MIME message, returning a hash of any multipart errors
-    def parse_multipart(boundary, body)
-      reader = MultipartParser::Reader.new(boundary)
-      result = { errors: [], parts: [] }
-      def result.part(name)
-        hash = self[:parts].detect { |h| h[:part].name == name }
-        [hash[:part], hash[:body].join]
-      end
-
-      reader.on_part do |part|
-        result[:parts] << thispart = {
-          part: part,
-          body: []
-        }
-        part.on_data do |chunk|
-          thispart[:body] << chunk
-        end
-      end
-      reader.on_error do |msg|
-        result[:errors] << msg
-      end
-      reader.write(body)
-      result
-    end
-
-    def method_with_body?(method)
-      self.class.method_with_body?(method)
-    end
-
-    def big_string
-      kb = 1024
-      (32..126).map(&:chr).cycle.take(50 * kb).join
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/faraday-1.10.0/spec/support/shared_examples/adapter.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples 'an adapter' do |**options|
-  before { skip } if options[:skip]
-
-  context 'with SSL enabled' do
-    before { ENV['SSL'] = 'yes' }
-    include_examples 'adapter examples', options
-  end
-
-  context 'with SSL disabled' do
-    before { ENV['SSL'] = 'no' }
-    include_examples 'adapter examples', options
-  end
-end
-
-shared_examples 'adapter examples' do |**options|
-  include Faraday::StreamingResponseChecker
-
-  let(:adapter) { described_class.name.split('::').last }
-
-  let(:conn_options) { { headers: { 'X-Faraday-Adapter' => adapter } }.merge(options[:conn_options] || {}) }
-
-  let(:adapter_options) do
-    return [] unless options[:adapter_options]
-
-    if options[:adapter_options].is_a?(Array)
-      options[:adapter_options]
-    else
-      [options[:adapter_options]]
-    end
-  end
-
-  let(:protocol) { ssl_mode? ? 'https' : 'http' }
-  let(:remote) { "#{protocol}://example.com" }
-  let(:stub_remote) { remote }
-
-  let(:conn) do
-    conn_options[:ssl] ||= {}
-    conn_options[:ssl][:ca_file] ||= ENV['SSL_FILE']
-
-    Faraday.new(remote, conn_options) do |conn|
-      conn.request :multipart
-      conn.request :url_encoded
-      conn.response :raise_error
-      conn.adapter described_class, *adapter_options
-    end
-  end
-
-  let!(:request_stub) { stub_request(http_method, stub_remote) }
-
-  after do
-    expect(request_stub).to have_been_requested unless request_stub.disabled?
-  end
-
-  describe '#delete' do
-    let(:http_method) { :delete }
-
-    it_behaves_like 'a request method', :delete
-  end
-
-  describe '#get' do
-    let(:http_method) { :get }
-
-    it_behaves_like 'a request method', :get
-  end
-
-  describe '#head' do
-    let(:http_method) { :head }
-
-    it_behaves_like 'a request method', :head
-  end
-
-  describe '#options' do
-    let(:http_method) { :options }
-
-    it_behaves_like 'a request method', :options
-  end
-
-  describe '#patch' do
-    let(:http_method) { :patch }
-
-    it_behaves_like 'a request method', :patch
-  end
-
-  describe '#post' do
-    let(:http_method) { :post }
-
-    it_behaves_like 'a request method', :post
-  end
-
-  describe '#put' do
-    let(:http_method) { :put }
-
-    it_behaves_like 'a request method', :put
-  end
-
-  on_feature :trace_method do
-    describe '#trace' do
-      let(:http_method) { :trace }
-
-      it_behaves_like 'a request method', :trace
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/faraday-1.10.0/spec/support/shared_examples/request_method.rb

@@ -1,262 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples 'proxy examples' do
-  it 'handles requests with proxy' do
-    res = conn.public_send(http_method, '/')
-
-    expect(res.status).to eq(200)
-  end
-
-  it 'handles proxy failures' do
-    request_stub.to_return(status: 407)
-
-    expect { conn.public_send(http_method, '/') }.to raise_error(Faraday::ProxyAuthError)
-  end
-end
-
-shared_examples 'a request method' do |http_method|
-  let(:query_or_body) { method_with_body?(http_method) ? :body : :query }
-  let(:response) { conn.public_send(http_method, '/') }
-
-  unless http_method == :head && feature?(:skip_response_body_on_head)
-    it 'retrieves the response body' do
-      res_body = 'test'
-      request_stub.to_return(body: res_body)
-      expect(conn.public_send(http_method, '/').body).to eq(res_body)
-    end
-  end
-
-  it 'handles headers with multiple values' do
-    request_stub.to_return(headers: { 'Set-Cookie' => 'name=value' })
-    expect(response.headers['set-cookie']).to eq('name=value')
-  end
-
-  it 'retrieves the response headers' do
-    request_stub.to_return(headers: { 'Content-Type' => 'text/plain' })
-    expect(response.headers['Content-Type']).to match(%r{text/plain})
-    expect(response.headers['content-type']).to match(%r{text/plain})
-  end
-
-  it 'sends user agent' do
-    request_stub.with(headers: { 'User-Agent' => 'Agent Faraday' })
-    conn.public_send(http_method, '/', nil, user_agent: 'Agent Faraday')
-  end
-
-  it 'represents empty body response as blank string' do
-    expect(response.body).to eq('')
-  end
-
-  it 'handles connection error' do
-    request_stub.disable
-    expect { conn.public_send(http_method, 'http://localhost:4') }.to raise_error(Faraday::ConnectionFailed)
-  end
-
-  on_feature :local_socket_binding do
-    it 'binds local socket' do
-      stub_request(http_method, 'http://example.com')
-
-      host = '1.2.3.4'
-      port = 1234
-      conn_options[:request] = { bind: { host: host, port: port } }
-
-      conn.public_send(http_method, '/')
-
-      expect(conn.options[:bind][:host]).to eq(host)
-      expect(conn.options[:bind][:port]).to eq(port)
-    end
-  end
-
-  # context 'when wrong ssl certificate is provided' do
-  #   let(:ca_file_path) { 'tmp/faraday-different-ca-cert.crt' }
-  #   before { conn_options.merge!(ssl: { ca_file: ca_file_path }) }
-  #
-  #   it do
-  #     expect { conn.public_send(http_method, '/') }.to raise_error(Faraday::SSLError) # do |ex|
-  #       expect(ex.message).to include?('certificate')
-  #     end
-  #   end
-  # end
-
-  on_feature :request_body_on_query_methods do
-    it 'sends request body' do
-      request_stub.with(Hash[:body, 'test'])
-      res = if query_or_body == :body
-              conn.public_send(http_method, '/', 'test')
-            else
-              conn.public_send(http_method, '/') do |req|
-                req.body = 'test'
-              end
-            end
-      expect(res.env.request_body).to eq('test')
-    end
-  end
-
-  it 'sends url encoded parameters' do
-    payload = { name: 'zack' }
-    request_stub.with(Hash[query_or_body, payload])
-    res = conn.public_send(http_method, '/', payload)
-    if query_or_body == :query
-      expect(res.env.request_body).to be_nil
-    else
-      expect(res.env.request_body).to eq('name=zack')
-    end
-  end
-
-  it 'sends url encoded nested parameters' do
-    payload = { name: { first: 'zack' } }
-    request_stub.with(Hash[query_or_body, payload])
-    conn.public_send(http_method, '/', payload)
-  end
-
-  # TODO: This needs reimplementation: see https://github.com/lostisland/faraday/issues/718
-  # Should raise Faraday::TimeoutError
-  it 'supports timeout option' do
-    conn_options[:request] = { timeout: 1 }
-    request_stub.to_timeout
-    exc = adapter == 'NetHttp' ? Faraday::ConnectionFailed : Faraday::TimeoutError
-    expect { conn.public_send(http_method, '/') }.to raise_error(exc)
-  end
-
-  # TODO: This needs reimplementation: see https://github.com/lostisland/faraday/issues/718
-  # Should raise Faraday::ConnectionFailed
-  it 'supports open_timeout option' do
-    conn_options[:request] = { open_timeout: 1 }
-    request_stub.to_timeout
-    exc = adapter == 'NetHttp' ? Faraday::ConnectionFailed : Faraday::TimeoutError
-    expect { conn.public_send(http_method, '/') }.to raise_error(exc)
-  end
-
-  # Can't send files on get, head and delete methods
-  if method_with_body?(http_method)
-    it 'sends files' do
-      payload = { uploaded_file: multipart_file }
-      request_stub.with(headers: { 'Content-Type' => %r{\Amultipart/form-data} }) do |request|
-        # WebMock does not support matching body for multipart/form-data requests yet :(
-        # https://github.com/bblimke/webmock/issues/623
-        request.body.include?('RubyMultipartPost')
-      end
-      conn.public_send(http_method, '/', payload)
-    end
-  end
-
-  on_feature :reason_phrase_parse do
-    it 'parses the reason phrase' do
-      request_stub.to_return(status: [200, 'OK'])
-      expect(response.reason_phrase).to eq('OK')
-    end
-  end
-
-  on_feature :compression do
-    # Accept-Encoding header not sent for HEAD requests as body is not expected in the response.
-    unless http_method == :head
-      it 'handles gzip compression' do
-        request_stub.with(headers: { 'Accept-Encoding' => /\bgzip\b/ })
-        conn.public_send(http_method, '/')
-      end
-
-      it 'handles deflate compression' do
-        request_stub.with(headers: { 'Accept-Encoding' => /\bdeflate\b/ })
-        conn.public_send(http_method, '/')
-      end
-    end
-  end
-
-  on_feature :streaming do
-    describe 'streaming' do
-      let(:streamed) { [] }
-
-      context 'when response is empty' do
-        it do
-          conn.public_send(http_method, '/') do |req|
-            req.options.on_data = proc { |*args| streamed << args }
-          end
-
-          expect(streamed).to eq([['', 0]])
-        end
-      end
-
-      context 'when response contains big data' do
-        before { request_stub.to_return(body: big_string) }
-
-        it 'handles streaming' do
-          response = conn.public_send(http_method, '/') do |req|
-            req.options.on_data = proc { |*args| streamed << args }
-          end
-
-          expect(response.body).to eq('')
-          check_streaming_response(streamed, chunk_size: 16 * 1024)
-        end
-      end
-    end
-  end
-
-  on_feature :parallel do
-    context 'with parallel setup' do
-      before do
-        @resp1 = nil
-        @resp2 = nil
-        @payload1 = { a: '1' }
-        @payload2 = { b: '2' }
-
-        request_stub
-          .with(Hash[query_or_body, @payload1])
-          .to_return(body: @payload1.to_json)
-
-        stub_request(http_method, remote)
-          .with(Hash[query_or_body, @payload2])
-          .to_return(body: @payload2.to_json)
-
-        conn.in_parallel do
-          @resp1 = conn.public_send(http_method, '/', @payload1)
-          @resp2 = conn.public_send(http_method, '/', @payload2)
-
-          expect(conn.in_parallel?).to be_truthy
-          expect(@resp1.body).to be_nil
-          expect(@resp2.body).to be_nil
-        end
-
-        expect(conn.in_parallel?).to be_falsey
-      end
-
-      it 'handles parallel requests status' do
-        expect(@resp1&.status).to eq(200)
-        expect(@resp2&.status).to eq(200)
-      end
-
-      unless http_method == :head && feature?(:skip_response_body_on_head)
-        it 'handles parallel requests body' do
-          expect(@resp1&.body).to eq(@payload1.to_json)
-          expect(@resp2&.body).to eq(@payload2.to_json)
-        end
-      end
-    end
-  end
-
-  context 'when a proxy is provided as option' do
-    before do
-      conn_options[:proxy] = 'http://env-proxy.com:80'
-    end
-
-    include_examples 'proxy examples'
-  end
-
-  context 'when http_proxy env variable is set' do
-    let(:proxy_url) { 'http://env-proxy.com:80' }
-
-    around do |example|
-      with_env 'http_proxy' => proxy_url do
-        example.run
-      end
-    end
-
-    include_examples 'proxy examples'
-
-    context 'when the env proxy is ignored' do
-      around do |example|
-        with_env_proxy_disabled(&example)
-      end
-
-      include_examples 'proxy examples'
-    end
-  end
-end