rack-idempotent 0.0.3 → 0.1.0

data/.travis.yml

@@ -1,12 +1,3 @@
 rvm:
-  - 1.8.7
   - 1.9.3
-  - rbx
-notifications:
-  recipients:
-    - drnicwilliams@gmail.com
-    - isombra@engineyard.com
-    - jhansen@engineyard.com
-branches:
-  only:
-    - master
+  - rbx-19mode

data/Gemfile

@@ -3,8 +3,9 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in rack-idempotent.gemspec
 gemspec
 
-group(:test) do
-  gem 'rake'
-  gem 'rack-client', :require => 'rack/client'
-  gem 'rspec'
+group :test do
+  gem 'guard-rspec'
+  gem "rake"
+  gem "rack-client"
+  gem "rspec", "~> 2.0"
 end

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/lib/rack-idempotent.rb

@@ -1,67 +1,54 @@
 require "rack-idempotent/version"
 
-module Rack
-  class Idempotent
-    RETRY_LIMIT = 5
-    RETRY_HTTP_CODES = [502, 503, 504]
-    IDEMPOTENT_HTTP_CODES = RETRY_HTTP_CODES + [408]
-    IDEMPOTENT_ERROR_CLASSES = [Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::EHOSTUNREACH]
+class Rack::Idempotent
+  DEFAULT_RETRY_LIMIT = 5
 
-    class RetryLimitExceeded < StandardError
-      attr_reader :idempotent_exceptions
-      def initialize(idempotent_exceptions)
-        @idempotent_exceptions = idempotent_exceptions
-      end
-    end
+  # Retry policies
+  autoload :ImmediateRetry, 'rack-idempotent/immediate_retry'
+  autoload :ExponentialBackoff, 'rack-idempotent/exponential_backoff'
 
-    class HTTPException < StandardError
-      attr_reader :status, :headers, :body
-      def initialize(status, headers, body)
-        @status, @headers, @body = status, headers, body
-      end
+  # Rescue policies
+  autoload :DefaultRescue, 'rack-idempotent/default_rescue'
 
-      def to_s
-        @status.to_s
-      end
-    end
+  # Exceptions
+  autoload :HTTPException, 'rack-idempotent/http_exception'
+  autoload :RetryLimitExceeded, 'rack-idempotent/retry_limit_exceeded'
+  autoload :Retryable, 'rack-idempotent/retryable'
 
-    class Retryable < StandardError
-    end
+  attr_reader :retry_policy, :rescue_policy
 
-    def initialize(app)
-      @app= app
-    end
+  def initialize(app, options={})
+    @app           = app
+    @retry_policy  = options[:retry] || Rack::Idempotent::ImmediateRetry.new
+    @rescue_policy = options[:rescue] || Rack::Idempotent::DefaultRescue.new
+  end
+
+  def call(env)
+    request = Rack::Request.new(env)
+    response = nil
+    exception = nil
+    while true
+      retry_policy.call(request, response, exception) if response || exception
+      response, exception = nil
 
-    def call(env)
-      env['client.retries'] = 0
-      status, headers, body = nil
-      idempotent_exceptions = []
       begin
-        dup_env = env.dup
-        status, headers, body = @app.call(dup_env)
-        raise HTTPException.new(status, headers, body) if IDEMPOTENT_HTTP_CODES.include?(status)
-        env.merge!(dup_env)
-        [status, headers, body]
-      rescue *(IDEMPOTENT_ERROR_CLASSES + [HTTPException, Retryable]) => ie
-        idempotent_exceptions << ie
-        if env['client.retries'] > RETRY_LIMIT - 1
-          raise(RetryLimitExceeded.new(idempotent_exceptions))
-        else
-          if retry?(status, env["REQUEST_METHOD"])
-            env['client.retries'] += 1
-            retry
-          else
-            raise
-          end
+        status, headers, body = @app.call(env.dup)
+        raise HTTPException.new(status, headers, body, request) if status >= 400
+        response = Rack::Response.new(body, status, headers)
+        next if rescue_policy.call({:response => response, :request => request})
+        return [status, headers, body]
+      rescue Rack::Idempotent::Retryable => exception
+        request.env["idempotent.requests.exceptions"] ||= []
+        request.env["idempotent.requests.exceptions"] << exception
+        next
+      rescue => exception
+        if rescue_policy.call({:exception => exception, :request => request})
+          request.env["idempotent.requests.exceptions"] ||= []
+          request.env["idempotent.requests.exceptions"] << exception
+          next
         end
+        raise
       end
     end
-
-  private
-
-  def retry?(response_status, request_method)
-    RETRY_HTTP_CODES.include?(response_status) || request_method == "GET"
-  end
-
   end
 end

