opinionated_http 0.0.1 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21c5b626468b387d5b10f055e3f45b399d1b7c0e91a3962a31de1914f582848e
-  data.tar.gz: 4190403fda9fd6bb3853f8d552aa53f22e1ddf89ead008ee4fde7d9f184c7eaa
+  metadata.gz: 5c63d8fd6c65797a7afcef26ff0ef72507dcf75f8dbbd4bc93e768cf0ddffc9a
+  data.tar.gz: 0a56d817ad5a0a988886faf17b034df697712c3958719cbcd72558ebb1bd8ee1
 SHA512:
-  metadata.gz: ff4c0ec5fadca2ac6a6cc6bbabb1e0893aa7064da3adbbfb33ef1c3561df302e2408b983ad1598360fab213ca5c35f5cc14765bcde59da95c8684d4f7f32894a
-  data.tar.gz: 274ff50c9ab8770f292ac37f2341480e01384ceddf8ef08a2ae644c139b5ecb965e0621309dd381f64e2e0a5d44bc2ee06b8037ada96c8731b8cdf645d8ab035
+  metadata.gz: f38a9f47681824038a271244c560639b119ff9ff138210c93eeb2e9d2e0955b05198f0956d5fba2f1b60b965bf4084e8f3aca0b89af759d6ecf78419d9f05903
+  data.tar.gz: 4b882e2ec2025a9d626c1a3e6d52edff1a20db6fb6dc48bc10203f14117bb1856764f373c4a0ca0bd81f97fc75a4798a68a57b2cdeafd1c3ad7d6b36ef93a14d

data/README.md

@@ -17,3 +17,56 @@ PersistentHTTP with the following enhancements:
 * Standardized Service Exception.
 * Retries on HTTP 5XX errors
 
+# Example
+
+# Configuration
+
+# Usage
+
+Create a new Opinionated HTTP instance.
+
+Parameters:
+  secret_config_prefix:
+    Required
+  metric_prefix:
+    Required
+  error_class:
+    Whenever exceptions are raised it is important that every client gets its own exception / error class
+    so that failures to specific http servers can be easily identified.
+    Required.
+  logger:
+    Default: SemanticLogger[OpinionatedHTTP]
+  Other options as supported by PersistentHTTP
+  #TODO: Expand PersistentHTTP options here
+
+Configuration:
+   Off of the `secret_config_path` path above, Opinionated HTTP uses specific configuration entry names
+   to configure the underlying HTTP setup:
+      url: [String]
+        The host url to the site to connect to.
+        Exclude any path, since that will be supplied when `#get` or `#post` is called.
+        Required.
+        Examples:
+          "https://example.com"
+          "https://example.com:8443/"
+      pool_size: [Integer]
+        default: 100
+      open_timeout: [Float]
+        default: 10
+      read_timeout: [Float]
+        default: 10
+      idle_timeout: [Float]
+        default: 300
+      keep_alive: [Float]
+        default: 300
+      pool_timeout: [Float]
+        default: 5
+      warn_timeout: [Float]
+        default: 0.25
+      proxy: [Symbol]
+        default: :ENV
+      force_retry: [true|false]
+        default: true
+
+Metrics:
+  During each call to `#get` or `#put`, the following metrics are logged using the

data/Rakefile

@@ -1,23 +1,23 @@
 # Setup bundler to avoid having to run bundle exec all the time.
-require 'rubygems'
-require 'bundler/setup'
+require "rubygems"
+require "bundler/setup"
 
-require 'rake/testtask'
-require_relative 'lib/opinionated_http/version'
+require "rake/testtask"
+require_relative "lib/opinionated_http/version"
 
 task :gem do
-  system 'gem build opinionated_http.gemspec'
+  system "gem build opinionated_http.gemspec"
 end
 
 task publish: :gem do
   system "git tag -a v#{OpinionatedHTTP::VERSION} -m 'Tagging #{OpinionatedHTTP::VERSION}'"
