my_api_client 0.14.0.pre → 0.17.0

data/lib/my_api_client/errors.rb

@@ -4,6 +4,7 @@ module MyApiClient
   # The ancestor class for all API request error
   class Error < StandardError
     attr_reader :params
+
     delegate :metadata, to: :params
     alias to_bugsnag metadata
 
@@ -25,57 +26,4 @@ module MyApiClient
       { error: super, params: params }.inspect
     end
   end
-
-  NETWORK_ERRORS = [
-    Faraday::TimeoutError,
-    Faraday::ConnectionFailed,
-    Faraday::SSLError,
-    OpenSSL::SSL::SSLError,
-    Net::OpenTimeout,
-    Net::ReadTimeout,
-    SocketError,
-  ].freeze
-
-  # Raises it when occurred to some network error
-  class NetworkError < Error
-    attr_reader :original_error
-
-    # Initialize the error class
-    #
-    # @param params [MyApiClient::Params::Params]
-    #   The request and response parameters
-    # @param original_error [StandardError]
-    #   Some network error
-    def initialize(params, original_error)
-      @original_error = original_error
-      super params, original_error.message
-    end
-
-    # Returns contents as string for to be readable for human
-    #
-    # @return [String] Contents as string
-    def inspect
-      { error: original_error, params: params }.inspect
-    end
-
-    # Generate metadata for bugsnag.
-    #
-    # @return [Hash] Metadata for bugsnag
-    def metadata
-      super.merge(original_error: original_error.inspect)
-    end
-  end
-
-  # NOTE: The built-in error classes are following. Although they are prepared
-  #       to save the trouble of defining, but you can create any error classes
-  #       which inherit the ancestor error class.
-
-  # For 4xx client error
-  class ClientError < Error; end
-
-  # For 5xx server error
-  class ServerError < Error; end
-
-  # For API request limit error
-  class ApiLimitError < Error; end
 end

data/lib/my_api_client/errors/api_limit_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  # For API request limit error
+  class ApiLimitError < Error; end
+end

data/lib/my_api_client/errors/client_error.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  # For 4xx client error
+  class ClientError < Error
+    # 400 Bad Request
+    class BadRequest < ClientError; end
+
+    # 401 Unauthorized
+    class Unauthorized < ClientError; end
+
+    # 402 Payment Required
+    class PaymentRequired < ClientError; end
+
+    # 403 Forbidden
+    class Forbidden < ClientError; end
+
+    # 404 Not Found
+    class NotFound < ClientError; end
+
+    # 405 Method Not Allowed
+    class MethodNotAllowed < ClientError; end
+
+    # 406 Not Acceptable
+    class NotAcceptable < ClientError; end
+
+    # 407 Proxy Authentication Required
+    class ProxyAuthenticationRequired < ClientError; end
+
+    # 408 Request Timeout
+    class RequestTimeout < ClientError; end
+
+    # 409 Conflict
+    class Conflict < ClientError; end
+
+    # 410 Gone
+    class Gone < ClientError; end
+
+    # 411 Length Required
+    class LengthRequired < ClientError; end
+
+    # 412 Precondition Failed
+    class PreconditionFailed < ClientError; end
+
+    # 413 Payload Too Large
+    class RequestEntityTooLarge < ClientError; end
+
+    # 414 URI Too Long
+    class RequestUriTooLong < ClientError; end
+
+    # 415 Unsupported Media Type
+    class UnsupportedMediaType < ClientError; end
+
+    # 416 Range Not Satisfiable
+    class RequestedRangeNotSatisfiable < ClientError; end
+
+    # 417 Expectation Failed
+    class ExpectationFailed < ClientError; end
+
+    # 418 I'm a teapot
+    class IamTeapot < ClientError; end
+
+    # 421 Misdirected Request
+    class MisdirectedRequest < ClientError; end
+
+    # 422 Unprocessable Entity
+    class UnprocessableEntity < ClientError; end
+
+    # 423 Locked
+    class Locked < ClientError; end
+
+    # 424 Failed Dependency
+    class FailedDependency < ClientError; end
+
+    # 425 Too Early
+    class TooEarly < ClientError; end
+
+    # 426 Upgrade Required
+    class UpgradeRequired < ClientError; end
+
+    # 428 Precondition Required
+    class PreconditionRequired < ClientError; end
+
+    # 429 Too Many Requests
+    class TooManyRequests < ClientError; end
+
+    # 431 Request Header Fields Too Large
+    class RequestHeaderFieldsTooLarge < ClientError; end
+
+    # 451 Unavailable for Legal Reasons
+    class UnavailableForLegalReasons < ClientError; end
+  end
+end