data/lib/rack-idempotent/default_rescue.rb

@@ -0,0 +1,35 @@
+class Rack::Idempotent::DefaultRescue
+  GET_RETRY_HTTP_CODES = [408, 502, 503, 504]
+  POST_RETRY_HTTP_CODES = [502, 503, 504]
+  IDEMPOTENT_ERROR_CLASSES = [Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::EHOSTUNREACH]
+
+  def call(options={})
+    exception = options[:exception]
+    status = nil
+    method = nil
+
+    if exception
+      if IDEMPOTENT_ERROR_CLASSES.include?(exception.class)
+        return true
+      elsif exception.class == Rack::Idempotent::HTTPException
+        status = exception.status
+        method = exception.request.env["REQUEST_METHOD"]
+      else
+        return false
+      end
+    end
+
+    unless status && method
+      status = options[:response].status
+      method = options[:request].env["REQUEST_METHOD"]
+    end
+
+    if method == "GET"
+      GET_RETRY_HTTP_CODES.include?(status)
+    elsif method == "POST"
+      POST_RETRY_HTTP_CODES.include?(status)
+    else
+      false
+    end
+  end
+end

data/lib/rack-idempotent/exponential_backoff.rb

@@ -0,0 +1,30 @@
+class Rack::Idempotent::ExponentialBackoff
+  attr_reader :max_retries, :max_retry_interval, :min_retry_interval
+
+  def initialize(options={})
+    @max_retries = options[:max_retries] || Rack::Idempotent::DEFAULT_RETRY_LIMIT
+    @min_retry_interval = options[:min_retry_interval] || 0.5
+    @max_retry_interval = options[:max_retry_interval] || 1800
+  end
+
+  def call(request, response, exception)
+    request.env["idempotent.requests.count"] ||= 0
+    request.env["idempotent.requests.count"] += 1
+    request.env["idempotent.requests.sleep"] ||= (@min_retry_interval / 2)
+    request.env["idempotent.requests.sleep"] *= 2
+
+    if request.env["idempotent.requests.sleep"] > @max_retry_interval
+      request.env["idempotent.requests.sleep"] = @max_retry_interval
+    end
+    if request.env["idempotent.requests.count"] >= @max_retries
+      raise Rack::Idempotent::RetryLimitExceeded.new(
+        request.env["idempotent.requests.exceptions"]
+      )
+    end
+    delay(request.env["idempotent.requests.sleep"])
+  end
+
+  def delay(secs)
+    sleep(secs)
+  end
+end

data/lib/rack-idempotent/http_exception.rb

@@ -0,0 +1,10 @@
+class Rack::Idempotent::HTTPException < StandardError
+  attr_reader :status, :headers, :body, :request
+  def initialize(status, headers, body, request)
+    @status, @headers, @body, @request = status, headers, body, request
+  end
+
+  def to_s
+    @status.to_s
+  end
+end

data/lib/rack-idempotent/immediate_retry.rb

@@ -0,0 +1,18 @@
+class Rack::Idempotent::ImmediateRetry
+  attr_reader :max_retries
+
+  def initialize(options={})
+    @max_retries = options[:max_retries] || Rack::Idempotent::DEFAULT_RETRY_LIMIT
+  end
+
+  def call(request, response, exception)
+    request.env["idempotent.requests.count"] ||= 0
+    request.env["idempotent.requests.count"] += 1
+
+    if request.env["idempotent.requests.count"] >= max_retries
+      raise Rack::Idempotent::RetryLimitExceeded.new(
+        request.env["idempotent.requests.exceptions"]
+      )
+    end
+  end
+end

data/lib/rack-idempotent/retry_limit_exceeded.rb

@@ -0,0 +1,7 @@
+class Rack::Idempotent::RetryLimitExceeded < StandardError
+  attr_reader :idempotent_exceptions
+
+  def initialize(idempotent_exceptions)
+    @idempotent_exceptions = idempotent_exceptions
+  end
+end

data/lib/rack-idempotent/retryable.rb

@@ -0,0 +1,2 @@
+class Rack::Idempotent::Retryable < StandardError
+end

data/lib/rack-idempotent/version.rb

@@ -1,5 +1,5 @@
 module Rack
   class Idempotent
-    VERSION = "0.0.3"
+    VERSION = "0.1.0"
   end
 end

data/rack-idempotent.gemspec

@@ -2,10 +2,10 @@
 require File.expand_path('../lib/rack-idempotent/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Ines Sombra"]
-  gem.email         = ["isombra@engineyard.com"]
-  gem.description   = %q{Retry logic for rack-client}
-  gem.summary       = %q{Retry logic for rack-client}
+  gem.authors       = ["Engine Yard"]
+  gem.email         = ["engineering@engineyard.com"]
+  gem.description   = %q{Idempotent Rack middleware}
+  gem.summary       = %q{Retry middleware for Rack clients}
   gem.homepage      = ""
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }

data/spec/rack-idempotent/default_rescue_spec.rb

@@ -0,0 +1,150 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Rack::Idempotent do
+  before(:each) do
+    TestCall.errors = []
+    RecordRequests.reset
+  end
+  let(:client) do
+    Rack::Client.new do
+      use Rack::Lint
+      use Rack::Idempotent, {:rescue => Rack::Idempotent::DefaultRescue.new}
+      use Rack::Lint
+      use RecordRequests
+      run TestCall
+    end
+  end
+
+  describe "using Rack::Idempotent::DefaultRescue" do
+    [408, 502, 503, 504].each do |status|
+      it "should retry GET requests that result in #{status}" do
+        TestCall.errors = [status]
+        client.get("http://example.org/")
+
+        RecordRequests.requests.count.should == 2
+
+        RecordRequests.responses.count.should == 2
+        RecordRequests.responses[0][0].should == status
+        RecordRequests.responses[1][0].should == 200
+      end
+    end
+
+    [200, 201, 301, 302, 400, 401, 403, 404, 500].each do |status|
+      it "should not retry GET requests that result in #{status}" do
+        TestCall.errors = [status]
+        begin
+          client.get("http://example.org/")
+          status.should < 400
+        rescue Rack::Idempotent::HTTPException => e
+          e.status.should == status
+          e.status.should >= 400
+        end
+        RecordRequests.requests.count.should == 1
+      end
+    end
+
+    [502, 503, 504].each do |status|
+      it "should retry POST requests that result in #{status}" do
+        TestCall.errors = [status]
+        client.post("http://example.org/")
+
+        RecordRequests.requests.count.should == 2
+
+        RecordRequests.responses.count.should == 2
+        RecordRequests.responses[0][0].should == status
+        RecordRequests.responses[1][0].should == 200
+      end
+    end
+
+    [200, 201, 301, 302, 400, 401, 403, 404, 408, 500].each do |status|
+      it "should not retry POST requests that result in #{status}" do
+        TestCall.errors = [status]
+        begin
+          client.post("http://example.org/")
+          status.should < 400
+        rescue Rack::Idempotent::HTTPException => e
+          e.status.should == status
+          e.status.should >= 400
+        end
+        RecordRequests.requests.count.should == 1
+      end
+    end
+
+    it "should not retry HEAD requests" do
+      TestCall.errors = [503]
+      begin
+        client.head("http://example.org/")
+      rescue Rack::Idempotent::HTTPException => e
+        e.status.should == 503
+      end
+      RecordRequests.requests.count.should == 1
+    end
+
+    it "should retry if it gets more than one unsuccesful response" do
+      TestCall.errors = [503, 504]
+      client.get("http://example.org/")
+
+      RecordRequests.requests.count.should == 3
+
+      RecordRequests.responses.count.should == 3
+      RecordRequests.responses[0][0].should == 503
+      RecordRequests.responses[1][0].should == 504
+      RecordRequests.responses[2][0].should == 200
+    end
+
+    it "should raise RetryLimitExceeded when the request fails too many times" do
+      retry_limit = Rack::Idempotent::DEFAULT_RETRY_LIMIT
+      TestCall.errors = (retry_limit + 1).times.map {|i| 503}
+      lambda {
+        client.get("http://example.org/")
+      }.should raise_exception Rack::Idempotent::RetryLimitExceeded
+      RecordRequests.requests.count.should == retry_limit
+      RecordRequests.responses.count.should == retry_limit
+    end
+    
+    [Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::EHOSTUNREACH].each do |ex|
+      it "should retry requests that result in #{ex}" do
+        TestCall.errors = [ex]
+        client.get("http://example.org/")
+
+        RecordRequests.requests.count.should == 2
+        exceptions = RecordRequests.requests.last["idempotent.requests.exceptions"]
+        exceptions.count.should == 1
+        exceptions.first.class.should == ex
+      end
+    end
+    
+    [Errno::EHOSTDOWN, Errno::ECONNRESET, Errno::ENETRESET].each do |ex|
+      it "should not retry requests that result in #{ex}" do
+        TestCall.errors = [ex]
+        lambda {
+          client.get("http://example.org/")
+        }.should raise_exception ex
+        RecordRequests.requests.count.should == 1
+      end
+    end
+
+    it "should retry if the connection times out more than once" do
+      TestCall.errors = [Errno::ETIMEDOUT, Errno::ETIMEDOUT]
+      client.get("http://example.org/")
+
+      RecordRequests.requests.count.should == 3
+      exceptions = RecordRequests.requests.last["idempotent.requests.exceptions"]
+      exceptions.count.should == 2
+      exceptions.first.class.should == Errno::ETIMEDOUT
+
+      RecordRequests.responses.count.should == 3
+      RecordRequests.responses.last[0].should == 200
+    end
+
+    it "should raise RetryLimitExceeded when the connection times out too many times" do
+      retry_limit = Rack::Idempotent::DEFAULT_RETRY_LIMIT
+      TestCall.errors = (retry_limit + 1).times.map {|i| Errno::ETIMEDOUT}
+      lambda {
+        client.get("http://example.org/")
+      }.should raise_exception Rack::Idempotent::RetryLimitExceeded
+      RecordRequests.requests.count.should == retry_limit
+      RecordRequests.responses.count.should == retry_limit
+    end
+  end
+end