-  system 'git push --tags'
+  system "git push --tags"
   system "gem push opinionated_http-#{OpinionatedHTTP::VERSION}.gem"
   system "rm opinionated_http-#{OpinionatedHTTP::VERSION}.gem"
 end
 
 Rake::TestTask.new(:test) do |t|
-  t.pattern = 'test/**/*_test.rb'
+  t.pattern = "test/**/*_test.rb"
   t.verbose = true
   t.warning = false
 end

data/lib/opinionated_http.rb

@@ -1,76 +1,17 @@
+require "opinionated_http/version"
 #
 # Opinionated HTTP
 #
 # An opinionated HTTP Client library using convention over configuration.
 #
-# Uses
-# * PersistentHTTP for http connection pooling.
-# * Semantic Logger for logging and metrics.
-# * Secret Config for its configuration.
-#
-# By convention the following metrics are measured and logged:
-# *
-#
-# PersistentHTTP with the following enhancements:
-# * Read config from Secret Config, just supply the `secret_config_path`.
-# * Redirect logging into standard Semantic Logger.
-# * Implements metrics and measure call durations.
-# * Standardized Service Exception.
-# * Retries on HTTP 5XX errors
-#
-
-require 'opinionated_http/version'
 module OpinionatedHTTP
-  autoload :Client, 'opinionated_http/client'
-  autoload :Logger, 'opinionated_http/logger'
+  autoload :Client, "opinionated_http/client"
+  autoload :Logger, "opinionated_http/logger"
 
-  # Create a new Opinionated HTTP instance.
-  #
-  # Parameters:
-  #   secret_config_prefix:
-  #     Required
-  #   metric_prefix:
-  #     Required
-  #   error_class:
-  #     Whenever exceptions are raised it is important that every client gets its own exception / error class
-  #     so that failures to specific http servers can be easily identified.
-  #     Required.
-  #   logger:
-  #     Default: SemanticLogger[OpinionatedHTTP]
-  #   Other options as supported by PersistentHTTP
-  #   #TODO: Expand PersistentHTTP options here
   #
-  # Configuration:
-  #    Off of the `secret_config_path` path above, Opinionated HTTP uses specific configuration entry names
-  #    to configure the underlying HTTP setup:
-  #       url: [String]
-  #         The host url to the site to connect to.
-  #         Exclude any path, since that will be supplied when `#get` or `#post` is called.
-  #         Required.
-  #         Examples:
-  #           "https://example.com"
-  #           "https://example.com:8443/"
-  #       pool_size: [Integer]
-  #         default: 100
-  #       open_timeout: [Float]
-  #         default: 10
-  #       read_timeout: [Float]
-  #         default: 10
-  #       idle_timeout: [Float]
-  #         default: 300
-  #       keep_alive: [Float]
-  #         default: 300
-  #       pool_timeout: [Float]
-  #         default: 5
-  #       warn_timeout: [Float]
-  #         default: 0.25
-  #       proxy: [Symbol]
-  #         default: :ENV
-  #       force_retry: [true|false]
-  #         default: true
+  # Create a new Opinionated HTTP instance.
   #
-  # Metrics:
-  #   During each call to `#get` or `#put`, the following metrics are logged using the
+  # See README.md for more info.
   def self.new(**args)
     Client.new(**args)
   end

data/lib/opinionated_http/client.rb

@@ -1,32 +1,80 @@
-require 'persistent_http'
-require 'secret_config'
-require 'semantic_logger'
+require "persistent_http"
+require "secret_config"
+require "semantic_logger"
 #
 # Client http implementation
 #
+# See README.md for more info.
 module OpinionatedHTTP
   class Client
-    attr_reader :secret_config_prefix, :logger, :metric_prefix, :error_class, :driver
+    # 502 Bad Gateway, 503 Service Unavailable, 504 Gateway Timeout
+    HTTP_RETRY_CODES = %w[502 503 504].freeze
 
