koine-rest_client 1.0.0

data/lib/koine/rest_client.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'httparty'
+require 'koine/url'
+require 'koine/rest_client/error'
+require 'koine/rest_client/version'
+require 'koine/rest_client/client'
+require 'koine/rest_client/async_builder'
+require 'koine/rest_client/async_queue'
+require 'koine/rest_client/response_parser'
+require 'koine/rest_client/bad_request_error'
+require 'koine/rest_client/not_found_error'
+require 'koine/rest_client/internal_server_error'
+require 'koine/rest_client/request'
+require 'koine/rest_client/adapters/http_party_adapter'
+
+module Koine
+  # The gem namespace
+  module RestClient
+  end
+end

data/lib/koine/rest_client/adapters/http_party_adapter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'httparty'
+
+module Koine
+  module RestClient
+    module Adapters
+      # adapter for HTTParty client
+      class HttpPartyAdapter
+        def initialize(http_party_client = HTTParty)
+          @client = http_party_client
+        end
+
+        def send_request(request)
+          send("send_#{request.method}", request)
+        end
+
+        private
+
+        def send_post(request)
+          @client.post(request.url, request.options)
+        end
+
+        def send_get(request)
+          @client.get(request.url, request.options)
+        end
+
+        def send_put(request)
+          @client.put(request.url, request.options)
+        end
+
+        def send_patch(request)
+          @client.patch(request.url, request.options)
+        end
+
+        def send_delete(request)
+          @client.delete(request.url, request.options)
+        end
+      end
+    end
+  end
+end

data/lib/koine/rest_client/async_builder.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Koine
+  module RestClient
+    # takes care of async requests
+    class AsyncBuilder
+      def initialize(client, response_parser, queue = AsyncQueue.new)
+        @client = client
+        @response_parser = response_parser
+        @queue = queue
+        @error_handler = proc do |error|
+          raise error
+        end
+      end
+
+      def get(*args, &block)
+        queue(:get, *args, &block)
+      end
+
+      def post(*args, &block)
+        queue(:post, *args, &block)
+      end
+
+      def put(*args, &block)
+        queue(:put, *args, &block)
+      end
+
+      def patch(*args, &block)
+        queue(:patch, *args, &block)
+      end
+
+      def delete(*args, &block)
+        queue(:delete, *args, &block)
+      end
+
+      def parsed_responses
+        blocks = @queue.map { |_request, block| block }
+        threads = @queue.map do |request|
+          Thread.new { @client.perform_request(request) }
+        end
+        @queue.clear
+        responses = threads.map(&:value)
+        parse_responses(responses, blocks)
+      end
+
+      def on_error(&block)
+        @error_handler = block
+      end
+
+      private
+
+      def parse_responses(responses, blocks)
+        responses.map.with_index do |response, index|
+          block = blocks[index]
+          begin
+            @response_parser.parse(response, &block)
+          rescue StandardError => exception
+            @error_handler.call(exception)
+          end
+        end
+      end
+
+      def queue(type, *args, &block)
+        request = @client.__send__("create_#{type}_request", *args)
+        @queue.push(request, &block)
+      end
+    end
+  end
+end

data/lib/koine/rest_client/async_queue.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Koine
+  module RestClient
+    # queue for async requests
+    class AsyncQueue
+      def initialize
+        @items = []
+      end
+
+      def push(item, &block)
+        @items.push([item, block])
+      end
+
+      def each
+        @items.each do |item|
+          yield(item[0], item[1])
+        end
+      end
+
+      def map
+        @items.map do |item|
+          yield(item[0], item[1])
+        end
+      end
+
+      def clear
+        @items.clear
+      end
+
+      def to_a
+        @items.to_a
+      end
+    end
+  end
+end

data/lib/koine/rest_client/bad_request_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Koine
+  module RestClient
+    # bad request error
+    class BadRequestError < Error
+    end
+  end
+end