data/spec/rack-idempotent/exponential_backoff_spec.rb

@@ -0,0 +1,164 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Rack::Idempotent do
+  class SleepMonitor
+    class << self
+      attr_accessor :sleeps
+    end
+    def self.delay(secs)
+      self.sleeps << secs
+    end
+    def self.reset
+      self.sleeps = []
+    end
+  end
+
+  before(:each) do
+    TestCall.errors = []
+    RecordRequests.reset
+    SleepMonitor.reset
+  end
+
+  class Rack::Idempotent::ExponentialBackoff
+    def delay(secs)
+      SleepMonitor.delay(secs)
+    end
+  end
+
+  configurations = {
+    'defaults' => {},
+    'custom max_retries' => {:max_retries => 50},
+    'custom min_retry_interval' => {:min_retry_interval => 0.1},
+    'custom max_retry_interval' => {:max_retry_interval => 86400},
+  }
+
+  configurations.each_pair do |name,opts|
+    describe "using Rack::Idempotent::ExponentialBackoff with #{name}" do
+      let(:client) do
+        Rack::Client.new do
+          use Rack::Lint
+          use Rack::Idempotent, {
+            :retry => Rack::Idempotent::ExponentialBackoff.new(opts)
+          }
+          use Rack::Lint
+          use RecordRequests
+          run TestCall
+        end
+      end
+      it "should not retry if succesful response" do
+        client.get("http://example.org/")
+        RecordRequests.requests.count.should == 1
+      end
+
+      it "should retry if it gets one unsuccesful response" do
+        TestCall.errors = [503]
+        client.get("http://example.org/")
+
+        RecordRequests.requests.count.should == 2
+
+        RecordRequests.responses.count.should == 2
+        RecordRequests.responses[0][0].should == 503
+        RecordRequests.responses[1][0].should == 200
+      end
+
+      it "should retry if it gets more than one unsuccesful response" do
+        TestCall.errors = [503, 504]
+        client.get("http://example.org/")
+
+        RecordRequests.requests.count.should == 3
+
+        RecordRequests.responses.count.should == 3
+        RecordRequests.responses[0][0].should == 503
+        RecordRequests.responses[1][0].should == 504
+        RecordRequests.responses[2][0].should == 200
+      end
+
+      it "should raise RetryLimitExceeded when the request fails too many times" do
+        retry_limit = rack_idempotent(client).retry_policy.max_retries
+        TestCall.errors = (retry_limit + 1).times.map {|i| 503}
+        lambda {
+          client.get("http://example.org/")
+        }.should raise_exception Rack::Idempotent::RetryLimitExceeded
+        RecordRequests.requests.count.should == retry_limit
+        RecordRequests.responses.count.should == retry_limit
+      end
+
+      it 'should sleep between retries' do
+        TestCall.errors = [503]
+        client.get("http://example.org/")
+        SleepMonitor.sleeps.count.should == 1
+      end
+
+      it 'should sleep for increasingly longer times' do
+        retry_limit = rack_idempotent(client).retry_policy.max_retries
+        max_retry_interval = rack_idempotent(client).retry_policy.max_retry_interval
+        TestCall.errors = (retry_limit + 1).times.map {|i| 503}
+        begin
+          client.get("http://example.org/")
+        rescue Rack::Idempotent::RetryLimitExceeded
+          # Ignore, this should be thrown
+        ensure
+          SleepMonitor.sleeps.count.should == retry_limit - 1
+          SleepMonitor.sleeps.each_index do |i|
+            if i > 0
+              expected = SleepMonitor.sleeps[i - 1]
+            else
+              expected = 0
+            end
+            if expected < max_retry_interval
+              SleepMonitor.sleeps[i].should > expected
+            else
+              SleepMonitor.sleeps[i].should == max_retry_interval
+            end
+          end
+        end
+      end
+
+      it 'should always use min_retry_interval as the first sleep' do
+        retry_limit = rack_idempotent(client).retry_policy.max_retries
+        min_retry_interval = rack_idempotent(client).retry_policy.min_retry_interval
+        TestCall.errors = (retry_limit + 1).times.map {|i| 503}
+        begin
+          client.get("http://example.org/")
+        rescue Rack::Idempotent::RetryLimitExceeded
+          # Ignore, this should be thrown
+        ensure
+          SleepMonitor.sleeps.count.should == retry_limit - 1
+          SleepMonitor.sleeps.first.should == min_retry_interval
+        end
+      end
+
+      it 'should never sleep shorter than min_retry_interval' do
+        retry_limit = rack_idempotent(client).retry_policy.max_retries
+        min_retry_interval = rack_idempotent(client).retry_policy.min_retry_interval
+        TestCall.errors = (retry_limit + 1).times.map {|i| 503}
+        begin
+          client.get("http://example.org/")
+        rescue Rack::Idempotent::RetryLimitExceeded
+          # Ignore, this should be thrown
+        ensure
+          SleepMonitor.sleeps.count.should == retry_limit - 1
+          SleepMonitor.sleeps.each do |sleep|
+            sleep.should >= min_retry_interval
+          end
+        end
+      end
+
+      it 'should never sleep longer than max_retry_interval' do
+        retry_limit = rack_idempotent(client).retry_policy.max_retries
+        max_retry_interval = rack_idempotent(client).retry_policy.max_retry_interval
+        TestCall.errors = (retry_limit + 1).times.map {|i| 503}
+        begin
+          client.get("http://example.org/")
+        rescue Rack::Idempotent::RetryLimitExceeded
+          # Ignore, this should be thrown
+        ensure
+          SleepMonitor.sleeps.count.should == retry_limit - 1
+          SleepMonitor.sleeps.each do |sleep|
+            sleep.should <= max_retry_interval
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rack-idempotent/immediate_retry_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Rack::Idempotent do
+  before(:each) do
+    TestCall.errors = []
+    RecordRequests.reset
+  end
+
+  configurations = {
+    "defaults" => {},
+    "custom max_retries" => {:max_retries => 50},
+  }
+
+  configurations.each_pair do |name,opts|
+    describe "using Rack::Idempotent::ImmediateRetry with #{name}" do
+      let(:client) do
+        Rack::Client.new do
+          use Rack::Lint
+          use Rack::Idempotent, {
+            :retry => Rack::Idempotent::ImmediateRetry.new(opts)
+          }
+          use Rack::Lint
+          use RecordRequests
+          run TestCall
+        end
+      end
+
+      it "should not retry if succesful response" do
+        client.get("http://example.org/")
+        RecordRequests.requests.count.should == 1
+      end
+
+      it "should retry if it gets one unsuccesful response" do
+        TestCall.errors = [503]
+        client.get("http://example.org/")
+
+        RecordRequests.requests.count.should == 2
+
+        RecordRequests.responses.count.should == 2
+        RecordRequests.responses[0][0].should == 503
+        RecordRequests.responses[1][0].should == 200
+      end
+
+      it "should retry if it gets more than one unsuccesful response" do
+        TestCall.errors = [503, 504]
+        client.get("http://example.org/")
+
+        RecordRequests.requests.count.should == 3
+
+        RecordRequests.responses.count.should == 3
+        RecordRequests.responses[0][0].should == 503
+        RecordRequests.responses[1][0].should == 504
+        RecordRequests.responses[2][0].should == 200
+      end
+
+      it "should raise RetryLimitExceeded when the request fails too many times" do
+        retry_limit = rack_idempotent(client).retry_policy.max_retries
+        TestCall.errors = (retry_limit + 1).times.map {|i| 503}
+        lambda {
+          client.get("http://example.org/")
+        }.should raise_exception Rack::Idempotent::RetryLimitExceeded
+        RecordRequests.requests.count.should == retry_limit
+        RecordRequests.responses.count.should == retry_limit
+      end
+    end
+  end
+end