-    def initialize(secret_config_prefix:, logger: nil, metric_prefix:, error_class:, **options)
-      @metric_prefix = metric_prefix
-      @logger        = logger || SemanticLogger[self]
-      @error_class   = error_class
+    attr_reader :secret_config_prefix, :logger, :metric_prefix, :error_class, :driver,
+                :retry_count, :retry_interval, :retry_multiplier, :http_retry_codes,
+                :url, :pool_size, :keep_alive, :proxy, :force_retry, :max_redirects,
+                :open_timeout, :read_timeout, :idle_timeout, :pool_timeout, :warn_timeout
+
+    # Any option supplied here can be overridden if that corresponding value is set in Secret Config.
+    # Except for any values passed directly to Persistent HTTP under `**options`.
+    def initialize(
+      secret_config_prefix:,
+      metric_prefix:,
+      error_class:,
+      logger: nil,
+      retry_count: 11,
+      retry_interval: 0.01,
+      retry_multiplier: 1.8,
+      http_retry_codes: HTTP_RETRY_CODES.join(","),
+      url: nil,
+      pool_size: 100,
+      open_timeout: 10,
+      read_timeout: 10,
+      idle_timeout: 300,
+      keep_alive: 300,
+      pool_timeout: 5,
+      warn_timeout: 0.25,
+      proxy: :ENV,
+      force_retry: true,
+      max_redirects: 10,
+      **options
+    )
+      @metric_prefix    = metric_prefix
+      @logger           = logger || SemanticLogger[self]
+      @error_class      = error_class
+      @retry_count      = SecretConfig.fetch("#{secret_config_prefix}/retry_count", type: :integer, default: retry_count)
+      @retry_interval   = SecretConfig.fetch("#{secret_config_prefix}/retry_interval", type: :float, default: retry_interval)
+      @retry_multiplier = SecretConfig.fetch("#{secret_config_prefix}/retry_multiplier", type: :float, default: retry_multiplier)
+      @max_redirects    = SecretConfig.fetch("#{secret_config_prefix}/max_redirects", type: :integer, default: max_redirects)
+      http_retry_codes  = SecretConfig.fetch("#{secret_config_prefix}/http_retry_codes", type: :string, default: http_retry_codes)
+      @http_retry_codes = http_retry_codes.split(",").collect(&:strip)
+
+      @url = url.nil? ? SecretConfig["#{secret_config_prefix}/url"] : SecretConfig.fetch("#{secret_config_prefix}/url", default: url)
+
+      @pool_size    = SecretConfig.fetch("#{secret_config_prefix}/pool_size", type: :integer, default: pool_size)
+      @open_timeout = SecretConfig.fetch("#{secret_config_prefix}/open_timeout", type: :float, default: open_timeout)
+      @read_timeout = SecretConfig.fetch("#{secret_config_prefix}/read_timeout", type: :float, default: read_timeout)
+      @idle_timeout = SecretConfig.fetch("#{secret_config_prefix}/idle_timeout", type: :float, default: idle_timeout)
+      @keep_alive   = SecretConfig.fetch("#{secret_config_prefix}/keep_alive", type: :float, default: keep_alive)
+      @pool_timeout = SecretConfig.fetch("#{secret_config_prefix}/pool_timeout", type: :float, default: pool_timeout)
+      @warn_timeout = SecretConfig.fetch("#{secret_config_prefix}/warn_timeout", type: :float, default: warn_timeout)
+      @proxy        = SecretConfig.fetch("#{secret_config_prefix}/proxy", type: :symbol, default: proxy)
+      @force_retry  = SecretConfig.fetch("#{secret_config_prefix}/force_retry", type: :boolean, default: force_retry)
 
       internal_logger = OpinionatedHTTP::Logger.new(@logger)
       new_options     = {
         logger:       internal_logger,
         debug_output: internal_logger,
         name:         "",
-        pool_size:    SecretConfig.fetch("#{secret_config_prefix}/pool_size", type: :integer, default: 100),
-        open_timeout: SecretConfig.fetch("#{secret_config_prefix}/open_timeout", type: :float, default: 10),
-        read_timeout: SecretConfig.fetch("#{secret_config_prefix}/read_timeout", type: :float, default: 10),
-        idle_timeout: SecretConfig.fetch("#{secret_config_prefix}/idle_timeout", type: :float, default: 300),
-        keep_alive:   SecretConfig.fetch("#{secret_config_prefix}/keep_alive", type: :float, default: 300),
-        pool_timeout: SecretConfig.fetch("#{secret_config_prefix}/pool_timeout", type: :float, default: 5),
-        warn_timeout: SecretConfig.fetch("#{secret_config_prefix}/warn_timeout", type: :float, default: 0.25),
-        proxy:        SecretConfig.fetch("#{secret_config_prefix}/proxy", type: :symbol, default: :ENV),
-        force_retry:  SecretConfig.fetch("#{secret_config_prefix}/force_retry", type: :boolean, default: true),
+        pool_size:    @pool_size,
+        open_timeout: @open_timeout,
+        read_timeout: @read_timeout,
+        idle_timeout: @idle_timeout,
+        keep_alive:   @keep_alive,
+        pool_timeout: @pool_timeout,
+        warn_timeout: @warn_timeout,
+        proxy:        @proxy,
+        force_retry:  @force_retry
       }
 
       url               = SecretConfig["#{secret_config_prefix}/url"]
