prop 1.0.0 → 1.0.1

data/Gemfile

@@ -1,3 +1,3 @@
-source "http://rubygems.org"
+source 'https://rubygems.org'
 
 gemspec

data/README.md

@@ -3,73 +3,95 @@
 
 Prop is a simple gem for rate limiting requests of any kind. It allows you to configure hooks for registering certain actions, such that you can define thresholds, register usage and finally act on exceptions once thresholds get exceeded.
 
-Prop uses and interval to define a window of time using simple div arithmetic. This means that it's a worst case throttle that will allow up to 2 times the specified requests within the specified interval.
+Prop uses an interval to define a window of time using simple div arithmetic. This means that it's a worst-case throttle that will allow up to two times the specified requests within the specified interval.
 
-To get going with Prop you first define the read and write operations. These define how you write a registered request and how to read the number of requests for a given action. For example do something like the below in a Rails initializer:
+To get going with Prop, you first define the read and write operations. These define how you write a registered request and how to read the number of requests for a given action. For example, do something like the below in a Rails initializer:
 
-    Prop.read do |key|
-      Rails.cache.read(key)
-    end
+```ruby
+Prop.read do |key|
+  Rails.cache.read(key)
+end
 
-    Prop.write do |key, value|
-      Rails.cache.write(key, value)
-    end
+Prop.write do |key, value|
+  Rails.cache.write(key, value)
+end
+```
 
 You can choose to rely on whatever you'd like to use for transient storage. Prop does not do any sort of clean up of its key space, so you would have to implement that manually should you be using anything but an LRU cache like memcached.
 
+## Setting a Callback
+
+You can define an optional callback that is invoked when a rate limit is reached. In a Rails application you could use such a handler to add notification support:
+
+```ruby
+Prop.before_throttle do |handle, key, threshold, interval|
+  ActiveSupport::Notifications.instrument('throttle.prop', handle: handle, key: key, threshold: threshold, interval: interval)
+end
+```
+
 ## Defining thresholds
 
-Once the read and write operations are defined, you can optionally define thresholds. If for example, you want to have a threshold on accepted emails per hour from a given user, you could define a threshold and interval (in seconds) for this like so:
+Once the read and write operations are defined, you can optionally define thresholds. If, for example, you want to have a threshold on accepted emails per hour from a given user, you could define a threshold and interval (in seconds) for this like so:
 
-    Prop.configure(:mails_per_hour, :threshold => 100, :interval => 1.hour, :description => "Mail rate limit exceeded")
+```ruby
+Prop.configure(:mails_per_hour, :threshold => 100, :interval => 1.hour, :description => "Mail rate limit exceeded")
+```
 
-The `:mails_per_hour` in the above is called the "handle". You can now put the throttle to work with this values, by passing the handle to the respective methods in Prop:
+The `:mails_per_hour` in the above is called the "handle". You can now put the throttle to work with these values, by passing the handle to the respective methods in Prop:
 
-    # Throws Prop::RateLimitExceededError if the threshold/interval has been reached
-    Prop.throttle!(:mails_per_hour)
+```ruby
+# Throws Prop::RateLimitExceededError if the threshold/interval has been reached
+Prop.throttle!(:mails_per_hour)
 
-    # Prop can be used to guard a block of code
-    Prop.throttle!(:expensive_request) { calculator.something_very_hard }
+# Prop can be used to guard a block of code
+Prop.throttle!(:expensive_request) { calculator.something_very_hard }
 
-    # Returns true if the threshold/interval has been reached
-    Prop.throttled?(:mails_per_hour)
+# Returns true if the threshold/interval has been reached
+Prop.throttled?(:mails_per_hour)
 
-    # Sets the throttle "count" to 0
-    Prop.reset(:mails_per_hour)
+# Sets the throttle "count" to 0
+Prop.reset(:mails_per_hour)
 
-    # Returns the value of this throttle, usually a count, but see below for more
-    Prop.count(:mails_per_hour)
+# Returns the value of this throttle, usually a count, but see below for more
+Prop.count(:mails_per_hour)
+```
 
-Prop will raise a RuntimeError if you attempt to operate on an undefined handle.
+Prop will raise a `RuntimeError` if you attempt to operate on an undefined handle.
 
 ## Scoping a throttle
 
-In many cases you will want to tie a specific key to a defined throttle, for example you can scope the throttling to a specific sender rather than running a global "mails per hour" throttle:
+In many cases you will want to tie a specific key to a defined throttle. For example, you can scope the throttling to a specific sender rather than running a global "mails per hour" throttle:
 
-    Prop.throttle!(:mails_per_hour, mail.from)
-    Prop.throttled?(:mails_per_hour, mail.from)
-    Prop.reset(:mails_per_hour, mail.from)
-    Prop.query(:mails_per_hour, mail.from)
+```ruby
+Prop.throttle!(:mails_per_hour, mail.from)
+Prop.throttled?(:mails_per_hour, mail.from)
+Prop.reset(:mails_per_hour, mail.from)
+Prop.query(:mails_per_hour, mail.from)
+```
 
 The throttle scope can also be an array of values, e.g.:
 