data/lib/my_api_client/errors/network_error.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  NETWORK_ERRORS = [
+    Faraday::TimeoutError,
+    Faraday::ConnectionFailed,
+    Faraday::SSLError,
+    OpenSSL::SSL::SSLError,
+    Net::OpenTimeout,
+    Net::ReadTimeout,
+    SocketError,
+  ].freeze
+
+  # Raises it when occurred to some network error
+  class NetworkError < Error
+    attr_reader :original_error
+
+    # Initialize the error class
+    #
+    # @param params [MyApiClient::Params::Params]
+    #   The request and response parameters
+    # @param original_error [StandardError]
+    #   Some network error
+    def initialize(params, original_error)
+      @original_error = original_error
+      super params, original_error.message
+    end
+
+    # Returns contents as string for to be readable for human
+    #
+    # @return [String] Contents as string
+    def inspect
+      { error: original_error, params: params }.inspect
+    end
+
+    # Generate metadata for bugsnag.
+    #
+    # @return [Hash] Metadata for bugsnag
+    def metadata
+      super.merge(original_error: original_error.inspect)
+    end
+  end
+end

data/lib/my_api_client/errors/server_error.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  # For 5xx server error
+  class ServerError < Error
+    # 500 Internal Server Error
+    class InternalServerError < ServerError; end
+
+    # 501 Not Implemented
+    class NotImplemented < ServerError; end
+
+    # 502 Bad Gateway
+    class BadGateway < ServerError; end
+
+    # 503 Service Unavailable
+    class ServiceUnavailable < ServerError; end
+
+    # 504 Gateway Timeout
+    class GatewayTimeout < ServerError; end
+
+    # 505 HTTP Version Not Supported
+    class HttpVersionNotSupported < ServerError; end
+
+    # 506 Variant Also Negotiates
+    class VariantAlsoNegotiates < ServerError; end
+
+    # 507 Insufficient Storage
+    class InsufficientStorage < ServerError; end
+
+    # 508 Loop Detected
+    class LoopDetected < ServerError; end
+
+    # 509 Bandwidth Limit Exceeded
+    class BandwidthLimitExceeded < ServerError; end
+
+    # 510 Not Extended
+    class NotExtended < ServerError; end
+
+    # 511 Network Authentication Required
+    class NetworkAuthenticationRequired < ServerError; end
+  end
+end

data/lib/my_api_client/request.rb

@@ -1,41 +1,38 @@
 # frozen_string_literal: true
 
 module MyApiClient
-  # Description of Request
+  # Provides HTTP request method.
   module Request