@@ -35,64 +83,111 @@ module OpinionatedHTTP
     end
 
     # Perform an HTTP Get against the supplied path
-    def get(action:, path: "/#{action}", parameters: nil)
+    def get(action:, path: "/#{action}", **args)
+      request  = build_request(path: path, verb: "Get", **args)
+      response = request(action: action, request: request)
+      extract_body(response, 'GET', action)
+    end
+
+    def post(action:, path: "/#{action}", **args)
+      request = build_request(path: path, verb: "Post", **args)
+
+      response = request(action: action, request: request)
+      extract_body(response, 'POST', action)
+    end
+
+    def build_request(verb:, path:, headers: nil, body: nil, form_data: nil, username: nil, password: nil, parameters: nil)
+      unless headers_and_form_data_compatible?(headers, form_data)
+        raise(ArgumentError, "Setting form data will overwrite supplied content-type")
+      end
+      raise(ArgumentError, "Cannot supply both form_data and a body") if body && form_data
+
       path = "/#{path}" unless path.start_with?("/")
       path = "#{path}?#{URI.encode_www_form(parameters)}" if parameters
 
-      request  = Net::HTTP::Get.new(path)
-      response =
-        begin
-          payload = {}
-          if logger.trace?
-            payload[:parameters] = parameters
-            payload[:path]       = path
-          end
-          message = "HTTP GET: #{action}" if logger.debug?
-
-          logger.benchmark_info(message: message, metric: "#{metric_prefix}/#{action}", payload: payload) { driver.request(request) }
-        rescue StandardError => exc
-          message = "HTTP GET: #{action} Failure: #{exc.class.name}: #{exc.message}"
-          logger.error(message: message, metric: "#{metric_prefix}/exception", exception: exc)
-          raise(error_class, message)
-        end
+      request = Net::HTTP.const_get(verb).new(path, headers)
 
-      unless response.is_a?(Net::HTTPSuccess)
-        message = "HTTP GET: #{action} Failure: (#{response.code}) #{response.message}"
-        logger.error(message: message, metric: "#{metric_prefix}/exception")
-        raise(error_class, message)
+      raise(ArgumentError, "#{request.class.name} does not support a request body") if body && !request.request_body_permitted?
+      if parameters && !request.response_body_permitted?
+        raise(ArgumentError, ":parameters cannot be supplied for #{request.class.name}")
       end
 