-    Prop.throttle!(:mails_per_hour, [ account.id, mail.from ])
+```ruby
+Prop.throttle!(:mails_per_hour, [ account.id, mail.from ])
+```
 
 ## Error handling
 
-If the throttle! method gets called more than "threshold" times within "interval in seconds" for a given handle and key combination, Prop throws a Prop::RateLimited error which is a subclass of StandardError. This exception contains a "handle" reference and a "description" if specified during the configuration. The handle allows you to rescue Prop::RateLimited and differentiate action depending on the handle. For example, in Rails you can use this in e.g. ApplicationController:
+If the throttle! method gets called more than "threshold" times within "interval in seconds" for a given handle and key combination, Prop throws a `Prop::RateLimited` error which is a subclass of `StandardError`. This exception contains a "handle" reference and a "description" if specified during the configuration. The handle allows you to rescue `Prop::RateLimited` and differentiate action depending on the handle. For example, in Rails you can use this in e.g. `ApplicationController`:
 
-    rescue_from Prop::RateLimited do |e|
-      if e.handle == :authorization_attempt
-        render :status => :forbidden, :message => I18n.t(e.description)
-      elsif ...
+```ruby
+rescue_from Prop::RateLimited do |e|
+  if e.handle == :authorization_attempt
+    render :status => :forbidden, :message => I18n.t(e.description)
+  elsif ...
 
-      end
-    end
+  end
+end
+```
 
 ### Using the Middleware
 