data/spec/rack-idempotent_spec.rb

@@ -1,120 +1,217 @@
 require 'spec_helper'
 
 describe Rack::Idempotent do
-  class CaptureEnv
-    class << self; attr_accessor :env; end
-    def initialize(app); @app=app; end
-    def call(env)
-      @app.call(env)
-    ensure
-      self.class.env = env
-    end
-  end
-  class RaiseUp
-    class << self; attr_accessor :errors; end
-    def self.call(env)
-      error = self.errors.shift
-      raise error if error.is_a?(Class)
-      status_code = error || 200
-      [status_code, {}, []]
-    end
+  before(:each) do
+    TestCall.errors = []
+    RecordRequests.reset
   end
-
-  before(:each){ CaptureEnv.env = nil }
   let(:client) do
     Rack::Client.new do
-      use CaptureEnv
+      use Rack::Lint
       use Rack::Idempotent
-      run RaiseUp
+      use Rack::Lint
+      use RecordRequests
+      run TestCall
     end
   end
 
-  it "should retry Errno::ETIMEDOUT" do
-    RaiseUp.errors = [Errno::ETIMEDOUT, Errno::ETIMEDOUT]
-    client.get("/doesntmatter")
-
-    env = CaptureEnv.env
-    env['client.retries'].should == 2
-  end
+  describe "with defaults" do
+    it "should not retry if succesful response" do
+      client.get("http://example.org/")
+      RecordRequests.requests.count.should == 1
+    end
 