-      response.body
+      request.body = body if body
+      request.set_form_data form_data if form_data
+      request.basic_auth(username, password) if username && password
+      request
     end
 
-    def post(action:, path: "/#{action}", parameters: nil)
-      path    = "/#{path}" unless path.start_with?("/")
-      request = Net::HTTP::Post.new(path)
-      request.set_form_data(*parameters) if parameters
+    # Returns [HTTP Response] after submitting the request
+    #
+    # Notes:
+    # - Does not raise an exception when the http response is not an HTTP OK (200.
+    def request(action:, request:)
+      request_with_retry(action: action, request: request)
+    end
 
-      response =
+    private
+
+    def request_with_retry(action:, request:, try_count: 0)
+      http_method = request.method.upcase
+      response    =
         begin
           payload = {}
           if logger.trace?
             payload[:parameters] = parameters
-            payload[:path]       = path
+            payload[:path]       = request.path
           end
-          message = "HTTP POST: #{action}" if logger.debug?
+          message = "HTTP #{http_method}: #{action}" if logger.debug?
 
           logger.benchmark_info(message: message, metric: "#{metric_prefix}/#{action}", payload: payload) { driver.request(request) }
-        rescue StandardError => exc
-          message = "HTTP POST: #{action} Failure: #{exc.class.name}: #{exc.message}"
-          logger.error(message: message, metric: "#{metric_prefix}/exception", exception: exc)
+        rescue StandardError => e
+          message = "HTTP #{http_method}: #{action} Failure: #{e.class.name}: #{e.message}"
+          logger.error(message: message, metric: "#{metric_prefix}/exception", exception: e)
           raise(error_class, message)
         end
 
-      unless response.is_a?(Net::HTTPSuccess)
-        message = "HTTP POST: #{action} Failure: (#{response.code}) #{response.message}"
-        logger.error(message: message, metric: "#{metric_prefix}/exception")
-        raise(error_class, message)
+      # Retry on http 5xx errors except 500 which means internal server error.
+      if http_retry_codes.include?(response.code)
+        if try_count < retry_count
+          try_count += 1
+          duration = retry_sleep_interval(try_count)
+          logger.warn(message: "HTTP #{http_method}: #{action} Failure: (#{response.code}) #{response.message}. Retry: #{try_count}", metric: "#{metric_prefix}/retry", duration: duration * 1_000)
+          sleep(duration)
+          response = request_with_retry(action: action, request: request, try_count: try_count)
+        else
+          message = "HTTP #{http_method}: #{action} Failure: (#{response.code}) #{response.message}. Retries Exhausted"
+          logger.error(message: message, metric: "#{metric_prefix}/exception")
+          raise(error_class, message)
+        end
       end
 
-      response.body
+      response
+    end
+
+    def extract_body(response, http_method, action)
+      return response.body if response.is_a?(Net::HTTPSuccess)
+
+      message = "HTTP #{http_method}: #{action} Failure: (#{response.code}) #{response.message}"
+      logger.error(message: message, metric: "#{metric_prefix}/exception")
+      raise(error_class, message)
+    end
+
+    def prefix_path(path)
+      path.start_with?("/") ? path : "/#{path}"
+    end
+
+    # First retry is immediate, next retry is after `retry_interval`,
+    # each subsequent retry interval is 100% longer than the prior interval.
+    def retry_sleep_interval(retry_count)
+      return 0 if retry_count <= 1
+
+      (retry_multiplier**(retry_count - 1)) * retry_interval
+    end
+
+    def headers_and_form_data_compatible?(headers, form_data)
+      return true if headers.nil? || form_data.nil?
+
+      !headers.keys.map(&:downcase).include?("content-type")
     end
   end
 end

data/lib/opinionated_http/version.rb