data/lib/koine/rest_client/client.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# :reek:DataClump
+# :reek:FeatureEnvy
+module Koine
+  module RestClient
+    class Client
+      def initialize(
+        adapter: Adapters::HttpPartyAdapter.new,
+        response_parser: ResponseParser.new,
+        base_request: Request.new
+      )
+        @adapter = adapter
+        @response_parser = response_parser
+        @request = base_request
+      end
+
+      def get(path, query = {}, options = {}, &block)
+        request = create_get_request(path, query, options)
+        response = perform_request(request)
+        parse_response(response, &block)
+      end
+
+      def create_get_request(path, query = {}, options = {})
+        create_request(:get, path, options.merge(query_params: query))
+      end
+
+      def post(path, body = {}, options = {}, &block)
+        request = create_post_request(path, body, options)
+        response = perform_request(request)
+        parse_response(response, &block)
+      end
+
+      def create_post_request(path, body = {}, options = {})
+        create_request(:post, path, options.merge(body: body))
+      end
+
+      def put(path, body = {}, options = {}, &block)
+        request = create_put_request(path, body, options)
+        response = perform_request(request)
+        parse_response(response, &block)
+      end
+
+      def create_put_request(path, body = {}, options = {})
+        create_request(:put, path, options.merge(body: body))
+      end
+
+      def patch(path, body = {}, options = {}, &block)
+        request = create_patch_request(path, body, options)
+        response = perform_request(request)
+        parse_response(response, &block)
+      end
+
+      def create_patch_request(path, body = {}, options = {})
+        create_request(:patch, path, options.merge(body: body))
+      end
+
+      def delete(path, body = {}, options = {}, &block)
+        request = create_delete_request(path, body, options)
+        response = perform_request(request)
+        parse_response(response, &block)
+      end
+
+      def create_delete_request(path, body = {}, options = {})
+        create_request(:delete, path, options.merge(body: body))
+      end
+
+      def async
+        builder = AsyncBuilder.new(self, @response_parser)
+        yield(builder)
+        builder.parsed_responses
+      end
+
+      def perform_request(request)
+        @adapter.send_request(request)
+      end
+
+      private
+
+      def create_request(method, path, options = {})
+        options = options.merge(method: method, path: path)
+        @request.with_added_options(options)
+      end
+
+      def parse_response(response, &block)
+        @response_parser.parse(response, &block)
+      end
+    end
+  end
+end

data/lib/koine/rest_client/error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Koine
+  module RestClient
+    # base class for http errors
+    class Error < StandardError
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+    end
+  end
+end

data/lib/koine/rest_client/internal_server_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Koine
+  module RestClient
+    # internal server error
+    class InternalServerError < Error
+    end
+  end
+end

data/lib/koine/rest_client/not_found_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Koine
+  module RestClient
+    # not found error
+    class NotFoundError < Error
+    end
+  end
+end

data/lib/koine/rest_client/request.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Koine
+  module RestClient
+    # request object
+    # :reek:TooManyInstanceVariables
+    class Request
+      attr_reader :method
+      attr_reader :base_url
+      attr_reader :path
+      attr_reader :headers
+      attr_reader :query_params
+      attr_reader :body
+
+      def initialize(base_url: '', query_params: {}, path: '', headers: {}, method: 'get')
+        @method = method
+        @base_url = base_url
+        @path = path
+        @query_params = query_params
+        @headers = headers
+      end
+
+      def with_method(method)
+        new(:method, method)
+      end
+
+      def with_path(path)
+        new(:path, path)
+      end
+
+      def with_base_url(base_url)
+        new(:base_url, base_url)
+      end
+
+      def with_added_query_params(query_params)
+        new(:query_params, @query_params.merge(query_params).compact)
+      end
+
+      def with_added_headers(headers)
+        new(:headers, @headers.merge(headers).compact)
+      end
+
+      def with_body(body)
+        new(:body, body)
+      end
+
+      def url
+        url = "#{@base_url.delete_suffix('/')}/#{path.delete_prefix('/')}"
+        Url.new(url).with_query_params(query_params).to_s(unescape: ',')
+      end
+
+      def options
+        { body: body, headers: headers }.compact.reject do |_key, value|
+          value.empty?
+        end
+      end
+
+      # :reek:ManualDispatch
+      def with_added_options(options)
+        object = self
+        options.each do |key, value|
+          if respond_to?("with_#{key}")
+            object = object.send("with_#{key}", value)
+          end
+
+          if respond_to?("with_added_#{key}")
+            object = object.send("with_added_#{key}", value)
+          end
+        end
+        object
+      end
+
+      private
+
+      attr_writer :method
+      attr_writer :base_url
+      attr_writer :path
+      attr_writer :query_params
+      attr_writer :headers
+      attr_writer :body
+
+      # :reek:FeatureEnvy
+      def new(attribute, value)
+        dup.tap do |object|
+          object.send("#{attribute}=", value)
+          object.freeze
+        end
+      end
+    end
+  end
+end