-  it "should retry Rack::Idempotent::Retryable" do
-    RaiseUp.errors = [Rack::Idempotent::Retryable, Rack::Idempotent::Retryable]
-    client.get("/alsodoesntmatter")
+    it "should retry if it gets one unsuccesful response" do
+      TestCall.errors = [503]
+      client.get("http://example.org/")
 
-    env = CaptureEnv.env
-    env['client.retries'].should == 2
-  end
+      RecordRequests.requests.count.should == 2
 
-  it "should raise Rack::Idempotent::RetryLimitExceeded when retry limit is reached" do
-    RaiseUp.errors = (Rack::Idempotent::RETRY_LIMIT + 1).times.map{|i| Errno::ETIMEDOUT}
+      RecordRequests.responses.count.should == 2
+      RecordRequests.responses[0][0].should == 503
+      RecordRequests.responses[1][0].should == 200
+    end
 
-    lambda { client.get("/doesntmatter") }.should raise_exception(Rack::Idempotent::RetryLimitExceeded)
+    it "should retry if it gets more than one unsuccesful response" do
+      TestCall.errors = [503, 504]
+      client.get("http://example.org/")
 
-    env = CaptureEnv.env
-    env['client.retries'].should == Rack::Idempotent::RETRY_LIMIT
-  end
+      RecordRequests.requests.count.should == 3
 
-  [502, 503, 504, 408].each do |code|
-    it "retries GET #{code}" do
-      RaiseUp.errors = [code]
-      client.get("/something")
-      env = CaptureEnv.env
-      env['client.retries'].should == 1
+      RecordRequests.responses.count.should == 3
+      RecordRequests.responses[0][0].should == 503
+      RecordRequests.responses[1][0].should == 504
+      RecordRequests.responses[2][0].should == 200
     end
-  end
 
-  [502, 503, 504].each do |code|
-    it "retries POST #{code}" do
-      RaiseUp.errors = [code]
-      client.post("/something")
-      env = CaptureEnv.env
-      env['client.retries'].should == 1
+    it "should raise RetryLimitExceeded when the request fails too many times" do
+      retry_limit = Rack::Idempotent::DEFAULT_RETRY_LIMIT
+      TestCall.errors = (retry_limit + 1).times.map {|i| 503}
+      lambda {
+        client.get("http://example.org/")
+      }.should raise_exception Rack::Idempotent::RetryLimitExceeded
+      RecordRequests.requests.count.should == retry_limit
+      RecordRequests.responses.count.should == retry_limit
     end
-  end
 
-  it "doesn't retry POST when return code is 408" do
-    RaiseUp.errors = [408]
-    lambda do
-      client.post("/something")
-    end.should raise_error(Rack::Idempotent::HTTPException)
-    env = CaptureEnv.env
-    env['client.retries'].should == 0
-  end
+    it "should retry if the connection times out once" do
+      TestCall.errors = [Errno::ETIMEDOUT]
+      client.get("http://example.org/")
 
-  it "should be able to rescue http exception via standard error" do
-    RaiseUp.errors = [408]
+      RecordRequests.requests.count.should == 2
+      exceptions = RecordRequests.requests.last["idempotent.requests.exceptions"]
+      exceptions.count.should == 1
+      exceptions.first.class.should == Errno::ETIMEDOUT
 
-    begin
-      client.post("/something")
-    rescue => e
-      # works
+      RecordRequests.responses.count.should == 2
+      RecordRequests.responses.last[0].should == 200
     end
-  end
 