@@ -1,3 +1,3 @@
 module OpinionatedHTTP
-  VERSION = "0.0.1".freeze
+  VERSION = "0.0.6".freeze
 end

data/test/client_test.rb

@@ -1,6 +1,6 @@
-require 'net/http'
-require 'json'
-require_relative 'test_helper'
+require "net/http"
+require "json"
+require_relative "test_helper"
 
 module OpinionatedHTTP
   class ClientTest < Minitest::Test
@@ -10,22 +10,159 @@ module OpinionatedHTTP
 
       let :http do
         OpinionatedHTTP.new(
-          secret_config_prefix: 'fake_service',
-          metric_prefix:        'FakeService',
+          secret_config_prefix: "fake_service",
+          metric_prefix:        "FakeService",
           logger:               SemanticLogger["FakeService"],
           error_class:          ServiceError,
-          header:               {'Content-Type' => 'application/json'}
+          header:               {"Content-Type" => "application/json"}
         )
       end
 
       describe "get" do
-        it 'success' do
-          output   = {zip: '12345', population: 54321}
+        it "succeeds" do
+          output   = {zip: "12345", population: 54_321}
           body     = output.to_json
-          response = Net::HTTPSuccess.new(200, 'OK', body)
-          http.driver.stub(:request, response) do
-            http.get(action: 'lookup', parameters: {zip: '12345'})
+          response = stub_request(Net::HTTPSuccess, 200, "OK", body) do
+            http.get(action: "lookup", parameters: {zip: "12345"})
           end