-    HTTP_METHODS = %i[get post patch delete].freeze
-
-    HTTP_METHODS.each do |http_method|
-      class_eval <<~METHOD, __FILE__, __LINE__ + 1
-        # Executes HTTP request with #{http_method.upcase} method
-        #
-        # @param pathname [String]
-        #   Pathname of the request target URL.
-        #   It's joined with the defined `endpoint`.
-        # @param headers [Hash, nil]
-        #   Request headers.
-        # @param query [Hash, nil]
-        #   Query string.
-        # @param body [Hash, nil]
-        #   Request body. You should not specify it when use GET method.
-        # @return [Sawyer::Resouce]
-        #   Response body instance.
-        def #{http_method}(pathname, headers: nil, query: nil, body: nil)
-          query_strings = query.present? ? '?' + query&.to_query : ''
-          uri = URI.join(File.join(endpoint, pathname), query_strings)
-          response = call(:_request, :#{http_method}, uri, headers, body)
-          response.data
-        end
-      METHOD
-    end
-    alias put patch
+    include Basic
+    include Pagination
 
     private
 
-    # Executes HTTP request.
+    # Executes HTTP request with relative URI.
+    #
+    # @param http_method [Symbol]
+    #   HTTP method. e.g. `:get`, `:post`, `:put`, `:patch` and `:delete`.
+    # @param pathname [String]
+    #   Pathname of the request target URL.
+    #   It's joined with the defined by `endpoint`.
+    # @param headers [Hash, nil]
+    #   Request headers.
+    # @param query [Hash, nil]
+    #   Query string.
+    # @param body [Hash, nil]
+    #   Request body.
+    # @return [Sawyer::Response]
+    #   Response instance.
+    def _request_with_relative_uri(http_method, pathname, headers, query, body)
+      query_strings = query.present? ? '?' + query&.to_query : ''
+      uri = URI.join(File.join(endpoint, pathname), query_strings)
+      _request_with_absolute_uri(http_method, uri, headers, body)
+    end
+
+    # Executes HTTP request with absolute URI.
     #
     # @param http_method [Symbol]
-    #   HTTP method. e.g. `:get`, `:post`, `:patch` and `:delete`.
+    #   HTTP method. e.g. `:get`, `:post`, `:put`, `:patch` and `:delete`.
     # @param uri [URI]
     #   Request target URI including query strings.
     # @param headers [Hash, nil]
@@ -44,13 +41,11 @@ module MyApiClient
     #   Request body.
     # @return [Sawyer::Response]
     #   Response instance.
-    def _request(http_method, uri, headers, body)
-      request_params = Params::Request.new(http_method, uri, headers, body)
-      request_logger = Logger.new(logger, http_method, uri)
+    def _request_with_absolute_uri(http_method, uri, headers, body)
       Executor.call(
         instance: self,
-        request_params: request_params,
-        request_logger: request_logger,
+        request_params: Params::Request.new(http_method, uri, headers, body),
+        request_logger: Logger.new(logger, http_method, uri),
         faraday_options: faraday_options
       )
     end

data/lib/my_api_client/request/basic.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  module Request
+    # Provides basic HTTP request method.
+    module Basic
+      HTTP_METHODS = %i[get post put patch delete].freeze
+
+      HTTP_METHODS.each do |http_method|
+        class_eval <<~METHOD, __FILE__, __LINE__ + 1
+          # Executes HTTP request with #{http_method.upcase} method
+          #
+          # @param pathname [String]
+          #   Pathname of the request target URL.
+          #   It's joined with the defined by `endpoint`.
+          # @param headers [Hash, nil]
+          #   Request headers.
+          # @param query [Hash, nil]
+          #   Query string.
+          # @param body [Hash, nil]
+          #   Request body. You should not specify it when use GET method.
+          # @return [Sawyer::Resource]
+          #   Response body instance.
+          def #{http_method}(pathname, headers: nil, query: nil, body: nil)
+            response = call(:_request_with_relative_uri, :#{http_method}, pathname, headers, query, body)
+            response.data
+          end
+        METHOD
+      end
+    end
+  end
+end

data/lib/my_api_client/request/executor.rb

@@ -32,7 +32,7 @@ module MyApiClient
       def call
         request_logger.info('Start')
         response = api_request
-        request_logger.info("Duration #{response.timing} sec")
+        request_logger.info("Duration #{response.timing.in_milliseconds} msec")
         verify(response)
       rescue MyApiClient::Error => e
         request_logger.warn("Failure (#{e.message})")

data/lib/my_api_client/request/pagination.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module MyApiClient
+  module Request
+    # Provides enumerable HTTP request method.
+    module Pagination
+      # Executes HTTP request with GET method, for pagination API. Expects the
+      # pagination API to provide pagination links as part of the content of the response.
+      #
+      # @param pathname [String]
+      #   Pathname of the request target URL. It's joined with the defined by `endpoint`.
+      # @param paging [String]
+      #   Specify the pagination link path included in the response body as JsonPath expression
+      # @param headers [Hash, nil]
+      #   Request headers.
+      # @param query [Hash, nil]
+      #   Query string.
+      # @param body [Hash, nil]
+      #   Request body. You should not specify it when use GET method.
+      # @return [Enumerator::Lazy]
+      #   Yields the pagination API response.
+      def pageable_get(pathname, paging:, headers: nil, query: nil)
+        Enumerator.new do |y|
+          response = call(:_request_with_relative_uri, :get, pathname, headers, query, nil)
+          loop do
+            y << response.data
+
+            next_uri = JsonPath.new(paging).first(response.body)
+            break if next_uri.blank?
+
+            response = call(:_request_with_absolute_uri, :get, next_uri, headers, nil)
+          end
+        end.lazy
+      end
+
+      alias pget pageable_get
+    end
+  end
+end

data/lib/my_api_client/rspec/matchers/request_to.rb

@@ -8,10 +8,9 @@ RSpec::Matchers.define :request_to do |expected_method, expected_url|
   match do |api_request|
     disable_logging
     @expected = {
-      request_line: request_line(expected_method, expected_url),
+      request_line: request_line(expected_method, expected_url, expected_options[:query]),
       body: expected_options[:body],
       headers: expected_options[:headers],
-      query: expected_options[:query],
     }.compact
     @actual = {}
     sawyer = instance_double(Sawyer::Agent)
@@ -24,7 +23,6 @@ RSpec::Matchers.define :request_to do |expected_method, expected_url|
           request_line: request_line(method, @actual_schema_and_hostname + pathname),
           body: body,
           headers: options[:headers],
-          query: options[:query],
         }.compact
     end.and_return(dummy_response)
     safe_execution(api_request)
@@ -51,7 +49,8 @@ RSpec::Matchers.define :request_to do |expected_method, expected_url|
     nil
   end
 
-  def request_line(method, url)
+  def request_line(method, url, query = nil)
+    url += '?' + query.to_query if query.present?
     "#{method.upcase} #{url}"
   end