-  it "should store exceptions raised" do
-    RaiseUp.errors = [502, Errno::ECONNREFUSED, 408, 504, Errno::EHOSTUNREACH, Errno::ETIMEDOUT]
-    errors = RaiseUp.errors.dup
-    exception = nil
+    it "should retry if the connection times out more than once" do
+      TestCall.errors = [Errno::ETIMEDOUT, Errno::ETIMEDOUT]
+      client.get("http://example.org/")
+
+      RecordRequests.requests.count.should == 3
+      exceptions = RecordRequests.requests.last["idempotent.requests.exceptions"]
+      exceptions.count.should == 2
+      exceptions.first.class.should == Errno::ETIMEDOUT
 
-    begin
-      client.get("/doesntmatter")
-    rescue Rack::Idempotent::RetryLimitExceeded => e
-      exception = e
+      RecordRequests.responses.count.should == 3
+      RecordRequests.responses.last[0].should == 200
     end
 
-    exception.should_not be_nil
-    exception.idempotent_exceptions.size.should == 6
-    exception.idempotent_exceptions.map{|ie| ie.is_a?(Rack::Idempotent::HTTPException) ? ie.status : ie.class}.should == errors
-  end
+    it "should raise RetryLimitExceeded when the connection times out too many times" do
+      retry_limit = Rack::Idempotent::DEFAULT_RETRY_LIMIT
+      TestCall.errors = (retry_limit + 1).times.map {|i| Errno::ETIMEDOUT}
+      lambda {
+        client.get("http://example.org/")
+      }.should raise_exception Rack::Idempotent::RetryLimitExceeded
+      RecordRequests.requests.count.should == retry_limit
+      RecordRequests.responses.count.should == retry_limit
+    end
 
-  it "should be able to rescue retry limit exceeded via standard error" do
-    RaiseUp.errors = (0...Rack::Idempotent::RETRY_LIMIT.succ).map{|_| 503 }
+    describe "does what the README says it does and" do
+      it 'has a retry limit of 5' do
+        Rack::Idempotent::DEFAULT_RETRY_LIMIT.should == 5
+      end
+
+      [Errno::ETIMEDOUT, Errno::ECONNREFUSED, Errno::EHOSTUNREACH].each do |e|
+        it "retries on #{e}" do
+          TestCall.errors = [e]
+          client.get("http://example.org/")
+
+          RecordRequests.requests.count.should == 2
+          exceptions = RecordRequests.requests.last["idempotent.requests.exceptions"]
+          exceptions.count.should == 1
+          exceptions.first.class.should == e
+
+          RecordRequests.responses.count.should == 2
+          RecordRequests.responses.last[0].should == 200
+        end
+      end
+
+      [408, 502, 503, 504].each do |status|
+        it "retries on #{status}" do
+          TestCall.errors = [status]
+          client.get("http://example.org/")
+
+          RecordRequests.requests.count.should == 2
+
+          RecordRequests.responses.count.should == 2
+          RecordRequests.responses[0][0].should == status
+          RecordRequests.responses[1][0].should == 200
+        end
+      end
+
+      it 'raises RetryLimitExceeded if the retry limit is exceeded' do
+        retry_limit = Rack::Idempotent::DEFAULT_RETRY_LIMIT
+        TestCall.errors = (retry_limit + 1).times.map {|i| 408}
+        lambda {
+          client.get("http://example.org/")
+        }.should raise_exception Rack::Idempotent::RetryLimitExceeded
+        RecordRequests.requests.count.should == retry_limit
+        RecordRequests.responses.count.should == retry_limit
+      end
+
+      it 'stores any exceptions raised in RetryLimitExceeded.idempotent_exceptions' do
+        retry_limit = Rack::Idempotent::DEFAULT_RETRY_LIMIT
+        TestCall.errors = (retry_limit + 1).times.map {|i| Errno::ETIMEDOUT}
+        lambda {
+          begin
+            client.get("http://example.org/")
+          rescue Rack::Idempotent::RetryLimitExceeded => e
+            e.idempotent_exceptions.should_not be_nil
+            exceptions = e.idempotent_exceptions
+            exceptions.count.should == retry_limit
+            exceptions.each do |ex|
+              ex.class.should == Errno::ETIMEDOUT
+            end
+            raise
+          end
+        }.should raise_exception Rack::Idempotent::RetryLimitExceeded
+
+        RecordRequests.requests.count.should == retry_limit
+        RecordRequests.responses.count.should == retry_limit
+      end
+    end
 