+          assert_equal body, response
+        end
+
+        it "fails" do
+          message = "HTTP GET: lookup Failure: (403) Forbidden"
+          error = assert_raises ServiceError do
+            stub_request(Net::HTTPForbidden, 403, "Forbidden", "") do
+              http.get(action: "lookup", parameters: {zip: "12345"})
+            end
+          end
+          assert_equal message, error.message
+        end
+      end
+
+      describe "post" do
+        it "succeeds with body" do
+          output   = {zip: "12345", population: 54_321}
+          body     = output.to_json
+          response = stub_request(Net::HTTPSuccess, 200, "OK", body) do
+            http.post(action: "lookup", body: body)
+          end
+          assert_equal body, response
+        end
+
+        it "with form data" do
+          output   = {zip: "12345", population: 54_321}
+          body     = output.to_json
+          response = stub_request(Net::HTTPSuccess, 200, "OK", body) do
+            http.post(action: "lookup", form_data: output)
+          end
+          assert_equal body, response
+        end
+
+        it "fails with body" do
+          message = "HTTP POST: lookup Failure: (403) Forbidden"
+          output  = {zip: "12345", population: 54_321}
+          body    = output.to_json
+          error   = assert_raises ServiceError do
+            stub_request(Net::HTTPForbidden, 403, "Forbidden", "") do
+              http.post(action: "lookup", body: body)
+            end
+          end
+          assert_equal message, error.message
+        end
+
+        it "fails with form data" do
+          output  = {zip: "12345", population: 54_321}
+          message = "HTTP POST: lookup Failure: (403) Forbidden"
+          error   = assert_raises ServiceError do
+            stub_request(Net::HTTPForbidden, 403, "Forbidden", "") do
+              http.post(action: "lookup", form_data: output)
+            end
+          end
+          assert_equal message, error.message
+        end
+      end
+
+      describe "build_request" do
+        let(:path) { "/fake_action" }
+        let(:post_verb) { "Post" }
+        let(:get_verb) { "Get" }
+
+        it "creates a request corresponding to the supplied verb" do
+          req  = http.build_request(path: path, verb: post_verb)
+          req2 = http.build_request(path: path, verb: get_verb)
+
+          assert_kind_of Net::HTTP::Post, req
+          assert_kind_of Net::HTTP::Get, req2
+        end
+
+        it "returns a request with supplied headers" do
+          test_headers = {"test1" => "yes_test_1", "test2" => "yes_test_2"}
+          req          = http.build_request(path: path, verb: get_verb, headers: test_headers)
+
+          assert_equal test_headers["test1"], req["test1"]
+          assert_equal test_headers["test2"], req["test2"]
+        end
+
+        it "returns a request with supplied body" do
+          test_body = "nice bod"
+          req       = http.build_request(path: path, verb: post_verb, body: test_body)
+
+          assert_equal test_body, req.body
+        end
+
+        it "returns a request with supplied form data in x-www-form-urlencoded Content-Type" do
+          test_data       = {test1: "yes", test2: "no"}
+          expected_string = "test1=yes&test2=no"
+          req             = http.build_request(path: path, verb: post_verb, form_data: test_data)
+
+          assert_equal expected_string, req.body
+          assert_equal "application/x-www-form-urlencoded", req["Content-Type"]
+        end
+
+        it "add supplied authentication to the request" do
+          test_un = "admin"
+          test_pw = "hunter2"
+          req     = http.build_request(path: path, verb: get_verb, username: test_un, password: test_pw)
+          req2    = Net::HTTP::Get.new(path)
+          req2.basic_auth test_un, test_pw
+
+          assert_equal req2["authorization"], req["authorization"]
+        end
+
+        it "raise an error if supplied content-type header would be overwritten by setting form_data" do
+          downcase_headers    = {"unimportant" => "blank", "content-type" => "application/json"}
+          capitalized_headers = {"Unimportant" => "blank", "Content-Type" => "application/json"}
+          no_conflict_headers = {"whatever" => "blank", "irrelevant" => "test"}
+          form_data           = {thing1: 1, thing2: 2}
+
+          assert_raises ArgumentError do
+            http.build_request(path: path, verb: post_verb, headers: downcase_headers, form_data: form_data)
+          end
+
+          assert_raises ArgumentError do
+            http.build_request(path: path, verb: post_verb, headers: capitalized_headers, form_data: form_data)
+          end
+
+          assert http.build_request(path: path, verb: post_verb, headers: no_conflict_headers, form_data: form_data)
+        end
+
+        it "raise an error if there is a collision between supplied body and form_data" do
+          form_data = {thing1: 1, thing2: 2}
+          body      = "not form data"
+
+          assert_raises ArgumentError do
+            http.build_request(path: path, verb: post_verb, body: body, form_data: form_data)
+          end
+
+          assert http.build_request(path: path, verb: post_verb, body: body)
+          assert http.build_request(path: path, verb: post_verb, form_data: form_data)
+        end
+      end
+
+      def stub_request(klass, code, msg, body, &block)
+        response = klass.new("1.1", code, msg)
+        response.stub(:body, body) do
+          http.driver.stub(:request, response, &block)
         end
       end
     end

data/test/test_helper.rb

@@ -1,14 +1,14 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-ENV['TZ'] = 'America/New_York'
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../lib"
+ENV["TZ"] = "America/New_York"
 
-require 'yaml'
-require 'minitest/autorun'
-require 'awesome_print'
-require 'secret_config'
-require 'semantic_logger'
-require 'opinionated_http'
+require "yaml"
+require "minitest/autorun"
+require "awesome_print"
+require "secret_config"
+require "semantic_logger"
+require "opinionated_http"
 
-SemanticLogger.add_appender(file_name: 'test.log', formatter: :color)
+SemanticLogger.add_appender(file_name: "test.log", formatter: :color)
 SemanticLogger.default_level = :debug
 
-SecretConfig.use :file, path: 'test', file_name: File.expand_path('config/application.yml', __dir__)
+SecretConfig.use :file, path: "test", file_name: File.expand_path("config/application.yml", __dir__)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opinionated_http
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.6
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-20 00:00:00.000000000 Z
+date: 2020-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: persistent_http
@@ -87,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Opinionated HTTP Client