faraday-conductivity 0.2.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c0e0b4ab8e7ebe14c7b3ac66223ac8249e457555
-  data.tar.gz: 9de5e1b2b2cb788589612ffdb35b656c538bdda8
+SHA256:
+  metadata.gz: d9e393883d3c0b3a50660e6dafbc81b71fcb7248369194c7f2e1b1680e803875
+  data.tar.gz: cf92d88b08e4e9eba93b56483cd3eff818f419f702dafe9d8e4ae4cc195ef507
 SHA512:
-  metadata.gz: 72d31c8c4ccb84c8ed76bbe98db9e94dff8c2e39c412ebac07a305cb16d232c3c233faf070e09de23868ad7b8295bb77afbd30c2dc1220c96da9f4f551980e92
-  data.tar.gz: 0b47e2a12d797d83d873c60ef4c0fe45b872a442b40343bc64e9a17ded073ac642e84e470277cf32d2dc465517270254a2beca32f459ae4149a4d6ae4776d371
+  metadata.gz: 833765770451c7113b605c449a8ccdf66a8b3e763ca9ad1458dcf227a3a599b160948cc10ec472491d703dc68fa841928b83ca126c908c71e28d7d73686c03b1
+  data.tar.gz: 7bd40193cd8be6a51a642a1a43e5320354a3af7535a12cfee7a0a875547340a6d58273c987e86f847dfbdaee84f0206e7be76d801ecb8e66dd9172bf684f9616

data/.gitignore

@@ -16,3 +16,4 @@ test/tmp
 test/version_tmp
 tmp
 log/