-    begin
-      res = client.get("/doesntmatter")
-    rescue => e
-      # works
+    describe "does what v0.0.3 does and" do
+      [502, 503, 504].each do |status|
+        it "retries POST requests if the status is #{status}" do
+          TestCall.errors = [status]
+          client.post("http://example.org/")
+
+          RecordRequests.requests.count.should == 2
+
+          RecordRequests.responses.count.should == 2
+          RecordRequests.responses[0][0].should == status
+          RecordRequests.responses[1][0].should == 200
+        end
+      end
+
+      it 'does not retry a POST if the status is 408' do
+        TestCall.errors = [408]
+        lambda {
+          client.post("http://example.org/")
+        }.should raise_exception Rack::Idempotent::HTTPException
+
+        RecordRequests.requests.count.should == 1
+
+        RecordRequests.responses.count.should == 1
+        RecordRequests.responses[0][0].should == 408
+      end
+
+      it 'retries if a Rack::Idempotent::Retryable exception is thrown' do
+        TestCall.errors = [Rack::Idempotent::Retryable]
+        client.get("http://example.org/")
+
+        RecordRequests.requests.count.should == 2
+        exceptions = RecordRequests.requests.last["idempotent.requests.exceptions"]
+        exceptions.count.should == 1
+        exceptions.first.class.should == Rack::Idempotent::Retryable
+
+        RecordRequests.responses.count.should == 2
+        RecordRequests.responses.last[0].should == 200
+      end
+
+      it 'is able to rescue http exception via standard error' do
+        TestCall.errors = [400]
+        begin
+          client.post("http://example.org/")
+        rescue => e
+          e.class.should == Rack::Idempotent::HTTPException
+        end
+      end
+
+      it 'is able to rescue retry limit exceeded via standard error' do
+        retry_limit = Rack::Idempotent::DEFAULT_RETRY_LIMIT
+        TestCall.errors = (retry_limit + 1).times.map {|i| Errno::ETIMEDOUT}
+        begin
+          client.post("http://example.org/")
+        rescue => e
+          e.class.should == Rack::Idempotent::RetryLimitExceeded
+        end
+      end
     end
   end
-
 end

data/spec/spec_helper.rb

@@ -1,3 +1,51 @@
+require File.expand_path("../../lib/rack-idempotent", __FILE__)
+
 Bundler.require(:test)
 
-require File.expand_path("../../lib/rack-idempotent", __FILE__)
+class RecordRequests
+  class << self
+    attr_accessor :requests
+    attr_accessor :responses
+
+    def reset
+      self.requests = []
+      self.responses = []
+    end
+  end
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    response = @app.call(env)
+  ensure
+    self.class.requests << env
+    self.class.responses << response
+  end
+end
+
+class TestCall
+  class << self
+    attr_accessor :errors
+  end
+
+  def self.call(env)
+    error = nil
+    if self.errors
+      error = self.errors.shift
+      raise error if error.is_a?(Class)
+    end
+    status_code = error || 200
+    [status_code, {"Content-Type" => "text/plain"}, []]
+  end
+end
+
+def rack_idempotent(client)
+  while true
+    if client.class == Rack::Idempotent
+      return client
+    end
+    client = client.instance_eval { @app }
+  end
+end

metadata

@@ -1,77 +1,71 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: rack-idempotent
-version: !ruby/object:Gem::Version 
-  hash: 25
+version: !ruby/object:Gem::Version
+  version: 0.1.0
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 3
-  version: 0.0.3
 platform: ruby
-authors: 
-- Ines Sombra
+authors:
+- Engine Yard
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-02-09 00:00:00 Z
+date: 2013-02-21 00:00:00.000000000 Z
 dependencies: []
-
-description: Retry logic for rack-client
-email: 
-- isombra@engineyard.com
+description: Idempotent Rack middleware
+email:
+- engineering@engineyard.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .travis.yml
 - Gemfile
+- Guardfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/rack-idempotent.rb
+- lib/rack-idempotent/default_rescue.rb
+- lib/rack-idempotent/exponential_backoff.rb
+- lib/rack-idempotent/http_exception.rb
+- lib/rack-idempotent/immediate_retry.rb
+- lib/rack-idempotent/retry_limit_exceeded.rb
+- lib/rack-idempotent/retryable.rb
 - lib/rack-idempotent/version.rb
 - rack-idempotent.gemspec
+- spec/rack-idempotent/default_rescue_spec.rb
+- spec/rack-idempotent/exponential_backoff_spec.rb
+- spec/rack-idempotent/immediate_retry_spec.rb
 - spec/rack-idempotent_spec.rb
 - spec/spec_helper.rb
-homepage: ""
+homepage: ''
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
-summary: Retry logic for rack-client
-test_files: 
+summary: Retry middleware for Rack clients
+test_files:
+- spec/rack-idempotent/default_rescue_spec.rb
+- spec/rack-idempotent/exponential_backoff_spec.rb
+- spec/rack-idempotent/immediate_retry_spec.rb
 - spec/rack-idempotent_spec.rb
 - spec/spec_helper.rb