data/lib/koine/rest_client/response_parser.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Koine
+  module RestClient
+    # either returns response or raises errors
+    class ResponseParser
+      def parse(response)
+        if block_given?
+          yield(response)
+        end
+
+        code = Integer(response.code)
+
+        if code.between?(200, 299)
+          return response.parsed_response
+        end
+
+        raise error_for_code(code), response
+      end
+
+      private
+
+      def error_for_code(code)
+        {
+          400 => BadRequestError,
+          404 => NotFoundError,
+          500 => InternalServerError
+        }.fetch(code) { Error }
+      end
+    end
+  end
+end

data/lib/koine/rest_client/rspec_mock_client.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Koine
+  module RestClient
+    # mock client
+    class RspecMockClient
+      attr_reader :client_mock
+
+      def initialize(rspec, response_parser: ResponseParser.new)
+        @client_mock = rspec.instance_double(Koine::RestClient::Client)
+        @builder = MockFactory.new(rspec, self)
+        @collected = []
+        @response_parser = response_parser
+        @error_handler = proc do |error|
+          raise error
+        end
+      end
+
+      def on_error(&block)
+        @error_handler = block
+      end
+
+      def mock
+        yield(@builder)
+      end
+
+      def get(*args, &block)
+        parse(@client_mock.get(*args), &block)
+      end
+
+      def post(*args, &block)
+        parse(@client_mock.post(*args), &block)
+      end
+
+      def put(*args, &block)
+        parse(@client_mock.put(*args), &block)
+      end
+
+      def patch(*args, &block)
+        parse(@client_mock.patch(*args), &block)
+      end
+
+      def delete(*args, &block)
+        parse(@client_mock.delete(*args), &block)
+      end
+
+      def async
+        @async = true
+        yield(self)
+        @async = false
+
+        responses = @collected.dup
+        @collected.clear
+        responses.map(&:parsed_response)
+      end
+
+      private
+
+      def parse(response, &block)
+        @response_parser.parse(response, &block).tap do |_parsed|
+          if @async
+            @collected << response
+          end
+        end
+      rescue StandardError => exception
+        unless @async
+          raise exception
+        end
+
+        @collected << MockResponse.new.tap do |new_response|
+          new_response.parsed_response = @error_handler.call(exception)
+        end
+      end
+    end
+
+    # mock response
+    class MockResponse
+      attr_accessor :code
+      attr_accessor :parsed_response
+    end
+
+    # mock factory
+    class MockFactory < SimpleDelegator
+      def initialize(rspec, client_proxy)
+        super(rspec)
+        @client_proxy = client_proxy
+      end
+
+      def get(*args)
+        create_mock(:get, *args)
+      end
+
+      def post(*args)
+        create_mock(:post, *args)
+      end
+
+      def put(*args)
+        create_mock(:put, *args)
+      end
+
+      def patch(*args)
+        create_mock(:patch, *args)
+      end
+
+      def delete(*args)
+        create_mock(:delete, *args)
+      end
+
+      def on_error(&block)
+        @client_proxy.on_error(&block)
+      end
+
+      private
+
+      def create_mock(method, *args)
+        allowed = allow(@client_proxy.client_mock).to receive(method)
+        MockBuilder.new(allowed).with(*args)
+      end
+    end
+
+    # mock builder
+    class MockBuilder
+      def initialize(mock)
+        @mock = mock
+      end
+
+      def with(*args)
+        @mock.with(*args)
+        self
+      end
+
+      def will_return(body: {}, code: 200)
+        response = MockResponse.new
+        response.parsed_response = body
+        response.code = code
+        if block_given?
+          response = yield(response)
+        end
+        @mock.and_return(response)
+        self
+      end
+
+      def on_error(&block)
+        @error_handler = block
+      end
+    end
+  end
+end