+gemfiles/*.lock

data/.rspec

@@ -1,2 +1,4 @@
 --format documentation
 --color
+--require spec_helper
+--order random

data/.travis.yml

@@ -1,4 +1,6 @@
 language: ruby
 rvm:
-  - 1.9.3
-  - 2.0.0
+  - 2.3.0
+  - 2.7.0
+gemfile:
+  - gemfiles/faraday_1.0.0.gemfile

data/Appraisals

@@ -0,0 +1,3 @@
+appraise "faraday-1.0.0" do
+  gem "faraday", "~> 1.0.0"
+end

data/README.md

@@ -1,4 +1,8 @@
-# Faraday::Conductivity [![Build Status](https://travis-ci.org/yourkarma/faraday-conductivity.png?branch=master)](https://travis-ci.org/yourkarma/faraday-conductivity)
+# Faraday::Conductivity [![Build Status](https://travis-ci.org/enova/faraday-conductivity.svg?branch=master)](https://travis-ci.org/enova/faraday-conductivity)
+
+Originally implemented by [yourkarma/faraday-conductivity](https://github.com/yourkarma/faraday-conductivity).
+
+---
 
 Extra Faraday Middleware! Geared towards a service oriented architecture.
 
@@ -9,7 +13,7 @@ These middlewares are currently included:
 * **extended_logging**, logs *all* the information of the request.
 * **request_id**, passes along the `X-Request-Id` header to track API request
   back to the source.
-* **mimetype**, allows you to specify the `Accept` header for API versioning.
+* **request_headers**, allows you to specify default request headers used in each request.
 * **selective_errors**, raise errors only on the statuses that you specify.
 
 Further information:
@@ -38,7 +42,7 @@ connection = Faraday.new(url: "http://widgets.yourapp.com") do |faraday|
   # provided by this gem
   faraday.request :user_agent, app: "MarketingSite", version: APP_VERSION
   faraday.request :request_id
-  faraday.request :mimetype, accept: "application/vnd.widgets-v2+json"
+  faraday.request :request_headers, accept: "application/vnd.widgets-v2+json"
 
   # provided by this gem
   faraday.use :extended_logging, logger: Rails.logger
@@ -144,8 +148,67 @@ The User-Agent will looks like this on my machine:
 MarketingSite/1.1 (iain.local; iain; 30360) ruby/1.9.3 (327; x86_64-darwin12.2.0)
 ```
 
+### Selective Errors
+
+The default `:raise_error` middleware raises errors for every http status above
+400. However, status codes like 404 or 422 might not be an actual exceptional
+condition. This middleware allows you to specify which status codes you do and
+do not want to raise an error for.
+
+You can pass in an array or a range to the `:on` argument. This will default to
+400...600. You can specify exceptions with the `:except` argument.
+
+``` ruby
+connection = Faraday.new(url: "http://widgets.yourapp.com") do |faraday|
+  faraday.response :selective_errors, on: (400...600), except: [404, 409, 410, 412, 422]
+end
+```
+
+The errors raised will be the same [as Faraday](https://github.com/lostisland/faraday/blob/019e1a841707718adad2fd05c602eb1a869b42bc/lib/faraday/response/raise_error.rb).
+
+If you don't specify the `:on` or `:except` options, it will behave exactly like
+`:raise_error`. The errors are however "enhanced" with extra information about
+the request that normally are lost:
+
+``` ruby
+begin
+  do_failing_request_here
+rescue Faraday::ClientError => error
+  puts error.request[:url]
+  puts error.request[:method]
+  puts error.request[:body]
+  puts error.request[:headers]
+
+  puts error.response[:status]
+  puts error.response[:body]
+  puts error.response[:headers]
+  puts error.response_time
+end
+```
+
+### Request Headers
+
+Allows you to set request headers ahead of time, so you don't have to do this
+each time you make a request. You can override it per request of course.
+
+Usage:
+
+``` ruby
+connection = Faraday.new(url: "http://widgets.yourapp.com") do |faraday|
+  faraday.request :request_headers, accept: "application/json", x_version_number: "10"
+end
+```
+
+## faraday-conductivity ~> 0.3
+
+The following middlewares have been removed entirely and are no longer
+supported, but were available prior in faraday-conductivity versions <= 0.3.
+
 ### Repeater
 
+Suggested to use [Faraday's Retry](https://github.com/lostisland/faraday/blob/master/docs/middleware/request/retry.md)
+instead.
+
 The Repeater will retry your requests until they succeed. This is handy for
 reaching servers that are not too reliable.
 
@@ -173,26 +236,9 @@ end
 You can use the repeater together with the `raise_error` middleware to also
 retry after getting 404s and other succeeded requests, but failed statuses.
 
-### Selective Errors
-
-The default `:raise_error` middleware raises errors for every http status above
-400. However, status codes like 404 or 422 might not be an actual exceptional
-condition. This middleware allows you to specify which status codes you do and
-do not want to raise an error for.
-
-You can pass in an array or a range to the `:on` argument. This will default to
-400...600. You can specify exceptions with the `:except` argument.
-
-``` ruby
-connection = Faraday.new(url: "http://widgets.yourapp.com") do |faraday|
-  faraday.response :selective_errors, on: (400...600), except: [404, 409, 410, 412, 422]
-end
-```
+### Mimetype
 
-The errors raised will be the same as Faraday, namely
-`Faraday::Error::ResourceNotFound` for 404 errors,
-`Faraday::Error::ConnectionFailed` for 407 and `Faraday::Error::ClientError` for
-the rest. These all inherit from `Faraday::Error`.
+This one is deprecated. Use Request Headers instead.
 
 ## Contributing
 

data/Rakefile

@@ -1,3 +1,4 @@
+require "appraisal"
 require "bundler/gem_tasks"
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)

data/faraday-conductivity.gemspec

@@ -6,11 +6,11 @@ require 'faraday/conductivity/version'
 Gem::Specification.new do |gem|
   gem.name          = "faraday-conductivity"
   gem.version       = Faraday::Conductivity::VERSION
-  gem.authors       = ["iain"]
-  gem.email         = ["iain@iain.nl"]
+  gem.authors       = ["iain", "sshao"]
+  gem.email         = ["iain@iain.nl", "ssh.sshao@gmail.com"]
   gem.description   = %q{Extra Faraday middleware, geared towards a service oriented architecture.}
   gem.summary       = %q{Extra Faraday middleware, geared towards a service oriented architecture.}
-  gem.homepage      = "https://github.com/yourkarma/faraday-conductivity"
+  gem.homepage      = "https://github.com/enova/faraday-conductivity"
   gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split($/)
@@ -18,9 +18,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency "faraday", "~> 0.8"
+  gem.add_dependency "faraday", "~> 1.0"
   gem.add_development_dependency "rake"
-  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rspec", "~> 3"
   gem.add_development_dependency "pry"
-  gem.add_development_dependency "service_double"
+  gem.add_development_dependency "appraisal"
 end

data/gemfiles/faraday_1.0.0.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "faraday", "~> 1.0.0"
+
+gemspec path: "../"

data/lib/faraday/conductivity.rb

@@ -3,21 +3,20 @@ require "faraday"
 require "faraday/conductivity/version"
 
 require "faraday/conductivity/extended_logging"
-require "faraday/conductivity/mimetype"
 require "faraday/conductivity/request_id"
 require "faraday/conductivity/request_id_filter"
 require "faraday/conductivity/user_agent"
-require "faraday/conductivity/repeater"
 require "faraday/conductivity/selective_errors"
+require "faraday/conductivity/request_headers"
 
 module Faraday
   module Conductivity
   end
-  register_middleware :middleware,  :extended_logging => Faraday::Conductivity::ExtendedLogging
-  register_middleware :request,     :user_agent       => Faraday::Conductivity::UserAgent
-  register_middleware :request,     :request_id       => Faraday::Conductivity::RequestId
-  register_middleware :request,     :mimetype         => Faraday::Conductivity::Mimetype
-  register_middleware :middleware,  :repeater         => Faraday::Conductivity::Repeater
-  register_middleware :response,    :selective_errors => Faraday::Conductivity::SelectiveErrors
+
+  Faraday::Middleware.register_middleware :extended_logging => Faraday::Conductivity::ExtendedLogging
+  Faraday::Request.register_middleware    :request_id       => Faraday::Conductivity::RequestId
+  Faraday::Request.register_middleware    :request_headers  => Faraday::Conductivity::RequestHeaders
+  Faraday::Request.register_middleware    :user_agent       => Faraday::Conductivity::UserAgent
+  Faraday::Response.register_middleware   :selective_errors => Faraday::Conductivity::SelectiveErrors
 end
 

data/lib/faraday/conductivity/extended_logging.rb

@@ -17,7 +17,7 @@ module Faraday
 
       def call(env)
         start_time = Time.now
-        info  { request_info(env) }
+        debug { request_info(env) }
         debug { request_debug(env) }
         @app.call(env).on_complete do
           end_time = Time.now
@@ -34,7 +34,7 @@ module Faraday
       end
 
       def response_info(env, response_time)
-        "Response from %s; Status: %d; Time: %.1fms" % [ env[:url], env[:status], (response_time * 1_000.0) ]
+        "Response from %s %s; Status: %d; Time: %.1fms" % [ env[:method].to_s.upcase, env[:url], env[:status], (response_time * 1_000.0) ]
       end
 
       def request_debug(env)

data/lib/faraday/conductivity/request_headers.rb

@@ -0,0 +1,19 @@
+module Faraday
+  module Conductivity
+    class RequestHeaders < Faraday::Middleware
+
+      def initialize(app, headers)
+        super(app)
+        @headers = headers
+      end
+
+      def call(env)
+        @headers.each do |header, value|
+          env[:request_headers][header] ||= value
+        end
+        @app.call(env)
+      end
+
+    end
+  end
+end

data/lib/faraday/conductivity/request_id_filter.rb

@@ -2,8 +2,11 @@ module Faraday
   module Conductivity
     class RequestIdFilter
 
-      def self.filter(controller)
-        Thread.current[:request_id] = controller.request.uuid
+      class << self
+        def filter(controller)
+          Thread.current[:request_id] = controller.request.uuid
+        end
+        alias_method :before, :filter
       end
 
     end

data/lib/faraday/conductivity/selective_errors.rb

@@ -1,50 +1,125 @@
 module Faraday
   module Conductivity
+
+    module Error
+
+      attr_accessor :request, :response, :response_time
+
+      def initialize(*)
+        @request  = {}
+        @response = {}
+        super
+      end
+
+      def message
+        if @wrapped_exception
+          "#{@wrapped_exception.class}: #{super}"
+        else
+          "#{request[:method].to_s.upcase} #{request[:url]} responded with status #{response[:status]}"
+        end
+      end
+
+      def inspect
+        "<#{self.class}> #{message}"
+      end
+
+    end
+
+    # Use this to raise errors on certain HTTP statuses. These are basically
+    # the same errors as Faraday raises when you use the "raise_error"
+    # middleware, but with added fields to better inspect what went wrong.
+    #
+    # Examples:
+    #
+    #   # specify an array
+    #   faraday.response :selective_errors, on: [422,500]
+    #   # or a range:
+    #   faraday.response :selective_errors, on: 500...600
+    #   # specify errors:
+    #   faraday.response :selective_errors, except: [404,422]
+    #
+    # Rescueing the errors:
+    #
+    #   begin
+    #     do_request
+    #   rescue Faraday::Conductivity::Error => error
+    #     puts error.request[:url]
+    #     puts error.request[:method]
+    #     puts error.request[:body]
+    #     puts error.request[:headers]
+    #
+    #     puts error.response[:status]
+    #     puts error.response[:body]
+    #     puts error.response[:headers]
+    #   end
     class SelectiveErrors < Faraday::Middleware
 
-      ClientErrorStatuses = 400...600
+      ClientErrorStatuses = (400...500).freeze
+      ServerErrorStatuses = (500...600).freeze
 
       def initialize(app, options = {})
         @app    = app
-        @on     = options.fetch(:on) { ClientErrorStatuses }
+        @on     = options.fetch(:on) { ClientErrorStatuses.to_a + ServerErrorStatuses.to_a }
         @except = options.fetch(:except) { [] }
       end
 
       def call(env)
-        # capture request_body because not accessible afterwards
-        request_body = env[:body]
+        # capture request because it will be modified during the request
+        request = {
+          :method  => env[:method],
+          :url     => env[:url],
+          :body    => env[:body],
+          :headers => env[:request_headers],
+        }
+
+        start_time = Time.now
+
         @app.call(env).on_complete do
-          if should_raise_error?(env[:status])
-            raise_error(env, request_body)
+          status = env[:status]
+
+          if should_raise_error?(status)
+            error = case status
+                    when 400
+                      Faraday::BadRequestError.new(response_values(env))
+                    when 401
+                      Faraday::UnauthorizedError.new(response_values(env))
+                    when 403
+                      Faraday::ForbiddenError.new(response_values(env))
+                    when 404
+                      Faraday::ResourceNotFound.new(response_values(env))
+                    when 407
+                      # mimic the behavior that we get with proxy requests with HTTPS
+                      msg = %(407 "Proxy Authentication Required")
+                      Faraday::ProxyAuthError.new(msg, response_values(env))
+                    when 409
+                      Faraday::ConflictError.new(response_values(env))
+                    when 422
+                      Faraday::UnprocessableEntityError.new(response_values(env))
+                    when ClientErrorStatuses
+                      Faraday::ClientError.new(response_values(env))
+                    when ServerErrorStatuses
+                      Faraday::ServerError.new(response_values(env))
+                    when nil
+                      Faraday::NilStatusError.new(response_values(env))
+                    end
+
+            error.extend Error
+            error.response = response_values(env)
+            error.request = request
+            error.response_time = Time.now - start_time
+
+            raise error
           end
-        end
-      end
 
-      def should_raise_error?(status)
-        @on.include?(status) && !@except.include?(status)
+        end
       end
 
-      def raise_error(env, request_body)
-        case env[:status]
-        when 404
-          raise Faraday::Error::ResourceNotFound, response_values(env, request_body)
-        when 407
-          # mimic the behavior that we get with proxy requests with HTTPS
-          raise Faraday::Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
-        else
-          raise Faraday::Error::ClientError, response_values(env, request_body)
-        end
+      def response_values(env)
+        { status: env.status, headers: env.response_headers, body: env.body }
       end
 
-      def response_values(env, request_body)
-        {
-          :url              => env[:url],
-          :status           => env[:status],
-          :request_body     => request_body,
-          :request_headers  => env[:request_headers],
-          :response_headers => env[:response_headers],
-          :response_body    => env[:body],
-        }
+      def should_raise_error?(status)
+        @on.include?(status) && !@except.include?(status)
       end
 
     end

data/lib/faraday/conductivity/version.rb

@@ -1,5 +1,5 @@
 module Faraday
   module Conductivity
-    VERSION = "0.2.0"
+    VERSION = "1.0.1"
   end
 end

data/spec/middleware/extended_logging_spec.rb

@@ -1,40 +1,39 @@
-require 'spec_helper'
 require 'logger'
 
-describe Faraday::Conductivity::ExtendedLogging do
+RSpec.describe Faraday::Conductivity::ExtendedLogging do
 
   subject(:log) { io.read }
 
   it "includes the HTTP verb" do
-    log.should include "GET"
+    expect(log).to include "GET"
   end
 
   it "includes the request body" do
-    log.should include "the request body"
+    expect(log).to include "the request body"
   end
 
   it "includes the request headers" do
-    log.should match %r"X-Foo\s+: bar"
+    expect(log).to match %r"X-Foo\s+: bar"
   end
 
   it "includes the complete URL" do
-    log.should include "http://widgets.example.org/test"
+    expect(log).to include "http://widgets.example.org/test"
   end
 
   it "includes the response status" do
-    log.should include "200"
+    expect(log).to include "200"
   end
 
   it "includes the response time" do
-    log.should match(/\d+\.\d+ms/)
+    expect(log).to match(/\d+\.\d+ms/)
   end
 
   it "includes the response headers" do
-    log.should include "X-Bar : foo"
+    expect(log).to include "X-Bar : foo"
   end
 
   it "includes the response body" do
-    log.should include "the response body"
+    expect(log).to include "the response body"
   end
 
   before do

data/spec/middleware/request_headers_spec.rb

@@ -0,0 +1,26 @@
+RSpec.describe Faraday::Conductivity::RequestHeaders do
+
+  it "includes the mimetype specified" do
+    connection = create_connection do |faraday|
+      faraday.request :request_headers, :accept => "application/json", :x_version_number => "123"
+    end
+    request_headers = connection.get("/test").env[:request_headers]
+
+    expect(request_headers["Accept"]).to eq "application/json"
+    expect(request_headers["X-Version-Number"]).to eq "123"
+  end
+
+  it "doesn't override locally specified headers" do
+    connection = create_connection do |faraday|
+      faraday.request :request_headers, :accept => "application/json"
+    end
+    response = connection.get("/test") do |request|
+      request.headers[:accept] = "application/xml"
+    end
+
+    request_headers = response.env[:request_headers]
+
+    expect(request_headers["Accept"]).to eq "application/xml"
+  end
+
+end

data/spec/middleware/request_id_spec.rb

@@ -1,17 +1,15 @@
-require 'spec_helper'
-
-describe Faraday::Conductivity::RequestId do
+RSpec.describe Faraday::Conductivity::RequestId do
 
   subject(:request_headers) { response.env[:request_headers] }
 
   it "includes the thread local variable" do
     Thread.current[:request_id] = "my-request-id"
-    request_headers["X-Request-Id"].should eq "my-request-id"
+    expect(request_headers["X-Request-Id"]).to eq "my-request-id"
   end
 
   it "doesn't add the header if there is no request id" do
     Thread.current[:request_id] = nil
-    request_headers.should_not have_key "X-Request-Id"
+    expect(request_headers).not_to have_key "X-Request-Id"
   end
 
   def connection

data/spec/middleware/selective_errors_spec.rb

@@ -1,12 +1,32 @@
-require 'spec_helper'
-
-describe Faraday::Conductivity::SelectiveErrors do
+RSpec.describe Faraday::Conductivity::SelectiveErrors do
 
   subject(:request_headers) { response.env[:request_headers] }
 
+  context 'default range' do
+    before { apply_selective_errors({}) }
+
+    it 'includes client errors' do
+      expect { response_with_status(400) }.to raise_error Faraday::BadRequestError
+      expect { response_with_status(450) }.to raise_error Faraday::ClientError
+      expect { response_with_status(499) }.to raise_error Faraday::ClientError
+    end
+
+    it 'includes server errors' do
+      expect { response_with_status(500) }.to raise_error Faraday::ServerError
+      expect { response_with_status(550) }.to raise_error Faraday::ServerError
+      expect { response_with_status(599) }.to raise_error Faraday::ServerError
+    end
+
+    it 'does not include non-client non-server errors' do
+      expect { response_with_status(100) }.not_to raise_error
+      expect { response_with_status(200) }.not_to raise_error
+      expect { response_with_status(305) }.not_to raise_error
+    end
+  end
+
   it "raises an exception if the error is inside the :on argument" do
     apply_selective_errors on: 407..409
-    expect { response_with_status(408) }.to raise_error Faraday::Error::ClientError
+    expect { response_with_status(408) }.to raise_error Faraday::ClientError
   end
 
   it "won't raise an exception when outside the range" do
@@ -21,17 +41,35 @@ describe Faraday::Conductivity::SelectiveErrors do
 
   it "raises an exception if included in :on and not included in :except" do
     apply_selective_errors on: 403..422, except: [408]
-    expect { response_with_status(409) }.to raise_error Faraday::Error::ClientError
+    expect { response_with_status(409) }.to raise_error Faraday::ClientError
   end
 
   it "raises a resource not found error when the actual status is 404" do
     apply_selective_errors on: 403..422, except: [408]
-    expect { response_with_status(404) }.to raise_error Faraday::Error::ResourceNotFound
+    expect { response_with_status(404) }.to raise_error Faraday::ResourceNotFound
   end
 
-  it "raises a connection failed on 407" do
+  it "raises proxy auth required on 407" do
     apply_selective_errors on: 403..422, except: [408]
-    expect { response_with_status(407) }.to raise_error Faraday::Error::ConnectionFailed
+    expect { response_with_status(407) }.to raise_error Faraday::ProxyAuthError
+  end
+
+  it "stores more information about the request and response" do
+    apply_selective_errors on: 403..422, except: [408]
+    error = response_with_status(422) rescue $!
+    expect(error.message).to eq "GET http://widgets.example.org/test responded with status 422"
+
+    expect(error.request[:url].to_s).to eq "http://widgets.example.org/test"
+    expect(error.request[:method]).to eq :get
+
+    expect(error.response[:status]).to eq 422
+
+    expect(error.request[:body]).to eq "the request body"
+    expect(error.response[:body]).to eq "the response body"
+
+    expect(error.request[:headers]).to eq "Accept" => "application/json"
+    expect(error.response[:headers]).to eq "X-Foo-Bar" => "y"
+    expect(error.response_time).to be_a Float
   end
 
   def apply_selective_errors(options)
@@ -40,12 +78,15 @@ describe Faraday::Conductivity::SelectiveErrors do
 
   def response_with_status(status)
     stubs = create_stubs do |stub|
-      stub.get("/test") { |e| [status, {}, "response"] }
+      stub.get("/test") { |e| [status, { :x_foo_bar => "y" }, "the response body"] }
     end
     connection = create_connection(stubs) do |faraday|
       faraday.response :selective_errors, @options
     end
-    connection.get("/test")
+    connection.get("/test") do |f|
+      f.body = "the request body"
+      f.headers = { "Accept" => "application/json" }
+    end
   end
 
 end

data/spec/middleware/user_agent_spec.rb

@@ -1,39 +1,37 @@
-require 'spec_helper'
-
-describe Faraday::Conductivity::UserAgent do
+RSpec.describe Faraday::Conductivity::UserAgent do
 
   subject(:user_agent) { response.env[:request_headers]["User-Agent"] }
 
   it "includes the name and version of the app" do
-    user_agent.should start_with "MarketingSite/1.1"
+    expect(user_agent).to start_with "MarketingSite/1.1"
   end
 
   it "includes the current ruby version" do
-    user_agent.should include RUBY_VERSION
+    expect(user_agent).to include RUBY_VERSION
   end
 
   it "includes the current ruby engine" do
-    user_agent.should include RUBY_ENGINE
+    expect(user_agent).to include RUBY_ENGINE
   end
 
   it "includes the current ruby patch level" do
-    user_agent.should include RUBY_PATCHLEVEL.to_s
+    expect(user_agent).to include RUBY_PATCHLEVEL.to_s
   end
 
   it "includes the platform" do
-    user_agent.should include RUBY_PLATFORM
+    expect(user_agent).to include RUBY_PLATFORM
   end
 
   it "includes the pid" do
-    user_agent.should include "1337"
+    expect(user_agent).to include "1337"
   end
 
   it "includes the current host" do
-    user_agent.should include "my.hostname"
+    expect(user_agent).to include "my.hostname"
   end
 
   it "includes the current user name" do
-    user_agent.should include "linus"
+    expect(user_agent).to include "linus"
   end
 
   let(:environment) {

data/spec/spec_helper.rb

@@ -28,18 +28,6 @@ module SpecHelper
 end
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-  config.order = 'random'
+  config.disable_monkey_patching!
   config.include SpecHelper
 end
-
-require 'service_double'
-
-$service_double_url = "http://localhost:3434"
-
-$service_double = ServiceDouble.hook_into(:rspec) do |config|
-  config.server = File.expand_path('../fake_server.rb', __FILE__)
-  config.url = $service_double_url
-end

metadata

@@ -1,118 +1,119 @@
 --- !ruby/object:Gem::Specification
 name: faraday-conductivity
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.1
 platform: ruby
 authors:
 - iain
+- sshao
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-27 00:00:00.000000000 Z
+date: 2020-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: service_double
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Extra Faraday middleware, geared towards a service oriented architecture.
 email:
 - iain@iain.nl
+- ssh.sshao@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Appraisals
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - faraday-conductivity.gemspec
+- gemfiles/faraday_1.0.0.gemfile
 - lib/faraday/conductivity.rb
 - lib/faraday/conductivity/extended_logging.rb
-- lib/faraday/conductivity/mimetype.rb
-- lib/faraday/conductivity/repeater.rb
+- lib/faraday/conductivity/request_headers.rb
 - lib/faraday/conductivity/request_id.rb
 - lib/faraday/conductivity/request_id_filter.rb
 - lib/faraday/conductivity/selective_errors.rb
 - lib/faraday/conductivity/user_agent.rb
 - lib/faraday/conductivity/version.rb
-- spec/fake_server.rb
 - spec/middleware/extended_logging_spec.rb
-- spec/middleware/mimetype_spec.rb
-- spec/middleware/repeater_spec.rb
+- spec/middleware/request_headers_spec.rb
 - spec/middleware/request_id_spec.rb
 - spec/middleware/selective_errors_spec.rb
 - spec/middleware/user_agent_spec.rb
 - spec/spec_helper.rb
-homepage: https://github.com/yourkarma/faraday-conductivity
+homepage: https://github.com/enova/faraday-conductivity
 licenses:
 - MIT
 metadata: {}
@@ -122,25 +123,22 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.1.0
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Extra Faraday middleware, geared towards a service oriented architecture.
 test_files:
-- spec/fake_server.rb
 - spec/middleware/extended_logging_spec.rb
-- spec/middleware/mimetype_spec.rb
-- spec/middleware/repeater_spec.rb
+- spec/middleware/request_headers_spec.rb
 - spec/middleware/request_id_spec.rb
 - spec/middleware/selective_errors_spec.rb
 - spec/middleware/user_agent_spec.rb

data/lib/faraday/conductivity/mimetype.rb

@@ -1,17 +0,0 @@
-module Faraday
-  module Conductivity
-    class Mimetype < Faraday::Middleware
-
-      def initialize(app, options = {})
-        super(app)
-        @accept = options.fetch(:accept)
-      end
-
-      def call(env)
-        env[:request_headers]['Accept'] ||= @accept
-        @app.call(env)
-      end
-
-    end
-  end
-end

data/lib/faraday/conductivity/repeater.rb

@@ -1,61 +0,0 @@
-module Faraday
-  module Conductivity
-    class Repeater < Faraday::Middleware
-
-      PATTERNS = {
-        :rapid       => lambda { |n| 0 },
-        :one         => lambda { |n| 1 },
-        :linear      => lambda { |n| n },
-        :exponential => lambda { |n| n ** 2 },
-      }
-
-      def initialize(app, options = {})
-        @app = app
-        @retries = options[:retries] || 10
-
-        if mode = options[:mode]
-          @pattern = build_pattern(PATTERNS.fetch(mode))
-        elsif pattern = options[:pattern]
-          @pattern = build_pattern(pattern)
-        else
-          @pattern = build_pattern(PATTERNS.fetch(:exponential))
-        end
-      end
-
-      def call(env)
-        tries = 0
-        begin
-          @app.call(env)
-        rescue Faraday::Error::ClientError, SystemCallError
-          if tries < @retries
-            tries += 1
-            @pattern.wait(tries)
-            retry
-          else
-            raise
-          end
-        end
-      end
-
-      def build_pattern(pattern)
-        Pattern.new(pattern)
-      end
-
-      class Pattern
-
-        def initialize(pattern)
-          @pattern = pattern
-        end
-
-        def wait(num)
-          seconds = @pattern.call(num)
-          if seconds != 0
-            sleep num
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/spec/fake_server.rb

@@ -1,21 +0,0 @@
-count = 0
-
-get "/" do
-  200
-end
-
-delete "/" do
-  count = 0
-  200
-end
-
-get "/unreliable/:max" do |max|
-  max = Integer(max)
-  count += 1
-  if count <= max
-    sleep 5
-    "slow"
-  else
-    "fast"
-  end
-end

data/spec/middleware/mimetype_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Faraday::Conductivity::Mimetype do
-
-  subject(:request_headers) { response.env[:request_headers] }
-
-  it "includes the mimetype specified" do
-    request_headers["Accept"].should eq mimetype
-  end
-
-  let(:mimetype) { "application/vnd.users-v2+json" }
-
-  def connection
-    create_connection do |faraday|
-      faraday.request :mimetype, :accept => mimetype
-    end
-  end
-
-end

data/spec/middleware/repeater_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-describe Faraday::Conductivity::Repeater do
-
-  let(:connection) {
-    Faraday.new(url: $service_double_url) { |faraday|
-      faraday.use :repeater, mode: :rapid, retries: 6
-      faraday.response :raise_error
-      faraday.adapter Faraday.default_adapter
-    }
-  }
-
-  it "retries after timeouts" do
-    get_with_max(4).body.should eq "fast"
-  end
-
-  it "gives up after a number of retries" do
-    expect { get_with_max(20) }.to raise_error(Faraday::Error::TimeoutError)
-  end
-
-  class MyPattern
-
-    def initialize
-      @waited = []
-    end
-
-    attr_reader :waited
-
-    def wait(x)
-      waited << x
-    end
-
-  end
-
-  it "waits according to a pattern" do
-    pattern = MyPattern.new
-    Faraday::Conductivity::Repeater::Pattern.should_receive(:new).and_return(pattern)
-    get_with_max(6)
-    pattern.waited.should eq pattern.waited.sort
-  end
-
-  it "handles other errors too" do
-    connection = Faraday.new(url: "http://blabla.bla") { |faraday|
-      faraday.use :repeater, mode: :rapid, retries: 2
-      faraday.adapter Faraday.default_adapter
-    }
-
-    pattern = double :pattern
-    Faraday::Conductivity::Repeater::Pattern.should_receive(:new).and_return(pattern)
-    pattern.should_receive(:wait).with(1).ordered
-    pattern.should_receive(:wait).with(2).ordered
-
-    expect { connection.get("/") }.to raise_error(Faraday::Error::ConnectionFailed)
-  end
-
-  def get_with_max(num)
-    connection.get("/unreliable/#{num}") { |req|
-      req.options[:timeout] = 1
-      req.options[:open_timeout] = 1
-    }
-  end
-
-end