rest_api_builder 0.0.1 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ffe941de96bc46453108079ed3dce2d654947b2930f2127c2e18737c9b00199
-  data.tar.gz: 59665b1e50fe3a2ab479d73dd549a2369718f6f2ba7adc02b66399b1a6c32a24
+  metadata.gz: 7e04eb4a2a88c29a02d4fc831018d118ce8cd570f7523625cc83bd155041734a
+  data.tar.gz: 1092c81256426cb4d0e590452c0831291b20697108a07358fe5efdc5761d74b0
 SHA512:
-  metadata.gz: cf33cca8a23fdfe9302e0fd6e9fabfddb4b67bc73c762f91689f1bf0130d6827c5545f5eb9ee3e4dda639f053fdc07a9ab92c175463b370ee2884e52c6ea3dbe
-  data.tar.gz: 8a70a3bbf1b7cd2c83b5ad65c45b98191a32daf864ac826fa40920f30a4f423169e9bfbadd6896eee2f6796b886f4caeabe65fa90fad834ff8d1b9b7ca574e1b
+  metadata.gz: b494a395a84ce64096cbe07231457e742de4ddd812bdf092e00e717db0c078496c907d81d19e671f32ce484f8b6464e310aba16184c6ed4724d0c0c19f7a5749
+  data.tar.gz: 2626417df9c9241d33ac3e76b2a9a5f64638b6a0397785c470f921303fb47188ab606914fc4890b47aaf4fd4fdc6f96fe8c6569ac9a29f114b9854ef66d48c29

data/README.md

@@ -84,7 +84,7 @@ response[:status]  #=> 200
 response[:body]    #=> ''
 response[:headers] #=> {}
 
-# Specifying response details
+# Specifying expectation details with WebMock::Request methods
 Expectations
   .expect_execute(base_url: "test.com", method: :get)
   .to_return(status: 404, body: "not found")
@@ -93,6 +93,29 @@ 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"}) }
+)
+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 = Request.execute(base_url: "test.com", method: :get)
+response[:success] #=> true
+response[:body]    #=> "{\"hi\":\"hello\"}"
 ```
 
 ## Request API
@@ -110,6 +133,7 @@ Does not throw on non-200 responses like RestClient does, but will throw on any
 * **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)
@@ -127,6 +151,11 @@ Defines a request expectation using WebMock's `stub_request`. Returns an instanc
 * **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

data/lib/rest_api_builder.rb

@@ -1 +1,21 @@
+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

data/lib/rest_api_builder/request.rb

@@ -1,11 +1,7 @@
 require 'rest-client'
-require 'rest_api_builder/url_helper'
-require 'rest_api_builder/rest_client_response_parser'
 
 module RestAPIBuilder
   class RequestSingleton
-    include RestAPIBuilder::UrlHelper
-
     def json_execute(headers: {}, body: nil, **options)
       headers = headers.merge(content_type: :json)
       body &&= JSON.generate(body)
@@ -21,29 +17,27 @@ module RestAPIBuilder
       path: nil,
       logger: nil,
       parse_json: false,
+      raw_response: false,
       rest_client_options: {}
     )
-      if method == :get && body
-        raise ArgumentError, 'GET requests do not support body'
-      end
-
-      response_parser = RestAPIBuilder::RestClientResponseParser.new(logger: logger, parse_json: parse_json)
-      headers = headers.merge(params: query) if query
+      options = RequestOptions.new.compose(
+        base_url: base_url,
+        method: method,
+        body: body,
+        headers: headers,
+        query: query,
+        path: path
+      )
 
-      begin
-        response = RestClient::Request.execute(
-          method: method,
-          url: full_url(base_url, path),
-          payload: body,
-          headers: headers,
-          log: logger,
-          **rest_client_options
-        )
-        response_parser.parse_response(response, success: true)
-      rescue RestClient::RequestFailed => e
-        raise e unless e.response
+      response_handler = ResponseHandler.new
+      execute_request = proc { RestClient::Request.execute(**options, log: logger, **rest_client_options) }
 
-        response_parser.parse_response(e.response, success: false)
+      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
   end

data/lib/rest_api_builder/request_options.rb

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,44 @@
+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/webmock_request_expectations.rb

@@ -6,8 +6,21 @@ module RestAPIBuilder
     include WebMock::API
     include RestAPIBuilder::UrlHelper
 
-    def expect_execute(base_url:, method:, path: nil)
-      stub_request(method, full_url(base_url, path))
+    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
   end
 

data/rest_api_builder.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'rest_api_builder'
-  s.version     = '0.0.1'
+  s.version     = '0.0.6'
   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.1
+  version: 0.0.6
 platform: ruby
 authors:
 - Alexey D
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-16 00:00:00.000000000 Z
+date: 2020-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -63,7 +63,8 @@ files:
 - README.md
 - lib/rest_api_builder.rb
 - lib/rest_api_builder/request.rb
-- lib/rest_api_builder/rest_client_response_parser.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/webmock_request_expectations.rb
 - rest_api_builder.gemspec
@@ -86,7 +87,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubyforge_project: 
+rubygems_version: 2.7.8
 signing_key: 
 specification_version: 4
 summary: A simple wrapper for rest-client

data/lib/rest_api_builder/rest_client_response_parser.rb

@@ -1,35 +0,0 @@
-require 'json'
-
-module RestAPIBuilder
-  class RestClientResponseParser
-    def initialize(logger:, parse_json:)
-      @logger = logger
-      @parse_json = parse_json
-    end
-
-    def parse_response(response, success:)
-      body = @parse_json ? parse_json(response.body) : response.body
-      result = {
-        success: success,
-        status: response.code,
-        body: body,
-        headers: response.headers
-      }
-      maybe_log_result(result)
-
-      result
-    end
-
-    private
-
-    def parse_json(json)
-      JSON.parse(json)
-    rescue JSON::ParserError
-      json
-    end
-
-    def maybe_log_result(result)
-      @logger && @logger << "# => Response: #{result}"
-    end
-  end
-end