-Prop ships with a built in Rack middleware that you can use to do all the exception handling. When a `Prop::RateLimited` error is caught, it will build an HTTP [429 Too Many Requests](http://tools.ietf.org/html/draft-nottingham-http-new-status-02#section-4) response and set the following headers:
+Prop ships with a built-in Rack middleware that you can use to do all the exception handling. When a `Prop::RateLimited` error is caught, it will build an HTTP [429 Too Many Requests](http://tools.ietf.org/html/draft-nottingham-http-new-status-02#section-4) response and set the following headers:
 
     Retry-After: 32
     Content-Type: text/plain
@@ -79,14 +101,16 @@ Where `Retry-After` is the number of seconds the client has to wait before retry
 
 If you wish to do manual error messaging in these cases, you can define an error handler in your Prop configuration. Here's how the default error handler looks - you use anything that responds to `.call` and takes the environment and a `RateLimited` instance as argument:
 
-    error_handler = Proc.new do |env, error|
-      body    = error.description || "This action has been rate limited"
-      headers = { "Content-Type" => "text/plain", "Content-Length" => body.size, "Retry-After" => error.retry_after }
+```ruby
+error_handler = Proc.new do |env, error|
+  body    = error.description || "This action has been rate limited"
+  headers = { "Content-Type" => "text/plain", "Content-Length" => body.size, "Retry-After" => error.retry_after }
 
-      [ 429, headers, [ body ]]
-    end
+  [ 429, headers, [ body ]]
+end
 
-    ActionController::Dispatcher.middleware.insert_before(ActionController::ParamsParser, :error_handler => error_handler)
+ActionController::Dispatcher.middleware.insert_before(ActionController::ParamsParser, :error_handler => error_handler)
+```
 
 An alternative to this, is to extend `Prop::Middleware` and override the `render_response(env, error)` method.
 
@@ -94,25 +118,33 @@ An alternative to this, is to extend `Prop::Middleware` and override the `render
 
 In case you need to perform e.g. a manual bulk operation:
 
-    Prop.disabled do
-      # No throttles will be tested here
-    end
+```ruby
+Prop.disabled do
+  # No throttles will be tested here
+end
+```
 
 ## Threshold settings
 
 You can chose to override the threshold for a given key:
 
-    Prop.throttle!(:mails_per_hour, mail.from, :threshold => current_account.mail_throttle_threshold)
+```ruby
+Prop.throttle!(:mails_per_hour, mail.from, :threshold => current_account.mail_throttle_threshold)
+```
 
 When the threshold are invoked without argument, the key is nil and as such a scope of its own, i.e. these are equivalent:
 
-    Prop.throttle!(:mails_per_hour)
-    Prop.throttle!(:mails_per_hour, nil)
+```ruby
+Prop.throttle!(:mails_per_hour)
+Prop.throttle!(:mails_per_hour, nil)
+```
 
 The default (and smallest possible) increment is 1, you can set that to any integer value using :increment which is handy for building time based throttles:
 
-    Prop.setup(:execute_time, :threshold => 10, :interval => 1.minute)
-    Prop.throttle!(:execute_time, account.id, :increment => (Benchmark.realtime { execute }).to_i)
+```ruby
+Prop.setup(:execute_time, :threshold => 10, :interval => 1.minute)
+Prop.throttle!(:execute_time, account.id, :increment => (Benchmark.realtime { execute }).to_i)
+```
 
 ## License
 

data/lib/prop.rb

@@ -7,7 +7,7 @@ module Prop
   # Short hand for accessing Prop::Limiter methods
   class << self
     extend Forwardable
-    def_delegators :"Prop::Limiter", :read, :write, :configure, :disabled
+    def_delegators :"Prop::Limiter", :read, :write, :configure, :disabled, :before_throttle
     def_delegators :"Prop::Limiter", :throttle!, :throttled?, :count, :query, :reset
   end
 end

data/lib/prop/limiter.rb

@@ -6,7 +6,7 @@ module Prop
   class Limiter
 
     class << self
-      attr_accessor :handles, :reader, :writer
+      attr_accessor :handles, :reader, :writer, :before_throttle_callback
 
       def read(&blk)
         self.reader = blk
@@ -16,6 +16,10 @@ module Prop
         self.writer = blk
       end
 
+      def before_throttle(&blk)
+        self.before_throttle_callback = blk
+      end
+
       # Public: Registers a handle for rate limiting
       #
       # handle   - the name of the handle you wish to use in your code, e.g. :login_attempt
@@ -55,6 +59,10 @@ module Prop
 
         unless disabled?
           if at_threshold?(counter, options[:threshold])
+            unless before_throttle_callback.nil?
+              before_throttle_callback.call(handle, key, options[:threshold], options[:interval])
+            end
+
             raise Prop::RateLimited.new(options.merge(:cache_key => cache_key, :handle => handle))
           else
             increment = options.key?(:increment) ? options[:increment].to_i : 1

data/prop.gemspec

@@ -1,6 +1,6 @@
-Gem::Specification.new "prop", "1.0.0" do |s|
+Gem::Specification.new "prop", "1.0.1" do |s|
   s.name              = 'prop'
-  s.version           = '1.0.0'
+  s.version           = '1.0.1'
   s.date              = '2012-04-24'
   s.rubyforge_project = 'prop'
   s.license           = "Apache License Version 2.0"
@@ -18,7 +18,7 @@ Gem::Specification.new "prop", "1.0.0" do |s|
 
   s.add_development_dependency('rake')
   s.add_development_dependency('bundler')
-  s.add_development_dependency('shoulda')
+  s.add_development_dependency('minitest')
   s.add_development_dependency('mocha')
 
   s.files = `git ls-files`.split("\n")

data/test/helper.rb

@@ -1,12 +1,13 @@
 require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'mocha'
+
+require "minitest/spec"
+require "minitest/mock"
+require "minitest/autorun"
+require 'mocha/setup'
+
 require 'time'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'prop'
 
-class Test::Unit::TestCase
-end
+require 'prop'

data/test/test_key.rb

@@ -1,26 +1,24 @@
 require 'helper'
 
-class TestKey < Test::Unit::TestCase
-
-  context Prop::Key do
-    context "#build" do
-      should "return a hexdigested key" do
-        assert_match /prop\/[a-f0-9]+/, Prop::Key.build(:handle => :hello, :key => [ "foo", 2, :bar ], :interval => 60)
-      end
+describe Prop::Key do
+  describe "#build" do
+    it "return a hexdigested key" do
+      assert_match /prop\/[a-f0-9]+/, Prop::Key.build(:handle => :hello, :key => [ "foo", 2, :bar ], :interval => 60)
     end
+  end
 
-    context "#normalize" do
-      should "turn a Fixnum into a String" do
-        assert_equal "3", Prop::Key.normalize(3)
-      end
+  describe "#normalize" do
+    it "turn a Fixnum into a String" do
+      assert_equal "3", Prop::Key.normalize(3)
+    end
 
-      should "return a String" do
-        assert_equal "S", Prop::Key.normalize("S")
-      end
+    it "return a String" do
+      assert_equal "S", Prop::Key.normalize("S")
+    end
 
-      should "flatten and join an Array" do
-        assert_equal "1/B/3", Prop::Key.normalize([ 1, "B", "3" ])
-      end
+    it "flatten and join an Array" do
+      assert_equal "1/B/3", Prop::Key.normalize([ 1, "B", "3" ])
     end
   end
-end
+end
+

data/test/test_limiter.rb

@@ -1,90 +1,107 @@
 require 'helper'
 
-class TestLimiter < Test::Unit::TestCase
 
-  context Prop::Limiter do
-    setup do
-      @store = {}
+describe Prop::Limiter do
+  before do
+    @store = {}
 
-      Prop::Limiter.read  { |key| @store[key] }
-      Prop::Limiter.write { |key, value| @store[key] = value }
-      Prop::Limiter.configure(:something, :threshold => 10, :interval => 10)
+    Prop::Limiter.read  { |key| @store[key] }
+    Prop::Limiter.write { |key, value| @store[key] = value }
+    Prop::Limiter.configure(:something, :threshold => 10, :interval => 10)
 
-      @start = Time.now
-      Time.stubs(:now).returns(@start)
-    end
+    @start = Time.now
+    Time.stubs(:now).returns(@start)
+  end
 
-    context "#throttle!" do
-      setup do
-        Prop.reset(:something)
-      end
+  describe "#throttle!" do
+    before do
+      Prop.reset(:something)
+    end
 
-      context "when disabled" do
-        setup { Prop::Limiter.expects(:disabled?).returns(true) }
+    describe "when disabled" do
+      before { Prop::Limiter.expects(:disabled?).returns(true) }
 
-        [ true, false ].each do |threshold_reached|
-          context "and threshold has #{"not " unless threshold_reached}been reached" do
-            setup { Prop::Limiter.stubs(:at_threshold?).returns(threshold_reached) }
+      [ true, false ].each do |threshold_reached|
+        describe "and threshold has #{"not " unless threshold_reached}been reached" do
+          before { Prop::Limiter.stubs(:at_threshold?).returns(threshold_reached) }
 
-            context "given a block" do
-              should "execute that block" do
-                assert_equal "wibble", Prop.throttle!(:something) { "wibble" }
-              end
+          describe "given a block" do
+            it "execute that block" do
+              assert_equal "wibble", Prop.throttle!(:something) { "wibble" }
             end
+          end
 
-            context "not given a block" do
-              should "return the current throttle count" do
-                assert_equal Prop.count(:something), Prop.throttle!(:something)
-              end
+          describe "not given a block" do
+            it "return the current throttle count" do
+              assert_equal Prop.count(:something), Prop.throttle!(:something)
             end
           end
         end
       end
+    end
 
-      context "when not disabled" do
-        setup { Prop::Limiter.expects(:disabled?).returns(false) }
+    describe "when not disabled" do
+      before { Prop::Limiter.expects(:disabled?).returns(false) }
 
-        context "and threshold has been reached" do
-          setup { Prop::Limiter.expects(:at_threshold?).returns(true) }
+      describe "and threshold has been reached" do
+        before { Prop::Limiter.expects(:at_threshold?).returns(true) }
 
-          context "given a block" do
-            should "raise Prop::RateLimited" do
-              assert_raises(Prop::RateLimited) { Prop.throttle!(:something) { "wibble" }}
-            end
+        describe "given a block" do
+          it "raise Prop::RateLimited" do
+            assert_raises(Prop::RateLimited) { Prop.throttle!(:something) { "wibble" }}
+          end
 
-            should "raise even if given :increment => 0" do
-              value = Prop.count(:something)
-              assert_raises(Prop::RateLimited) { Prop.throttle!(:something, nil, :increment => 0) { "wibble" }}
-              assert_equal value, Prop.count(:something)
-            end
+          it "raise even if given :increment => 0" do
+            value = Prop.count(:something)
+            assert_raises(Prop::RateLimited) { Prop.throttle!(:something, nil, :increment => 0) { "wibble" }}
+            assert_equal value, Prop.count(:something)
           end
 
-          context "not given a block" do
-            should "raise Prop::RateLimited" do
-              assert_raises(Prop::RateLimited) { Prop.throttle!(:something) }
+          describe "and given a before_throttle callback" do
+            before do
+              Prop.before_throttle do |handle, key, threshold, interval|
+                @handle = handle
+                @key = key
+                @threshold = threshold
+                @interval = interval
+              end
+            end
+
+            it "invoke callback with expected parameters" do
+              assert_raises(Prop::RateLimited) { Prop.throttle!(:something, [:extra]) }
+              assert_equal @handle, :something
+              assert_equal @key, [:extra]
+              assert_equal @threshold, 10
+              assert_equal @interval, 10
             end
           end
         end
 
-        context "and threshold has not been reached" do
-          setup do
-            Prop::Limiter.expects(:at_threshold?).returns(false)
+        describe "not given a block" do
+          it "raise Prop::RateLimited" do
+            assert_raises(Prop::RateLimited) { Prop.throttle!(:something) }
           end
+        end
+      end
 
-          context "given a block" do
-            should "execute that block" do
-              assert_equal "wibble", Prop.throttle!(:something) { "wibble" }
-            end
+      describe "and threshold has not been reached" do
+        before do
+          Prop::Limiter.expects(:at_threshold?).returns(false)
+        end
+
+        describe "given a block" do
+          it "execute that block" do
+            assert_equal "wibble", Prop.throttle!(:something) { "wibble" }
           end
+        end
 
-          context "not given a block" do
-            should "return the updated throttle count" do
-              assert_equal Prop.count(:something) + 1, Prop.throttle!(:something)
-            end
+        describe "not given a block" do
+          it "return the updated throttle count" do
+            assert_equal Prop.count(:something) + 1, Prop.throttle!(:something)
+          end
 
-            should "not update count if passed an increment of 0" do
-              assert_equal Prop.count(:something), Prop.throttle!(:something, nil, :increment => 0)
-            end
+          it "not update count if passed an increment of 0" do
+            assert_equal Prop.count(:something), Prop.throttle!(:something, nil, :increment => 0)
           end
         end
       end

data/test/test_middleware.rb

@@ -1,47 +1,46 @@
 require 'helper'
+
 require 'prop/middleware'
 require 'prop/rate_limited'
 
-class TestMiddleware < Test::Unit::TestCase
 
-  context Prop::Middleware do
-    setup do
-      @app = stub()
-      @env = {}
-      @middleware = Prop::Middleware.new(@app)
+describe Prop::Middleware do
+  before do
+    @app = stub()
+    @env = {}
+    @middleware = Prop::Middleware.new(@app)
+  end
+
+  describe "when the app call completes" do
+    before do
+      @app.expects(:call).with(@env).returns("response")
     end
 
-    context "when the app call completes" do
-      setup do
-        @app.expects(:call).with(@env).returns("response")
-      end
+    it "return the response" do
+      assert_equal "response", @middleware.call(@env)
+    end
+  end
 
-      should "return the response" do
-        assert_equal "response", @middleware.call(@env)
-      end
+  describe "when the app call results in a raised throttle" do
+    before do
+      @app.expects(:call).with(@env).raises(Prop::RateLimited.new(:handle => "foo", :threshold => 10, :interval => 60, :cache_key => "wibble", :description => "Boom!"))
     end
 
-    context "when the app call results in a raised throttle" do
-      setup do
-        @app.expects(:call).with(@env).raises(Prop::RateLimited.new(:handle => "foo", :threshold => 10, :interval => 60, :cache_key => "wibble", :description => "Boom!"))
-      end
+    it "return the rate limited message" do
+      response = @middleware.call(@env)
 
-      should "return the rate limited message" do
-        response = @middleware.call(@env)
+      assert_equal 429, response[0]
+      assert_equal ["Boom!"], response[2]
+    end
 
-        assert_equal 429, response[0]
-        assert_equal ["Boom!"], response[2]
+    describe "with a custom error handler" do
+      before do
+        @middleware = Prop::Middleware.new(@app, :error_handler => Proc.new { |env, error| "Oops" })
       end
 
-      context "with a custom error handler" do
-        setup do
-          @middleware = Prop::Middleware.new(@app, :error_handler => Proc.new { |env, error| "Oops" })
-        end
-
-        should "allow setting a custom error handler" do
-          assert_equal "Oops", @middleware.call(@env)
-        end
+      it "allow setting a custom error handler" do
+        assert_equal "Oops", @middleware.call(@env)
       end
     end
   end
-end
+end

data/test/test_options.rb

@@ -1,48 +1,44 @@
 require 'helper'
 
-class TestOptions < Test::Unit::TestCase
+describe Prop::Options do
+  describe "#build" do
+    before do
+      @args = { :key => "hello", :params => { :foo => "bif" }, :defaults => { :foo => "bar", :baz => "moo", :threshold => 10, :interval => 5 }}
+    end
 
-  context Prop::Options do
-    context "#build" do
-      setup do
-        @args = { :key => "hello", :params => { :foo => "bif" }, :defaults => { :foo => "bar", :baz => "moo", :threshold => 10, :interval => 5 }}
+    describe "when given valid input" do
+      before do
+        @options = Prop::Options.build(@args)
       end
 
-      context "when given valid input" do
-        setup do
-          @options = Prop::Options.build(@args)
-        end
-
-        should "support defaults" do
-          assert_equal "moo", @options[:baz]
-        end
+      it "support defaults" do
+        assert_equal "moo", @options[:baz]
+      end
 
-        should "override defaults" do
-          assert_equal "bif", @options[:foo]
-        end
+      it "override defaults" do
+        assert_equal "bif", @options[:foo]
       end
+    end
 
-      context "when given invalid input" do
-        should "raise when not given an interval" do
-          @args[:defaults].delete(:interval)
-          assert_raises(RuntimeError) { Prop::Options.build(@args) }
-        end
+    describe "when given invalid input" do
+      it "raise when not given an interval" do
+        @args[:defaults].delete(:interval)
+        assert_raises(RuntimeError) { Prop::Options.build(@args) }
+      end
 
-        should "raise when not given a threshold" do
-          @args[:defaults].delete(:threshold)
-          assert_raises(RuntimeError) { Prop::Options.build(@args) }
-        end
+      it "raise when not given a threshold" do
+        @args[:defaults].delete(:threshold)
+        assert_raises(RuntimeError) { Prop::Options.build(@args) }
+      end
 
-        should "raise when not given a key" do
-          @args.delete(:key)
-          begin
-            Prop::Options.build(@args)
-            fail "Should puke when not given a valid key"
-          rescue
-          end
+      it "raise when not given a key" do
+        @args.delete(:key)
+        begin
+          Prop::Options.build(@args)
+          fail "it puke when not given a valid key"
+        rescue
         end
       end
     end
-
   end
-end
+end

data/test/test_prop.rb

@@ -1,198 +1,195 @@
 require 'helper'
 
 # Integration level tests
-class TestProp < Test::Unit::TestCase
+describe Prop do
+  before do
+    store = {}
+    Prop.read  { |key| store[key] }
+    Prop.write { |key, value| store[key] = value }
+
+    @start = Time.now
+    Time.stubs(:now).returns(@start)
+  end
 
-  context "Prop" do
-    setup do
-      store = {}
-      Prop.read  { |key| store[key] }
-      Prop.write { |key, value| store[key] = value }
+  describe "#defaults" do
+    it "raise errors on invalid configuation" do
+      assert_raises(RuntimeError) do
+        Prop.configure :hello_there, :threshold => 20, :interval => 'hello'
+      end
 
-      @start = Time.now
-      Time.stubs(:now).returns(@start)
+      assert_raises(RuntimeError) do
+        Prop.configure :hello_there, :threshold => 'wibble', :interval => 100
+      end
     end
 
-    context "#defaults" do
-      should "raise errors on invalid configuation" do
-        assert_raises(RuntimeError) do
-          Prop.configure :hello_there, :threshold => 20, :interval => 'hello'
-        end
-
-        assert_raises(RuntimeError) do
-          Prop.configure :hello_there, :threshold => 'wibble', :interval => 100
-        end
+    it "result in a default handle" do
+      Prop.configure :hello_there, :threshold => 4, :interval => 10
+      4.times do |i|
+        assert_equal (i + 1), Prop.throttle!(:hello_there, 'some key')
       end
 
-      should "result in a default handle" do
-        Prop.configure :hello_there, :threshold => 4, :interval => 10
-        4.times do |i|
-          assert_equal (i + 1), Prop.throttle!(:hello_there, 'some key')
-        end
-
-        assert_raises(Prop::RateLimited) { Prop.throttle!(:hello_there, 'some key') }
-        assert_equal 5, Prop.throttle!(:hello_there, 'some key', :threshold => 20)
-      end
+      assert_raises(Prop::RateLimited) { Prop.throttle!(:hello_there, 'some key') }
+      assert_equal 5, Prop.throttle!(:hello_there, 'some key', :threshold => 20)
+    end
 
-      should "create a handle accepts various cache key types" do
-        Prop.configure :hello_there, :threshold => 4, :interval => 10
-        assert_equal 1, Prop.throttle!(:hello_there, 5)
-        assert_equal 2, Prop.throttle!(:hello_there, 5)
-        assert_equal 1, Prop.throttle!(:hello_there, '6')
-        assert_equal 2, Prop.throttle!(:hello_there, '6')
-        assert_equal 1, Prop.throttle!(:hello_there, [ 5, '6' ])
-        assert_equal 2, Prop.throttle!(:hello_there, [ 5, '6' ])
-      end
+    it "create a handle accepts various cache key types" do
+      Prop.configure :hello_there, :threshold => 4, :interval => 10
+      assert_equal 1, Prop.throttle!(:hello_there, 5)
+      assert_equal 2, Prop.throttle!(:hello_there, 5)
+      assert_equal 1, Prop.throttle!(:hello_there, '6')
+      assert_equal 2, Prop.throttle!(:hello_there, '6')
+      assert_equal 1, Prop.throttle!(:hello_there, [ 5, '6' ])
+      assert_equal 2, Prop.throttle!(:hello_there, [ 5, '6' ])
     end
+  end
 
-    context "#disable" do
-      setup do
-        Prop.configure :hello, :threshold => 10, :interval => 10
-      end
+  describe "#disable" do
+    before do
+      Prop.configure :hello, :threshold => 10, :interval => 10
+    end
 
-      should "not increase the throttle" do
-        assert_equal 1, Prop.throttle!(:hello)
+    it "not increase the throttle" do
+      assert_equal 1, Prop.throttle!(:hello)
+      assert_equal 2, Prop.throttle!(:hello)
+      Prop.disabled do
+        assert_equal 2, Prop.throttle!(:hello)
         assert_equal 2, Prop.throttle!(:hello)
-        Prop.disabled do
-          assert_equal 2, Prop.throttle!(:hello)
-          assert_equal 2, Prop.throttle!(:hello)
-          assert Prop::Limiter.send(:disabled?)
-        end
-        assert !Prop::Limiter.send(:disabled?)
-        assert_equal 3, Prop.throttle!(:hello)
+        assert Prop::Limiter.send(:disabled?)
       end
+      assert !Prop::Limiter.send(:disabled?)
+      assert_equal 3, Prop.throttle!(:hello)
     end
+  end
 
-    context "#reset" do
-      setup do
-        Prop.configure :hello, :threshold => 10, :interval => 10
+  describe "#reset" do
+    before do
+      Prop.configure :hello, :threshold => 10, :interval => 10
 
-        5.times do |i|
-          assert_equal (i + 1), Prop.throttle!(:hello)
-        end
+      5.times do |i|
+        assert_equal (i + 1), Prop.throttle!(:hello)
       end
+    end
 
-      should "set the correct counter to 0" do
-        Prop.throttle!(:hello, 'wibble')
-        Prop.throttle!(:hello, 'wibble')
+    it "set the correct counter to 0" do
+      Prop.throttle!(:hello, 'wibble')
+      Prop.throttle!(:hello, 'wibble')
 
-        Prop.reset(:hello)
-        assert_equal 1, Prop.throttle!(:hello)
+      Prop.reset(:hello)
+      assert_equal 1, Prop.throttle!(:hello)
 
-        assert_equal 3, Prop.throttle!(:hello, 'wibble')
-        Prop.reset(:hello, 'wibble')
-        assert_equal 1, Prop.throttle!(:hello, 'wibble')
-      end
+      assert_equal 3, Prop.throttle!(:hello, 'wibble')
+      Prop.reset(:hello, 'wibble')
+      assert_equal 1, Prop.throttle!(:hello, 'wibble')
     end
+  end
 
-    context "#throttled?" do
-      should "return true once the threshold has been reached" do
-        Prop.configure(:hello, :threshold => 2, :interval => 10)
-        Prop.throttle!(:hello)
-        assert !Prop.throttled?(:hello)
-        Prop.throttle!(:hello)
-        assert Prop.throttled?(:hello)
-      end
+  describe "#throttled?" do
+    it "return true once the threshold has been reached" do
+      Prop.configure(:hello, :threshold => 2, :interval => 10)
+      Prop.throttle!(:hello)
+      assert !Prop.throttled?(:hello)
+      Prop.throttle!(:hello)
+      assert Prop.throttled?(:hello)
     end
+  end
 
-    context "#count" do
-      setup do
-        Prop.configure(:hello, :threshold => 20, :interval => 20)
-        Prop.throttle!(:hello)
-        Prop.throttle!(:hello)
-      end
+  describe "#count" do
+    before do
+      Prop.configure(:hello, :threshold => 20, :interval => 20)
+      Prop.throttle!(:hello)
+      Prop.throttle!(:hello)
+    end
 
-      should "be aliased by #count" do
-        assert_equal Prop.count(:hello), 2
-      end
+    it "be aliased by #count" do
+      assert_equal Prop.count(:hello), 2
+    end
 
-      should "return the number of hits on a throttle" do
-        assert_equal Prop.query(:hello), 2
+    it "return the number of hits on a throttle" do
+      assert_equal Prop.query(:hello), 2
+    end
+  end
+
+  describe "#throttle!" do
+    it "increment counter correctly" do
+      3.times do |i|
+        assert_equal (i + 1), Prop.throttle!(:hello, nil, :threshold => 10, :interval => 10)
       end
     end
 
-    context "#throttle!" do
-      should "increment counter correctly" do
-        3.times do |i|
-          assert_equal (i + 1), Prop.throttle!(:hello, nil, :threshold => 10, :interval => 10)
-        end
+    it "reset counter when time window is passed" do
+      3.times do |i|
+        assert_equal (i + 1), Prop.throttle!(:hello, nil, :threshold => 10, :interval => 10)
       end
 
-      should "reset counter when time window is passed" do
-        3.times do |i|
-          assert_equal (i + 1), Prop.throttle!(:hello, nil, :threshold => 10, :interval => 10)
-        end
+      Time.stubs(:now).returns(@start + 20)
 
-        Time.stubs(:now).returns(@start + 20)
+      3.times do |i|
+        assert_equal (i + 1), Prop.throttle!(:hello, nil, :threshold => 10, :interval => 10)
+      end
+    end
 
-        3.times do |i|
-          assert_equal (i + 1), Prop.throttle!(:hello, nil, :threshold => 10, :interval => 10)
-        end
+    it "not increment the counter beyond the threshold" do
+      Prop.configure(:hello, :threshold => 5, :interval => 1)
+      10.times do |i|
+        Prop.throttle!(:hello) rescue nil
       end
 
-      should "not increment the counter beyond the threshold" do
-        Prop.configure(:hello, :threshold => 5, :interval => 1)
-        10.times do |i|
-          Prop.throttle!(:hello) rescue nil
-        end
+      assert_equal 5, Prop.query(:hello)
+    end
+
+    it "support custom increments" do
+      Prop.configure(:hello, :threshold => 100, :interval => 10)
 
-        assert_equal 5, Prop.query(:hello)
-      end
+      Prop.throttle!(:hello)
+      Prop.throttle!(:hello)
 
-      should "support custom increments" do
-        Prop.configure(:hello, :threshold => 100, :interval => 10)
+      assert_equal 2, Prop.query(:hello)
 
-        Prop.throttle!(:hello)
-        Prop.throttle!(:hello)
+      Prop.throttle!(:hello, nil, :increment => 48)
 
-        assert_equal 2, Prop.query(:hello)
+      assert_equal 50, Prop.query(:hello)
+    end
 
-        Prop.throttle!(:hello, nil, :increment => 48)
+    it "raise Prop::RateLimited when the threshold is exceeded" do
+      Prop.configure(:hello, :threshold => 5, :interval => 10, :description => "Boom!")
 
-        assert_equal 50, Prop.query(:hello)
+      5.times do |i|
+        Prop.throttle!(:hello, nil)
       end
-
-      should "raise Prop::RateLimited when the threshold is exceeded" do
-        Prop.configure(:hello, :threshold => 5, :interval => 10, :description => "Boom!")
-
-        5.times do |i|
-          Prop.throttle!(:hello, nil)
-        end
-        assert_raises(Prop::RateLimited) do
-          Prop.throttle!(:hello, nil)
-        end
-
-        begin
-          Prop.throttle!(:hello, nil)
-          fail
-        rescue Prop::RateLimited => e
-          assert_equal :hello, e.handle
-          assert_match "5 tries per 10s exceeded for key", e.message
-          assert_equal "Boom!", e.description
-          assert e.retry_after
-        end
+      assert_raises(Prop::RateLimited) do
+        Prop.throttle!(:hello, nil)
       end
 
-      should "raise a RuntimeError when a handle has not been configured" do
-        assert_raises(RuntimeError) do
-          Prop.throttle!(:no_such_handle, nil, :threshold => 5, :interval => 10)
-        end
+      begin
+        Prop.throttle!(:hello, nil)
+        fail
+      rescue Prop::RateLimited => e
+        assert_equal :hello, e.handle
+        assert_match "5 tries per 10s exceeded for key", e.message
+        assert_equal "Boom!", e.description
+        assert e.retry_after
       end
     end
 
-    context 'different handles with the same interval' do
-      setup do
-        Prop.configure(:api_requests, :threshold => 100, :interval => 30)
-        Prop.configure(:login_attempts, :threshold => 10, :interval => 30)
+    it "raise a RuntimeError when a handle has not been configured" do
+      assert_raises(RuntimeError) do
+        Prop.throttle!(:no_such_handle, nil, :threshold => 5, :interval => 10)
       end
+    end
+  end
 
-      should 'be counted separately' do
-        user_id = 42
-        Prop.throttle!(:api_requests, user_id)
-        assert_equal(1, Prop.count(:api_requests, user_id))
-        assert_equal(0, Prop.count(:login_attempts, user_id))
-      end
+  describe 'different handles with the same interval' do
+    before do
+      Prop.configure(:api_requests, :threshold => 100, :interval => 30)
+      Prop.configure(:login_attempts, :threshold => 10, :interval => 30)
     end
 
+    it 'be counted separately' do
+      user_id = 42
+      Prop.throttle!(:api_requests, user_id)
+      assert_equal(1, Prop.count(:api_requests, user_id))
+      assert_equal(0, Prop.count(:login_attempts, user_id))
+    end
   end
+
 end

data/test/test_rate_limited.rb

@@ -1,27 +1,24 @@
 require 'helper'
 
-class TestRateLimited < Test::Unit::TestCase
+describe Prop::RateLimited do
+  describe "#initialize" do
+    before do
+      time = Time.at(1333685680)
+      Time.stubs(:now).returns(time)
 
-  context Prop::RateLimited do
-    context "#initialize" do
-      setup do
-        time = Time.at(1333685680)
-        Time.stubs(:now).returns(time)
-
-        @error = Prop::RateLimited.new(:handle => "foo", :threshold => 10, :interval => 60, :cache_key => "wibble", :description => "Boom!")
-      end
+      @error = Prop::RateLimited.new(:handle => "foo", :threshold => 10, :interval => 60, :cache_key => "wibble", :description => "Boom!")
+    end
 
-      should "return an error instance" do
-        assert @error.is_a?(StandardError)
-        assert @error.is_a?(Prop::RateLimited)
+    it "return an error instance" do
+      assert @error.is_a?(StandardError)
+      assert @error.is_a?(Prop::RateLimited)
 
-        assert_equal "foo", @error.handle
-        assert_equal "wibble", @error.cache_key
-        assert_equal "Boom!", @error.description
-        assert_equal "foo threshold of 10 tries per 60s exceeded for key 'nil', hash wibble", @error.message
-        assert_equal 20, @error.retry_after
-      end
+      assert_equal "foo", @error.handle
+      assert_equal "wibble", @error.cache_key
+      assert_equal "Boom!", @error.description
+      assert_equal "foo threshold of 10 tries per 60s exceeded for key 'nil', hash wibble", @error.message
+      assert_equal 20, @error.retry_after
     end
-
   end
-end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prop
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -44,7 +44,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: shoulda
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements: