rest_api_builder 0.0.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e04eb4a2a88c29a02d4fc831018d118ce8cd570f7523625cc83bd155041734a
-  data.tar.gz: 1092c81256426cb4d0e590452c0831291b20697108a07358fe5efdc5761d74b0
+  metadata.gz: d192a166c3b73c990be9893ac5f08bfd601aed7c4cc9c8bd8419ce2fe20c32be
+  data.tar.gz: 9d9974f0d2451412333dec8979a8bcdd3268b7bba8d15f58d7ef9ce4ccb63f31
 SHA512:
-  metadata.gz: b494a395a84ce64096cbe07231457e742de4ddd812bdf092e00e717db0c078496c907d81d19e671f32ce484f8b6464e310aba16184c6ed4724d0c0c19f7a5749
-  data.tar.gz: 2626417df9c9241d33ac3e76b2a9a5f64638b6a0397785c470f921303fb47188ab606914fc4890b47aaf4fd4fdc6f96fe8c6569ac9a29f114b9854ef66d48c29
+  metadata.gz: 23676f348f1feb5cb3b6d66b452af4ced13358ceec0f91591279d0db73e48b02bb06e415252c2a08708afc12fc6916c2d679dcffef3b6f625b58e2194ef36077
+  data.tar.gz: ce0e28889a73b8cc2924cc855e3feef7da8dbbca0d78551ad5cfd5c23ade751ffd9e11b42af711d19826614993fa94fa31544c371221e617f94ad06ef3fe57d5

data/README.md

@@ -8,154 +8,339 @@ RestClient is great, but after building a few API clients with it you will almos
 - Handling and extracting details from non-200 responses
 - Creating testing interfaces for your API clients
 
-This library's tries to solve these and similar issues by providing a thin wrapper around [rest-client](https://github.com/rest-client/rest-client) and an optional [webmock](https://github.com/bblimke/webmock) testing interface for it.
+This library tries to solve these and similar issues by providing a set of self-contained helper methods to improve on [rest-client](https://github.com/rest-client/rest-client) features with an optional [WebMock](https://github.com/bblimke/webmock) testing interface.
 
 ## Installation
 ```
 gem install rest_api_builder
 ```
 
-## WebMock interface installation
-Simply require webmock interface before your test, for example in your `test_helper.rb`:
+## RestAPIBuilder::Request
+Main RestAPIBuilder module which includes various helper methods for parsing RestClient responses, catching errors and composing request details. `handle_*` and `compose_*` methods are intended to be used in conjunction, but you can use any of them in any combination without relying on the rest.
+
+```rb
+# Basic usage
+require 'rest_api_builder'
+include RestAPIBuilder::Request
+
+logger = Logger.new(STDOUT)
+response = handle_json_response(logger: logger) do
+  RestClient::Request.execute(
+    {
+      **compose_json_request_options(
+        base_url: 'https://api.github.com',
+        path: '/users/octocat/orgs',
+        method: :get
+      ),
+      log: logger
+    }
+  )
+end
+
+response[:success] # => true
+response[:status]  # => 200
+response[:body]    # => []
+```
+
+Included methods:
+
+### `#handle_response(options, &block)`
+Executes given block, expecting to receive RestClient::Response as a result.\
+Returns plain ruby hash with following keys: `:success, :status, :body, :headers`\
+This will gracefully handle non-200 responses, but will throw on any error without defined response(e.g server timeout)
+
+```rb
+require 'rest_api_builder'
+include RestAPIBuilder::Request
+
+# normal response
+response = handle_response do
+  RestClient::Request.execute(method: :get, url: 'https://api.github.com/users/octocat/orgs')
+end
+
+response[:success] # => true
+response[:status]  # => 200
+response[:body]    # => '[]'
+response[:headers] # => {:accept_ranges=>"bytes", :access_control_allow_origin=>"*", ...}
+
+# non-200 response that would result in RestClient::RequestFailed exception otherwise
+response = handle_response do
+  RestClient::Request.execute(method: :get, url: 'https://api.github.com/users/octocat/foobar')
+end
+
+response[:success] # => false
+response[:status]  # => 404
+response[:body]    # => "{\"message\":\"Not Found\",..."}"
+```
+
+#### Accepted Options:
+| Name   | Description |
+|--------|-------------|
+| logger | Any object with `<<` method, e.g `Logger` instance. Will be used to log *response* details in the same way that [RestClient's `log` option](https://github.com/rest-client/rest-client#logging) logs the request details. Optional |
+
+### `#handle_json_response(options, &block)`
+Behaves just like `#handle_response`, but will also attempt to decode response `:body`, returning it as is if a parsing error occurs.
+
+```rb
+require 'rest_api_builder'
+include RestAPIBuilder::Request
+
+# decodes JSON response body
+response = handle_json_response do
+  RestClient::Request.execute(method: :get, url: 'https://api.github.com/users/octocat/orgs')
+end
+
+response[:success] # => true
+response[:status]  # => 200
+response[:body]    # => []
+
+# returns body as is if it cannot be decoded
+response = handle_json_response do
+  RestClient::Request.execute(method: :get, url: 'https://github.com/foo/bar/test')
+end
+
+response[:success] # => false
+response[:status]  # => 404
+response[:body]    # => "Not Found"
+```
+
+### `handle_response_error(&block)`
+Low-level API.\
+You can use this method if you want to work with regular `RestClient::Response` objects directly(e.g when using `block_response` or `raw_response` options). This will handle non-200 exceptions but will not do anything else.\
+Returns plain ruby hash with `:success` and `:raw_response` keys.
+
+```rb
+require 'rest_api_builder'
+include RestAPIBuilder::Request
+
+# returns RestClient::Response as :raw_response
+response = handle_response_error do
+  RestClient::Request.execute(method: :get, url: 'https://api.github.com/users/octocat/orgs')
+end
+
+response[:success]      # => true
+response[:raw_response] # => <RestClient::Response 200 "[]">
+
+# handles non-200 responses
+response = handle_response_error do
+  RestClient::Request.execute(
+    method: :get,
+    url: 'https://api.github.com/users/octocat/foobar',
+    raw_response: true
+  )
+end
+
+response[:success]      # => false
+response[:raw_response] # => <RestClient::RawResponse @code=404, @file=#<Tempfile...>>
+```
+
+### `#compose_request_options(options)`
+Provides a more consistent interface for `RestClient::Request#execute`.\
+This method returns a hash of options which you can then pass to `RestClient::Request#execute`.
+
+```rb
+require 'rest_api_builder'
+include RestAPIBuilder::Request
+
+# basic usage
+response = RestClient::Request.execute(
+  compose_request_options(
+    base_url: 'https://api.github.com',
+    path: '/users/octocat/orgs',
+    method: :get
+  )
+)
+
+response.request.url # => "https://api.github.com/users/octocat/orgs"
+response.body        # => '[]'
+
+# advanced options
+result = handle_response_error do
+  RestClient::Request.execute(
+    compose_request_options(
+      base_url: 'https://api.github.com',
+      path: '/users/octocat/orgs',
+      method: :post,
+      body: 'Hello',
+      headers: { content_type: 'foobar' },
+      query: { foo: 'bar' }
+    )
+  )
+end
+request = result[:raw_response].request
+
+request.url     # => "https://api.github.com/users/octocat/orgs?foo=bar"
+request.headers # => {:content_type=>"foobar"}
+request.payload # => <RestClient::Payload 'Hello'>
+```
+
+#### Accepted Options:
+| Name     | Description |
+|----------|-------------|
+| base_url | Base URL of the request. Required. |
+| method   | HTTP method of the request(e.g :get, :post, :patch). Required. |
+| path     | Path to be appended to `base_url`. Optional. |
+| body     | Request Body. Optional. |
+| headers  | Request Headers. Optional. |
+| query    | Query hash to be appended to the resulting url. Optional. |
+
+### `#compose_json_request_options(options)`
+Same as `compose_request_options` but will also convert provided `body`(if any) to JSON and append `Content-Type: 'application/json'` to `headers`
+
 ```rb
-  # test_helper.rb
-  require "webmock"
-  require "rest_api_builder/webmock_request_expectations"
+require 'rest_api_builder'
+include RestAPIBuilder::Request
+
+# basic usage
+result = handle_response_error do
+  RestClient::Request.execute(
+    compose_json_request_options(
+      base_url: 'https://api.github.com',
+      path: '/users/octocat/orgs',
+      method: :post,
+      body: {a: 1}
+    )
+  )
+end
+request = result[:raw_response].request
+
+request.headers # => {:content_type=>:json}
+request.payload # => <RestClient::Payload "{\"a\":1}">
+```
+
+## RestAPIBuilder::APIClient
 
-  WebMock.enable!
+### `#define_resource_shortcuts(resources, resources_scope:, init_with:)`
+Dynamically defines attribute readers for given resources
 
-  # my_spec.rb 
-  require 'test_helper'
+```rb
+require 'rest_api_builder'
+
+module ReadmeExamples
+  module Resources
+    class Octocat
+      def orgs
+        RestClient::Request.execute(method: :get, url: 'https://api.github.com/users/octocat/orgs')
+      end
+    end
+  end
 
-  describe 'my test' do
-    it 'performs a request' do
-      RestAPIBuilder::WebMockRequestExpectations.expect_execute(...).to_return(body: "hi!")
-      result = RestAPIBuilder::Request.execute(...)
+  class APIClient
+    include RestAPIBuilder::APIClient
 
-      # some assertions
+    def initialize
+      define_resource_shortcuts(
+        [:octocat],
+        resources_scope: ReadmeExamples::Resources,
+        init_with: ->(resource_class) { resource_class.new }
+      )
     end
   end
+end
+
+
+GITHUB_API = ReadmeExamples::APIClient.new
+
+response = GITHUB_API.octocat.orgs
+response.body # => '[]'
+response.code # => 200
 ```
 
-`RestAPIBuilder::WebMockRequestExpectations` expects that you have WebMock installed as a dependency.
+#### Accepted Arguments:
+| Name            | Description |
+|-----------------|-------------|
+| resources       | Array of resources to define shortcuts for |
+| resources_scope | Module or String(path to Module) within which resource classes are contained |
+| init_with       | Lambda which will be called for each resource class. The result will be returned from the defined shortcut. **Note:** `init_with` lambda is only called once so resource class must be able to function as a singleton. |
+
+## RestAPIBuilder::WebMockRequestExpectations
+Optional wrapper around WebMock mocking interface with various improvements. This module must be required explicitly and expects [WebMock](https://github.com/bblimke/webmock) to be installed as a dependency in your project.
 
-## Usage
+### `#expect_execute(options)`
+Defines a request expectation using WebMock's `stub_request`.
 ```rb
-require "rest_api_builder"
-
-Request = RestAPIBuilder::Request
-
-# Simple request:
-response = Request.execute(base_url: "example.com", method: :get)
-response[:success] #=> true
-response[:status]  #=> 200
-response[:body]    #=> "<!doctype html>\n<html>..."
-response[:headers] #=> {:accept_ranges=>"bytes", ...}
-
-# Non-200 responses:
-response = Request.execute(base_url: "example.com", path: "/foo", method: :get)
-response[:success] #=> false
-response[:status]  #=> 404
-response[:body]    #=> "<!doctype html>\n<html>..."
-
-# JSON requests:
-response = Request.json_execute(base_url: "api.github.com", path: "/users/octocat/orgs", method: :get)
-response[:success] #=> true
-response[:body]    #=> []
+require 'rest_api_builder'
+require 'rest_api_builder/webmock_request_expectations'
+include RestAPIBuilder::Request
+include RestAPIBuilder::WebMockRequestExpectations
+
+# basic usage with regular webmock interface
+expect_execute(
+  base_url: 'https://api.github.com',
+  path: '/users/octocat/orgs',
+  method: :post
+).with(body: {foo: 'bar'}).to_return(body: '[hello]')
+
+response = RestClient::Request.execute(
+  compose_request_options(
+    base_url: 'https://api.github.com',
+    path: '/users/octocat/orgs',
+    method: :post,
+    body: {foo: 'bar'}
+  )
+)
+
+response.body # => '[hello]'
+
+# using expect_execute's request and response options
+expect_execute(
+  base_url: 'https://api.github.com',
+  path: '/users/octocat',
+  method: :post,
+  # matches request body and query hashes partially by default
+  request: { body: {foo: 'bar'}, query: {a: 1, b: 2} },
+  response: { body: 'hello' }
+)
+
+response = RestClient::Request.execute(
+  compose_request_options(
+    base_url: 'https://api.github.com',
+    path: '/users/octocat',
+    method: :post,
+    body: { foo: 'bar', bar: 'baz' }, 
+    query: { a: 1, b: 2 }
+  )
+)
+
+response.body # => 'hello'
 ```
 
-## WebMock Expectations
+#### Accepted Options:
+| Name     | Description |
+|----------|-------------|
+| base_url | Base URL of the request expectation. Required. |
+| path     | HTTP method of the request. Required. |
+| method   | Path to be appended to `base_url`. Regular expressions are also supported. Optional. |
+| request  | Hash of options which will be passed to WebMock's `with` method with following changes: `body` hash is converted to `hash_including` expectation and `query` hash values are transformed to strings and then it's converted into `hash_including` expectation. Optional  |
+| response | Hash of options which will be passed to WebMock's `to_return` method unchanged. Optional |
+
+### `#expect_json_execute(options)`
+Same as `expect_execute` but will also call JSON encode on `response.body`(if one is provided).
+
 ```rb
-require "rest_api_builder"
-require "webmock"
-require "rest_api_builder/webmock_request_expectations"
-
-WebMock.disable_net_connect!
-
-Request = RestAPIBuilder::Request
-Expectations = RestAPIBuilder::WebMockRequestExpectations
-
-# Simple expectation
-Expectations.expect_execute(base_url: "test.com", method: :get)
-response = Request.execute(base_url: "test.com", method: :get)
-
-response[:success] #=> true
-response[:status]  #=> 200
-response[:body]    #=> ''
-response[:headers] #=> {}
-
-# Specifying expectation details with WebMock::Request methods
-Expectations
-  .expect_execute(base_url: "test.com", method: :get)
-  .to_return(status: 404, body: "not found")
-response = Request.execute(base_url: "test.com", method: :get)
-
-response[:success] #=> false
-response[:status]  #=> 404
-response[:body]    #=> "not found"
-
-# Specifying expectation details with :request and :response options
-Expectations.expect_execute(
-  base_url: "test.com", 
-  method: :post, 
-  response: { body: 'hello' }, 
-  request: { body: WebMock::API.hash_including({foo: "bar"}) }
+require 'rest_api_builder'
+require 'rest_api_builder/webmock_request_expectations'
+include RestAPIBuilder::Request
+include RestAPIBuilder::WebMockRequestExpectations
+
+expect_json_execute(
+  base_url: 'https://api.github.com',
+  path: '/users/octocat/orgs',
+  method: :get,
+  response: { body: { foo: 'bar' } }
 )
-response = Request.json_execute(base_url: "test.com", method: :post, body: {foo: "bar"})
-response[:success] #=> true
-response[:body]    #=> 'hello'
 
-Request.json_execute(base_url: "test.com", method: :post, body: {bar: "baz"}) # => Raises WebMock::NetConnectNotAllowedError
-
-# Using #expect_json_execute
-Expectations.expect_json_execute(
-  base_url: "test.com", 
-  method: :get, 
-  response: { body: {hi: 'hello'} }
+response = RestClient::Request.execute(
+  compose_request_options(
+    base_url: 'https://api.github.com',
+    path: '/users/octocat/orgs',
+    method: :get
+  )
 )
-response = Request.execute(base_url: "test.com", method: :get)
-response[:success] #=> true
-response[:body]    #=> "{\"hi\":\"hello\"}"
+
+response.body # => "{\"foo\":\"bar\"}"
 ```
 
-## Request API
-### RestAPIBuilder::Request.execute(options)
-Performs a HTTP request via `RestClient::Request.execute`.\
-Returns ruby hash with following keys: `:success`, `:status`, `:body`, `:headers`\
-Does not throw on non-200 responses like RestClient does, but will throw on any error without defined response(e.g server timeout)
-
-#### Options:
-* **base_url**: Base URL of the request. Required.
-* **method**: HTTP method of the request(e.g :get, :post, :patch). Required.
-* **path**: Path to be appended to the :base_url. Optional.
-* **body**: Request Body. Optional.
-* **headers**: Request Headers. Optional.
-* **query**: Query hash to be appended to the resulting url. Optional.
-* **logger**: A `Logger` instance to be passed to RestClient in `log` option. Will also log response details as RestClient does not do this by default. Optional
-* **parse_json**: Boolean. If `true`, will attempt to parse the response body as JSON. Will return the response body unchanged if it does not contain valid JSON. `false` by default.
-* **raw_response**: Boolean. If `true`, the response returned by RestClient will not be parsed into {:status, :body, :headers}, but instead returned as {:raw_response}. `false` by default.
-* **rest_client_options**: Any additional options to be passed to `RestClient::Request.execute` unchanged. **Any option set here will completely overwrite all custom options**. For example, if you call `RestAPIBuilder::Request.execute(method: :post, rest_client_options: {method: :get})`, the resulting request will be sent as GET. Optional.
-
-### RestAPIBuilder::Request.json_execute(options)
-A convenience shortcut for `#execute` which will also:
-- Add `Content-Type: 'application/json'` to request `headers`
-- Convert request `body` to JSON
-- Set `parse_json` option to `true`
-
-
-## WebMockRequestExpectations API
-### RestAPIBuilder::WebMockRequestExpectations.expect_execute(options)
-Defines a request expectation using WebMock's `stub_request`. Returns an instance of `WebMock::RequestStub` on which methods such as `with`, `to_return`, `to_timeout` can be called
-
-#### Options:
-* **base_url**: Base URL of the request. Required.
-* **method**: HTTP method of the request(e.g :get, :post, :patch). Required.
-* **path**: Path to be appended to the :base_url. Optional.
-* **request**: request details which will be passed to `WebMock::RequestStub#with` if provided. Optional
-* **response**: response details which will be passed to `WebMock::RequestStub#to_return` if provided. Optional
-
-### RestAPIBuilder::WebMockRequestExpectations.expect_json_execute(options)
-A convenience shortcut for `#json_execute` which will convert `request[:body]` to JSON if it's provided
 
 ## License
-MIT
+MIT

data/lib/rest_api_builder.rb

@@ -1,21 +1,3 @@
 require 'forwardable'
 require 'rest_api_builder/request'
-require 'rest_api_builder/request_options'
-require 'rest_api_builder/response_handler'
-
-module RestAPIBuilder
-  extend Forwardable
-
-  def_delegator :request_options, :compose, :compose_request_options
-  def_delegator :request_options, :compose_json, :compose_json_request_options
-
-  def_delegators :response_handler, :handle_response, :handle_json_response, :handle_response_error
-
-  def request_options
-    RequestOptions.new
-  end
-
-  def response_handler
-    ResponseHandler.new
-  end
-end
+require 'rest_api_builder/api_client'

data/lib/rest_api_builder/api_client.rb

@@ -0,0 +1,16 @@
+require 'rest_api_builder/helpers/string_helper'
+
+module RestAPIBuilder
+  module APIClient
+    def define_resource_shortcuts(resources, resources_scope:, init_with:)
+      resources.each do |name|
+        class_name = RestAPIBuilder::Helpers::StringHelper.camelize(name.to_s)
+        resource_class = Object.const_get("#{resources_scope}::#{class_name}")
+
+        define_singleton_method(name) do
+          init_with.call(resource_class)
+        end
+      end
+    end
+  end
+end

data/lib/rest_api_builder/helpers/string_helper.rb

@@ -0,0 +1,15 @@
+module RestAPIBuilder
+  module Helpers
+    module StringHelper
+      module_function
+
+      # From https://apidock.com/rails/String/camelize
+      def camelize(string)
+        string
+          .sub(/^[a-z\d]*/, &:capitalize)
+          .gsub(/(?:_|(\/))([a-z\d]*)/) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" }
+          .gsub("/", "::")
+      end
+    end
+  end
+end

data/lib/rest_api_builder/helpers/url_helper.rb

@@ -0,0 +1,15 @@
+module RestAPIBuilder
+  module Helpers
+    module UrlHelper
+      module_function
+
+      def full_url(url, path)
+        if path
+          File.join(url, path)
+        else
+          url
+        end
+      end
+    end
+  end
+end

data/lib/rest_api_builder/request.rb

@@ -1,46 +1,18 @@
-require 'rest-client'
+require 'forwardable'
+require 'rest_api_builder/request/request_options'
+require 'rest_api_builder/request/response_handler'
 
 module RestAPIBuilder
-  class RequestSingleton
-    def json_execute(headers: {}, body: nil, **options)
-      headers = headers.merge(content_type: :json)
-      body &&= JSON.generate(body)
-      execute(**options, parse_json: true, headers: headers, body: body)
-    end
+  module Request
+    extend Forwardable
 
-    def execute(
-      base_url:,
-      method:,
-      body: nil,
-      headers: {},
-      query: nil,
-      path: nil,
-      logger: nil,
-      parse_json: false,
-      raw_response: false,
-      rest_client_options: {}
-    )
-      options = RequestOptions.new.compose(
-        base_url: base_url,
-        method: method,
-        body: body,
-        headers: headers,
-        query: query,
-        path: path
-      )
+    def_delegators RestAPIBuilder::Request::RequestOptions,
+                   :compose_request_options,
+                   :compose_json_request_options
 
-      response_handler = ResponseHandler.new
-      execute_request = proc { RestClient::Request.execute(**options, log: logger, **rest_client_options) }
-
-      if raw_response
-        response_handler.handle_response_error(&execute_request)
-      elsif parse_json
-        response_handler.handle_json_response(logger: logger, &execute_request)
-      else
-        response_handler.handle_response(logger: logger, &execute_request)
-      end
-    end
+    def_delegators RestAPIBuilder::Request::ResponseHandler,
+                   :handle_response,
+                   :handle_json_response,
+                   :handle_response_error
   end
-
-  Request = RequestSingleton.new
 end

data/lib/rest_api_builder/request/request_options.rb

@@ -0,0 +1,37 @@
+require 'rest_api_builder/helpers/url_helper'
+
+module RestAPIBuilder
+  module Request
+    module RequestOptions
+      extend RestAPIBuilder::Helpers::UrlHelper
+
+      module_function
+
+      def compose_request_options(base_url:, method:, path: nil, body: nil, headers: {}, query: nil)
+        if method == :get && body
+          raise ArgumentError, 'GET requests do not support body'
+        end
+
+        headers = headers.merge(params: query) if query
+
+        {
+          method: method,
+          url: full_url(base_url, path),
+          payload: body,
+          headers: headers
+        }
+      end
+
+      def compose_json_request_options(**options)
+        result = compose_request_options(**options)
+        headers = result[:headers]
+        payload = result[:payload]
+
+        result.merge(
+          headers: headers.merge(content_type: :json),
+          payload: payload && JSON.generate(payload)
+        )
+      end
+    end
+  end
+end

data/lib/rest_api_builder/request/response_handler.rb

@@ -0,0 +1,48 @@
+require 'rest-client'
+
+module RestAPIBuilder
+  module Request
+    module ResponseHandler
+      module_function
+
+      def handle_json_response(**options, &block)
+        result = handle_response(**options, &block)
+        result.merge(body: parse_json(result[:body]))
+      end
+
+      def handle_response(logger: nil, &block)
+        result = parse_response(**handle_response_error(&block))
+        maybe_log_result(result, logger: logger)
+        result
+      end
+
+      def handle_response_error
+        response = yield
+        { raw_response: response, success: true }
+      rescue RestClient::RequestFailed => e
+        raise e unless e.response
+
+        { raw_response: e.response, success: false }
+      end
+
+      def parse_response(raw_response:, success:)
+        {
+          success: success,
+          status: raw_response.code,
+          body: raw_response.body,
+          headers: raw_response.headers
+        }
+      end
+
+      def maybe_log_result(result, logger:)
+        logger && logger << "# => Response: #{result}\n"
+      end
+
+      def parse_json(json)
+        JSON.parse(json)
+      rescue JSON::ParserError
+        json
+      end
+    end
+  end
+end

data/lib/rest_api_builder/webmock_request_expectations.rb

@@ -1,28 +1,10 @@
-require 'webmock'
-require 'rest_api_builder/url_helper'
+require 'forwardable'
+require 'rest_api_builder/webmock_request_expectations/expectations'
 
 module RestAPIBuilder
-  class WebMockRequestExpectationsSingleton
-    include WebMock::API
-    include RestAPIBuilder::UrlHelper
+  module WebMockRequestExpectations
+    extend Forwardable
 
-    def expect_json_execute(response: nil, **options)
-      if response && response[:body]
-        response = response.merge(body: JSON.generate(response[:body]))
-      end
-
-      expect_execute(**options, response: response)
-    end
-
-    def expect_execute(base_url:, method:, path: nil, request: nil, response: nil)
-      expectation = stub_request(method, full_url(base_url, path))
-
-      expectation.with(request) if request
-      expectation.to_return(response) if response
-
-      expectation
-    end
+    def_delegators Expectations, :expect_json_execute, :expect_execute
   end
-
-  WebMockRequestExpectations = WebMockRequestExpectationsSingleton.new
 end

data/lib/rest_api_builder/webmock_request_expectations/expectations.rb

@@ -0,0 +1,47 @@
+require 'webmock'
+require 'rest_api_builder/helpers/url_helper'
+
+module RestAPIBuilder
+  module WebMockRequestExpectations
+    module Expectations
+      extend WebMock::API
+      extend RestAPIBuilder::Helpers::UrlHelper
+
+      module_function
+
+      def expect_json_execute(response: nil, **options)
+        if response && response[:body]
+          response = response.merge(body: JSON.generate(response[:body]))
+        end
+
+        expect_execute(**options, response: response)
+      end
+
+      def expect_execute(base_url:, method:, path: nil, request: nil, response: nil)
+        url = path.is_a?(Regexp) ? /#{base_url}#{path}/ : full_url(base_url, path)
+        expectation = stub_request(method, url)
+
+        if !request.nil? && request.any?
+          add_request_expectations(expectation, request)
+        end
+
+        expectation.to_return(response) if response
+
+        expectation
+      end
+
+      def add_request_expectations(expectation, request)
+        if request[:body].is_a?(Hash)
+          request = request.merge(body: hash_including(request[:body]))
+        end
+
+        if request[:query].is_a?(Hash)
+          query = request[:query].transform_values(&:to_s)
+          request = request.merge(query: hash_including(query))
+        end
+
+        expectation.with(request)
+      end
+    end
+  end
+end

data/rest_api_builder.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'rest_api_builder'
-  s.version     = '0.0.6'
+  s.version     = '0.2.0'
   s.summary     = "A simple wrapper for rest-client"
   s.description = "A simple wrapper for rest-client aiming to make creation and testing of API clients easier."
   s.authors     = ["Alexey D"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_api_builder
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.2.0
 platform: ruby
 authors:
 - Alexey D
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-29 00:00:00.000000000 Z
+date: 2020-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -62,11 +62,14 @@ files:
 - LICENSE
 - README.md
 - lib/rest_api_builder.rb
+- lib/rest_api_builder/api_client.rb
+- lib/rest_api_builder/helpers/string_helper.rb
+- lib/rest_api_builder/helpers/url_helper.rb
 - lib/rest_api_builder/request.rb
-- lib/rest_api_builder/request_options.rb
-- lib/rest_api_builder/response_handler.rb
-- lib/rest_api_builder/url_helper.rb
+- lib/rest_api_builder/request/request_options.rb
+- lib/rest_api_builder/request/response_handler.rb
 - lib/rest_api_builder/webmock_request_expectations.rb
+- lib/rest_api_builder/webmock_request_expectations/expectations.rb
 - rest_api_builder.gemspec
 homepage: https://github.com/alexeyds/rest_api_builder
 licenses:
@@ -87,8 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A simple wrapper for rest-client

data/lib/rest_api_builder/request_options.rb

@@ -1,33 +0,0 @@
-require 'rest_api_builder/url_helper'
-
-module RestAPIBuilder
-  class RequestOptions
-    include RestAPIBuilder::UrlHelper
-
-    def compose(base_url:, method:, path: nil, body: nil, headers: {}, query: nil)
-      if method == :get && body
-        raise ArgumentError, 'GET requests do not support body'
-      end
-
-      headers = headers.merge(params: query) if query
-
-      {
-        method: method,
-        url: full_url(base_url, path),
-        payload: body,
-        headers: headers
-      }
-    end
-
-    def compose_json(**options)
-      result = compose(**options)
-      headers = result[:headers]
-      payload = result[:payload]
-
-      result.merge(
-        headers: headers.merge(content_type: :json),
-        payload: payload && JSON.generate(payload)
-      )
-    end
-  end
-end

data/lib/rest_api_builder/response_handler.rb

@@ -1,44 +0,0 @@
-module RestAPIBuilder
-  class ResponseHandler
-    def handle_json_response(**options, &block)
-      result = handle_response(**options, &block)
-      result.merge(body: parse_json(result[:body]))
-    end
-
-    def handle_response(logger: nil, &block)
-      result = parse_response(**handle_response_error(&block))
-      maybe_log_result(result, logger: logger)
-      result
-    end
-
-    def handle_response_error
-      response = yield
-      { raw_response: response, success: true }
-    rescue RestClient::RequestFailed => e
-      raise e unless e.response
-
-      { raw_response: e.response, success: false }
-    end
-
-    private
-
-    def parse_response(raw_response:, success:)
-      {
-        success: success,
-        status: raw_response.code,
-        body: raw_response.body,
-        headers: raw_response.headers
-      }
-    end
-
-    def maybe_log_result(result, logger:)
-      logger && logger << "# => Response: #{result}\n"
-    end
-
-    def parse_json(json)
-      JSON.parse(json)
-    rescue JSON::ParserError
-      json
-    end
-  end
-end

data/lib/rest_api_builder/url_helper.rb

@@ -1,11 +0,0 @@
-module RestAPIBuilder
-  module UrlHelper
-    def full_url(url, path)
-      if path
-        File.join(url, path)
-      else
-        url
-      end
-    end
-  end
-end