es_cli 0.1.0

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.12.2/examples/client_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# Requires Ruby with rspec and faraday gems.
+# rspec client_spec.rb
+
+require 'faraday'
+require 'json'
+
+# Example API client
+class Client
+  def initialize(conn)
+    @conn = conn
+  end
+
+  def httpbingo(jname, params: {})
+    res = @conn.get("/#{jname}", params)
+    data = JSON.parse(res.body)
+    data['origin']
+  end
+
+  def foo(params)
+    res = @conn.post('/foo', JSON.dump(params))
+    res.status
+  end
+end
+
+RSpec.describe Client do
+  let(:stubs)  { Faraday::Adapter::Test::Stubs.new }
+  let(:conn)   { Faraday.new { |b| b.adapter(:test, stubs) } }
+  let(:client) { Client.new(conn) }
+
+  it 'parses origin' do
+    stubs.get('/ip') do |env|
+      # optional: you can inspect the Faraday::Env
+      expect(env.url.path).to eq('/ip')
+      [
+        200,
+        { 'Content-Type': 'application/javascript' },
+        '{"origin": "127.0.0.1"}'
+      ]
+    end
+
+    # uncomment to trigger stubs.verify_stubbed_calls failure
+    # stubs.get('/unused') { [404, {}, ''] }
+
+    expect(client.httpbingo('ip')).to eq('127.0.0.1')
+    stubs.verify_stubbed_calls
+  end
+
+  it 'handles 404' do
+    stubs.get('/api') do
+      [
+        404,
+        { 'Content-Type': 'application/javascript' },
+        '{}'
+      ]
+    end
+    expect(client.httpbingo('api')).to be_nil
+    stubs.verify_stubbed_calls
+  end
+
+  it 'handles exception' do
+    stubs.get('/api') do
+      raise Faraday::ConnectionFailed
+    end
+
+    expect { client.httpbingo('api') }.to raise_error(Faraday::ConnectionFailed)
+    stubs.verify_stubbed_calls
+  end
+
+  context 'When the test stub is run in strict_mode' do
+    let(:stubs) { Faraday::Adapter::Test::Stubs.new(strict_mode: true) }
+
+    it 'verifies the all parameter values are identical' do
+      stubs.get('/api?abc=123') do
+        [
+          200,
+          { 'Content-Type': 'application/javascript' },
+          '{"origin": "127.0.0.1"}'
+        ]
+      end
+
+      # uncomment to raise Stubs::NotFound
+      # expect(client.httpbingo('api', params: { abc: 123, foo: 'Kappa' })).to eq('127.0.0.1')
+      expect(client.httpbingo('api', params: { abc: 123 })).to eq('127.0.0.1')
+      stubs.verify_stubbed_calls
+    end
+  end
+
+  context 'When the Faraday connection is configured with FlatParamsEncoder' do
+    let(:conn) { Faraday.new(request: { params_encoder: Faraday::FlatParamsEncoder }) { |b| b.adapter(:test, stubs) } }
+
+    it 'handles the same multiple URL parameters' do
+      stubs.get('/api?a=x&a=y&a=z') { [200, { 'Content-Type' => 'application/json' }, '{"origin": "127.0.0.1"}'] }
+
+      # uncomment to raise Stubs::NotFound
+      # expect(client.httpbingo('api', params: { a: %w[x y] })).to eq('127.0.0.1')
+      expect(client.httpbingo('api', params: { a: %w[x y z] })).to eq('127.0.0.1')
+      stubs.verify_stubbed_calls
+    end
+  end
+
+  context 'When you want to test the body, you can use a proc as well as string' do
+    it 'tests with a string' do
+      stubs.post('/foo', '{"name":"YK"}') { [200, {}, ''] }
+
+      expect(client.foo(name: 'YK')).to eq 200
+      stubs.verify_stubbed_calls
+    end
+
+    it 'tests with a proc' do
+      check = ->(request_body) { JSON.parse(request_body).slice('name') == { 'name' => 'YK' } }
+      stubs.post('/foo', check) { [200, {}, ''] }
+
+      expect(client.foo(name: 'YK', created_at: Time.now)).to eq 200
+      stubs.verify_stubbed_calls
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.12.2/examples/client_test.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+# Requires Ruby with test-unit and faraday gems.
+# ruby client_test.rb
+
+require 'faraday'
+require 'json'
+require 'test/unit'
+
+# Example API client
+class Client
+  def initialize(conn)
+    @conn = conn
+  end
+
+  def httpbingo(jname, params: {})
+    res = @conn.get("/#{jname}", params)
+    data = JSON.parse(res.body)
+    data['origin']
+  end
+
+  def foo(params)
+    res = @conn.post('/foo', JSON.dump(params))
+    res.status
+  end
+end
+
+# Example API client test
+class ClientTest < Test::Unit::TestCase
+  def test_httpbingo_name
+    stubs = Faraday::Adapter::Test::Stubs.new
+    stubs.get('/api') do |env|
+      # optional: you can inspect the Faraday::Env
+      assert_equal '/api', env.url.path
+      [
+        200,
+        { 'Content-Type': 'application/javascript' },
+        '{"origin": "127.0.0.1"}'
+      ]
+    end
+
+    # uncomment to trigger stubs.verify_stubbed_calls failure
+    # stubs.get('/unused') { [404, {}, ''] }
+
+    cli = client(stubs)
+    assert_equal '127.0.0.1', cli.httpbingo('api')
+    stubs.verify_stubbed_calls
+  end
+
+  def test_httpbingo_not_found
+    stubs = Faraday::Adapter::Test::Stubs.new
+    stubs.get('/api') do
+      [
+        404,
+        { 'Content-Type': 'application/javascript' },
+        '{}'
+      ]
+    end
+
+    cli = client(stubs)
+    assert_nil cli.httpbingo('api')
+    stubs.verify_stubbed_calls
+  end
+
+  def test_httpbingo_exception
+    stubs = Faraday::Adapter::Test::Stubs.new
+    stubs.get('/api') do
+      raise Faraday::ConnectionFailed
+    end
+
+    cli = client(stubs)
+    assert_raise Faraday::ConnectionFailed do
+      cli.httpbingo('api')
+    end
+    stubs.verify_stubbed_calls
+  end
+
+  def test_strict_mode
+    stubs = Faraday::Adapter::Test::Stubs.new(strict_mode: true)
+    stubs.get('/api?abc=123') do
+      [
+        200,
+        { 'Content-Type': 'application/javascript' },
+        '{"origin": "127.0.0.1"}'
+      ]
+    end
+
+    cli = client(stubs)
+    assert_equal '127.0.0.1', cli.httpbingo('api', params: { abc: 123 })
+
+    # uncomment to raise Stubs::NotFound
+    # assert_equal '127.0.0.1', cli.httpbingo('api', params: { abc: 123, foo: 'Kappa' })
+    stubs.verify_stubbed_calls
+  end
+
+  def test_non_default_params_encoder
+    stubs = Faraday::Adapter::Test::Stubs.new(strict_mode: true)
+    stubs.get('/api?a=x&a=y&a=z') do
+      [
+        200,
+        { 'Content-Type': 'application/javascript' },
+        '{"origin": "127.0.0.1"}'
+      ]
+    end
+    conn = Faraday.new(request: { params_encoder: Faraday::FlatParamsEncoder }) do |builder|
+      builder.adapter :test, stubs
+    end
+
+    cli = Client.new(conn)
+    assert_equal '127.0.0.1', cli.httpbingo('api', params: { a: %w[x y z] })
+
+    # uncomment to raise Stubs::NotFound
+    # assert_equal '127.0.0.1', cli.httpbingo('api', params: { a: %w[x y] })
+    stubs.verify_stubbed_calls
+  end
+
+  def test_with_string_body
+    stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+      stub.post('/foo', '{"name":"YK"}') { [200, {}, ''] }
+    end
+    cli = client(stubs)
+    assert_equal 200, cli.foo(name: 'YK')
+
+    stubs.verify_stubbed_calls
+  end
+
+  def test_with_proc_body
+    stubs = Faraday::Adapter::Test::Stubs.new do |stub|
+      check = ->(request_body) { JSON.parse(request_body).slice('name') == { 'name' => 'YK' } }
+      stub.post('/foo', check) { [200, {}, ''] }
+    end
+    cli = client(stubs)
+    assert_equal 200, cli.foo(name: 'YK', created_at: Time.now)
+
+    stubs.verify_stubbed_calls
+  end
+
+  def client(stubs)
+    conn = Faraday.new do |builder|
+      builder.adapter :test, stubs
+    end
+    Client.new(conn)
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.12.2/lib/faraday/adapter/test.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+module Faraday
+  class Adapter
+    # @example
+    #   test = Faraday::Connection.new do
+    #     use Faraday::Adapter::Test do |stub|
+    #       # Define matcher to match the request
+    #       stub.get '/resource.json' do
+    #         # return static content
+    #         [200, {'Content-Type' => 'application/json'}, 'hi world']
+    #       end
+    #
+    #       # response with content generated based on request
+    #       stub.get '/showget' do |env|
+    #         [200, {'Content-Type' => 'text/plain'}, env[:method].to_s]
+    #       end
+    #
+    #       # A regular expression can be used as matching filter
+    #       stub.get /\A\/items\/(\d+)\z/ do |env, meta|
+    #         # in case regular expression is used, an instance of MatchData
+    #         # can be received
+    #         [200,
+    #          {'Content-Type' => 'text/plain'},
+    #          "showing item: #{meta[:match_data][1]}"
+    #         ]
+    #       end
+    #
+    #      # Test the request body is the same as the stubbed body
+    #      stub.post('/bar', 'name=YK&word=call') { [200, {}, ''] }
+    #
+    #      # You can pass a proc as a stubbed body and check the request body in your way.
+    #      # In this case, the proc should return true or false.
+    #      stub.post('/foo', ->(request_body) do
+    #        JSON.parse(request_body).slice('name') == { 'name' => 'YK' } }) { [200, {}, '']
+    #      end
+    #
+    #       # You can set strict_mode to exactly match the stubbed requests.
+    #       stub.strict_mode = true
+    #     end
+    #   end
+    #
+    #   resp = test.get '/resource.json'
+    #   resp.body # => 'hi world'
+    #
+    #   resp = test.get '/showget'
+    #   resp.body # => 'get'
+    #
+    #   resp = test.get '/items/1'
+    #   resp.body # => 'showing item: 1'
+    #
+    #   resp = test.get '/items/2'
+    #   resp.body # => 'showing item: 2'
+    #
+    #   resp = test.post '/bar', 'name=YK&word=call'
+    #   resp.status # => 200
+    #
+    #   resp = test.post '/foo', JSON.dump(name: 'YK', created_at: Time.now)
+    #   resp.status # => 200
+    class Test < Faraday::Adapter
+      attr_accessor :stubs
+
+      # A stack of Stubs
+      class Stubs
+        class NotFound < StandardError
+        end
+
+        def initialize(strict_mode: false)
+          # { get: [Stub, Stub] }
+          @stack = {}
+          @consumed = {}
+          @strict_mode = strict_mode
+          @stubs_mutex = Monitor.new
+          yield(self) if block_given?
+        end
+
+        def empty?
+          @stack.empty?
+        end
+
+        # @param env [Faraday::Env]
+        def match(env)
+          request_method = env[:method]
+          return false unless @stack.key?(request_method)
+
+          stack = @stack[request_method]
+          consumed = (@consumed[request_method] ||= [])
+
+          @stubs_mutex.synchronize do
+            stub, meta = matches?(stack, env)
+            if stub
+              removed = stack.delete(stub)
+              consumed << removed unless removed.nil?
+              return stub, meta
+            end
+          end
+          matches?(consumed, env)
+        end
+
+        def get(path, headers = {}, &block)
+          new_stub(:get, path, headers, &block)
+        end
+
+        def head(path, headers = {}, &block)
+          new_stub(:head, path, headers, &block)
+        end
+
+        def post(path, body = nil, headers = {}, &block)
+          new_stub(:post, path, headers, body, &block)
+        end
+
+        def put(path, body = nil, headers = {}, &block)
+          new_stub(:put, path, headers, body, &block)
+        end
+
+        def patch(path, body = nil, headers = {}, &block)
+          new_stub(:patch, path, headers, body, &block)
+        end
+
+        def delete(path, headers = {}, &block)
+          new_stub(:delete, path, headers, &block)
+        end
+
+        def options(path, headers = {}, &block)
+          new_stub(:options, path, headers, &block)
+        end
+
+        # Raises an error if any of the stubbed calls have not been made.
+        def verify_stubbed_calls
+          failed_stubs = []
+          @stack.each do |method, stubs|
+            next if stubs.empty?
+
+            failed_stubs.concat(
+              stubs.map do |stub|
+                "Expected #{method} #{stub}."
+              end
+            )
+          end
+          raise failed_stubs.join(' ') unless failed_stubs.empty?
+        end
+
+        # Set strict_mode. If the value is true, this adapter tries to find matched requests strictly,
+        # which means that all of a path, parameters, and headers must be the same as an actual request.
+        def strict_mode=(value)
+          @strict_mode = value
+          @stack.each_value do |stubs|
+            stubs.each do |stub|
+              stub.strict_mode = value
+            end
+          end
+        end
+
+        protected
+
+        def new_stub(request_method, path, headers = {}, body = nil, &block)
+          normalized_path, host =
+            if path.is_a?(Regexp)
+              path
+            else
+              [
+                Faraday::Utils.normalize_path(path),
+                Faraday::Utils.URI(path).host
+              ]
+            end
+          path, query = normalized_path.respond_to?(:split) ? normalized_path.split('?') : normalized_path
+          headers = Utils::Headers.new(headers)
+
+          stub = Stub.new(host, path, query, headers, body, @strict_mode, block)
+          (@stack[request_method] ||= []) << stub
+        end
+
+        # @param stack [Hash]
+        # @param env [Faraday::Env]
+        def matches?(stack, env)
+          stack.each do |stub|
+            match_result, meta = stub.matches?(env)
+            return stub, meta if match_result
+          end
+          nil
+        end
+      end
+
+      # Stub request
+      Stub = Struct.new(:host, :path, :query, :headers, :body, :strict_mode, :block) do
+        # @param env [Faraday::Env]
+        def matches?(env)
+          request_host = env[:url].host
+          request_path = Faraday::Utils.normalize_path(env[:url].path)
+          request_headers = env.request_headers
+          request_body = env[:body]
+
+          # meta is a hash used as carrier
+          # that will be yielded to consumer block
+          meta = {}
+          [(host.nil? || host == request_host) &&
+            path_match?(request_path, meta) &&
+            params_match?(env) &&
+            body_match?(request_body) &&
+            headers_match?(request_headers), meta]
+        end
+
+        def path_match?(request_path, meta)
+          if path.is_a?(Regexp)
+            !!(meta[:match_data] = path.match(request_path))
+          else
+            path == request_path
+          end
+        end
+
+        # @param env [Faraday::Env]
+        def params_match?(env)
+          request_params = env[:params]
+          params = env.params_encoder.decode(query) || {}
+
+          if strict_mode
+            return Set.new(params) == Set.new(request_params)
+          end
+
+          params.keys.all? do |key|
+            request_params[key] == params[key]
+          end
+        end
+
+        def headers_match?(request_headers)
+          if strict_mode
+            headers_with_user_agent = headers.dup.tap do |hs|
+              # NOTE: Set User-Agent in case it's not set when creating Stubs.
+              #       Users would not want to set Faraday's User-Agent explicitly.
+              hs[:user_agent] ||= Connection::USER_AGENT
+            end
+            return Set.new(headers_with_user_agent) == Set.new(request_headers)
+          end
+
+          headers.keys.all? do |key|
+            request_headers[key] == headers[key]
+          end
+        end
+
+        def body_match?(request_body)
+          return true if body.to_s.empty?
+
+          case body
+          when Proc
+            body.call(request_body)
+          else
+            request_body == body
+          end
+        end
+
+        def to_s
+          "#{path} #{body}"
+        end
+      end
+
+      def initialize(app, stubs = nil, &block)
+        super(app)
+        @stubs = stubs || Stubs.new
+        configure(&block) if block
+      end
+
+      def configure
+        yield(stubs)
+      end
+
+      # @param env [Faraday::Env]
+      def call(env)
+        super
+
+        env.request.params_encoder ||= Faraday::Utils.default_params_encoder
+        env[:params] = env.params_encoder.decode(env[:url].query) || {}
+        stub, meta = stubs.match(env)
+
+        unless stub
+          raise Stubs::NotFound, "no stubbed request for #{env[:method]} " \
+                                 "#{env[:url]} #{env[:body]} #{env[:headers]}"
+        end
+
+        block_arity = stub.block.arity
+        params = if block_arity >= 0
+                   [env, meta].take(block_arity)
+                 else
+                   [env, meta]
+                 end
+
+        timeout = request_timeout(:open, env[:request])
+        timeout ||= request_timeout(:read, env[:request])
+
+        status, headers, body =
+          if timeout
+            ::Timeout.timeout(timeout, Faraday::TimeoutError) do
+              stub.block.call(*params)
+            end
+          else
+            stub.block.call(*params)
+          end
+
+        # We need to explicitly pass `reason_phrase = nil` here to avoid keyword args conflicts.
+        #   See https://github.com/lostisland/faraday/issues/1444
+        # TODO: remove `nil` explicit reason_phrase once Ruby 3.0 becomes minimum req. version
+        save_response(env, status, body, headers, nil)
+
+        @app.call(env)
+      end
+    end
+  end
+end
+
+Faraday::Adapter.register_middleware(test: Faraday::Adapter::Test)

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.12.2/lib/faraday/adapter.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Faraday
+  # Base class for all Faraday adapters. Adapters are
+  # responsible for fulfilling a Faraday request.
+  class Adapter
+    extend MiddlewareRegistry
+
+    CONTENT_LENGTH = 'Content-Length'
+
+    # This module marks an Adapter as supporting parallel requests.
+    module Parallelism
+      attr_writer :supports_parallel
+
+      def supports_parallel?
+        @supports_parallel
+      end
+
+      def inherited(subclass)
+        super
+        subclass.supports_parallel = supports_parallel?
+      end
+    end
+
+    extend Parallelism
+    self.supports_parallel = false
+
+    def initialize(_app = nil, opts = {}, &block)
+      @app = lambda(&:response)
+      @connection_options = opts
+      @config_block = block
+    end
+
+    # Yields or returns an adapter's configured connection. Depends on
+    # #build_connection being defined on this adapter.
+    #
+    # @param env [Faraday::Env, Hash] The env object for a faraday request.
+    #
+    # @return The return value of the given block, or the HTTP connection object
+    #         if no block is given.
+    def connection(env)
+      conn = build_connection(env)
+      return conn unless block_given?
+
+      yield conn
+    end
+
+    # Close any persistent connections. The adapter should still be usable
+    # after calling close.
+    def close
+      # Possible implementation:
+      #   @app.close if @app.respond_to?(:close)
+    end
+
+    def call(env)
+      env.clear_body if env.needs_body?
+      env.response = Response.new
+    end
+
+    private
+
+    def save_response(env, status, body, headers = nil, reason_phrase = nil, finished: true)
+      env.status = status
+      env.body = body
+      env.reason_phrase = reason_phrase&.to_s&.strip
+      env.response_headers = Utils::Headers.new.tap do |response_headers|
+        response_headers.update headers unless headers.nil?
+        yield(response_headers) if block_given?
+      end
+
+      env.response.finish(env) unless env.parallel? || !finished
+      env.response
+    end
+
+    # Fetches either a read, write, or open timeout setting. Defaults to the
+    # :timeout value if a more specific one is not given.
+    #
+    # @param type [Symbol] Describes which timeout setting to get: :read,
+    #                      :write, or :open.
+    # @param options [Hash] Hash containing Symbol keys like :timeout,
+    #                       :read_timeout, :write_timeout, or :open_timeout
+    #
+    # @return [Integer, nil] Timeout duration in seconds, or nil if no timeout
+    #                        has been set.
+    def request_timeout(type, options)
+      key = TIMEOUT_KEYS.fetch(type) do
+        msg = "Expected :read, :write, :open. Got #{type.inspect} :("
+        raise ArgumentError, msg
+      end
+      options[key] || options[:timeout]
+    end
+
+    TIMEOUT_KEYS = {
+      read: :read_timeout,
+      open: :open_timeout,
+      write: :write_timeout
+    }.freeze
+  end
+end
+
+require 'faraday/adapter/test'

data/vendor/bundle/ruby/3.1.0/gems/faraday-2.12.2/lib/faraday/adapter_registry.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'monitor'
+
+module Faraday
+  # AdapterRegistry registers adapter class names so they can be looked up by a
+  # String or Symbol name.
+  class AdapterRegistry
+    def initialize
+      @lock = Monitor.new
+      @constants = {}
+    end
+
+    def get(name)
+      klass = @lock.synchronize do
+        @constants[name]
+      end
+      return klass if klass
+
+      Object.const_get(name).tap { |c| set(c, name) }
+    end
+
+    def set(klass, name = nil)
+      name ||= klass.to_s
+      @lock.synchronize do
+        @constants[name] = klass
+      end
+    end
+  end
+end