prop 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5753d3ad85cbb0e81257570a59b12362e7da611
-  data.tar.gz: 7ff4f5c528bfe42bc8b15a0a7e9193e6e13238bb
+  metadata.gz: 2601b63983949b53ff9f31664203316614466b74
+  data.tar.gz: dc5deeebea017087d28a378e83783e3d7a5001ae
 SHA512:
-  metadata.gz: b1b0d1f4239241457b30e60bd80db2301d47b38c1f6de67cbacce29f16de80d777d91ba21f1043f5f73f6f532fbdc487076d3fc97f8f5ffa20d4da3299a8a380
-  data.tar.gz: 160b608c60ed35e72426f2c053d4a8d77643cd1506dfe9a742819b23005373ac5550a4bb7f9bcab67f406ac70d04594f085027e17fc6da45990cce44bf76d6a8
+  metadata.gz: fcd418b8e8bd9c96bb84ad902db628ce7c792a3ff3324b52c682ed989ad951595aa35564f26386f742ee07f73c3af42b490cc1731614ae255b4cc2d2988608eb
+  data.tar.gz: 43d95cc4198eacf0c3fe20182788085c778a7d20d67ffeb97c1875f3f8488275d2ea2e0aa8e997e82ffffb2aab56a7c37bbab619fb8ca930d7b3c72b94a76150

data/README.md

@@ -1,9 +1,12 @@
 
-# Prop [![Build Status](https://secure.travis-ci.org/zendesk/prop.png)](http://travis-ci.org/zendesk/prop)
+# Prop [![Build Status](https://travis-ci.org/zendesk/prop.png)](https://travis-ci.org/zendesk/prop)
 
 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 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.
+Prop supports two limiting strategies:
+
+* Basic strategy (default): Prop will use 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.
+* Leaky bucket strategy: Prop also supports the [Leaky Bucket](https://en.wikipedia.org/wiki/Leaky_bucket) algorithm, which is similar to the basic strategy but also supports bursts up to a specified threshold.
 
 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:
 
@@ -34,7 +37,7 @@ end
 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:
 
 ```ruby
-Prop.configure(:mails_per_hour, :threshold => 100, :interval => 1.hour, :description => "Mail rate limit exceeded")
+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 these values, by passing the handle to the respective methods in Prop:
@@ -82,7 +85,7 @@ If the throttle! method gets called more than "threshold" times within "interval
 ```ruby
 rescue_from Prop::RateLimited do |e|
   if e.handle == :authorization_attempt
-    render :status => :forbidden, :message => I18n.t(e.description)
+    render status: :forbidden, message: I18n.t(e.description)
   elsif ...
 
   end
@@ -142,8 +145,8 @@ 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:
 
 ```ruby
-Prop.configure(:execute_time, :threshold => 10, :interval => 1.minute)
-Prop.throttle!(:execute_time, account.id, :increment => (Benchmark.realtime { execute }).to_i)
+Prop.configure(:execute_time, threshold: 10, interval: 1.minute)
+Prop.throttle!(:execute_time, account.id, increment: (Benchmark.realtime { execute }).to_i)
 ```
 
 ## Optional configuration
@@ -151,9 +154,9 @@ Prop.throttle!(:execute_time, account.id, :increment => (Benchmark.realtime { ex
 You can add optional configuration to a prop and retrieve it using `Prop.configurations[:foo]`:
 
 ```ruby
-Prop.configure(:api_query, :threshold => 10, :interval => 1.minute, :category => :api)
-Prop.configure(:api_insert, :threshold => 50, :interval => 1.minute, :category => :api)
-Prop.configure(:password_failure, :threshold => 5, :interval => 1.minute, :category => :auth)
+Prop.configure(:api_query, threshold: 10, interval: 1.minute, category: :api)
+Prop.configure(:api_insert, threshold: 50, interval: 1.minute, category: :api)
+Prop.configure(:password_failure, threshold: 5, interval: 1.minute, category: :auth)
 ```
 
 ```
@@ -173,9 +176,20 @@ rescue Prop::RateLimited => e
 end 
 ```
 
+## Using Leaky Bucket Algorithm
+
+You can add two additional configurations: `:strategy` and `:burst_rate` to use the [leaky bucket algorithm](https://en.wikipedia.org/wiki/Leaky_bucket). Prop will handle the details after configured, and you don't have to specify `:strategy` again when using `throttle`, `throttle!` or any other methods.
+
+```ruby
+Prop.configure(:api_request, strategy: :leaky_bucket, burst_rate: 20, threshold: 5, interval: 1.minute)
+```
+
+* `:threshold` value here would be the "leak rate" of leaky bucket algorithm. 
+
+
 ## License
 
-Copyright 2013 Zendesk
+Copyright 2015 Zendesk
 
 Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

data/lib/prop.rb

@@ -2,7 +2,7 @@ require "prop/limiter"
 require "forwardable"
 
 module Prop
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 
   # Short hand for accessing Prop::Limiter methods
   class << self

data/lib/prop/interval_strategy.rb

@@ -0,0 +1,59 @@
+require 'prop/limiter'
+require 'prop/options'
+require 'prop/key'
+
+module Prop
+  class IntervalStrategy
+    class << self
+      def counter(cache_key, options)
+        Prop::Limiter.reader.call(cache_key).to_i
+      end
+
+      def increment(cache_key, options, counter)
+        increment = options.fetch(:increment, 1)
+        Prop::Limiter.writer.call(cache_key, counter + increment)
+      end
+
+      def reset(cache_key)
+        Prop::Limiter.writer.call(cache_key, 0)
+      end
+
+      def at_threshold?(counter, options)
+        counter >= options.fetch(:threshold)
+      end
+
+      # Builds the expiring cache key
+      def build(options)
+        key       = options.fetch(:key)
+        handle    = options.fetch(:handle)
+        interval  = options.fetch(:interval)
+
+        window    = (Time.now.to_i / interval)
+        cache_key = Prop::Key.normalize([ handle, key, window ])
+
+        "prop/#{Digest::MD5.hexdigest(cache_key)}"
+      end
+
+      def threshold_reached(options)
+        threshold = options.fetch(:threshold)
+
+        "#{options[:handle]} threshold of #{threshold} tries per #{options[:interval]}s exceeded for key '#{options[:key].inspect}', hash #{options[:cache_key]}"
+      end
+
+      def validate_options!(options)
+        validate_positive_integer(options[:threshold], :threshold)
+        validate_positive_integer(options[:interval], :interval)
+
+        if options.key?(:increment)
+          raise ArgumentError.new(":increment must be zero or a positive Integer") if !options[:increment].is_a?(Fixnum) || options[:increment] < 0
+        end
+      end
+
+      private
+
+      def validate_positive_integer(option, key)
+        raise ArgumentError.new("#{key.inspect} must be a positive Integer") if !option.is_a?(Fixnum) || option <= 0
+      end
+    end
+  end
+end

data/lib/prop/key.rb

@@ -3,18 +3,6 @@ require "digest/md5"
 module Prop
   class Key
 
-    # Builds the expiring cache key
-    def self.build(options)
-      key       = options.fetch(:key)
-      handle    = options.fetch(:handle)
-      interval  = options.fetch(:interval)
-
-      window    = (Time.now.to_i / interval)
-      cache_key = normalize([ handle, key, window ])
-
-      "prop/#{Digest::MD5.hexdigest(cache_key)}"
-    end
-
     # Simple key expansion only supports arrays and primitives
     def self.normalize(key)
       if key.is_a?(Array)

data/lib/prop/leaky_bucket_strategy.rb

@@ -0,0 +1,68 @@
+require 'prop/limiter'
+require 'prop/options'
+require 'prop/key'
+require 'prop/interval_strategy'
+
+module Prop
+  class LeakyBucketStrategy
+    class << self
+      def update_bucket(cache_key, interval, leak_rate)
+        bucket = Prop::Limiter.reader.call(cache_key) || default_bucket
+        now = Time.now.to_i
+        leak_amount = (now - bucket[:last_updated]) / interval * leak_rate
+
+        bucket[:bucket] = [bucket[:bucket] - leak_amount, 0].max
+        bucket[:last_updated] = now
+
+        Prop::Limiter.writer.call(cache_key, bucket)
+        bucket
+      end
+
+      def counter(cache_key, options)
+        update_bucket(cache_key, options[:interval], options[:threshold]).merge(burst_rate: options[:burst_rate])
+      end
+
+      def increment(cache_key, options, counter)
+        increment = options.fetch(:increment, 1)
+        bucket = { :bucket => counter[:bucket].to_i + increment, :last_updated => Time.now.to_i }
+        Prop::Limiter.writer.call(cache_key, bucket)
+      end
+
+      def reset(cache_key)
+        Prop::Limiter.writer.call(cache_key, default_bucket)
+      end
+
+      def at_threshold?(counter, options)
+        counter[:bucket].to_i >= options.fetch(:burst_rate)
+      end
+
+      def build(options)
+        key       = options.fetch(:key)
+        handle    = options.fetch(:handle)
+
+        cache_key = Prop::Key.normalize([ handle, key ])
+
+        "prop/leaky_bucket/#{Digest::MD5.hexdigest(cache_key)}"
+      end
+
+      def default_bucket
+        { :bucket => 0, :last_updated => 0 }
+      end
+
+      def threshold_reached(options)
+        burst_rate = options.fetch(:burst_rate)
+        threshold  = options.fetch(:threshold)
+
+        "#{options[:handle]} threshold of #{threshold} tries per #{options[:interval]}s and burst rate #{burst_rate} tries exceeded for key '#{options[:key].inspect}', hash #{options[:cache_key]}"
+      end
+
+      def validate_options!(options)
+        Prop::IntervalStrategy.validate_options!(options)
+
+        if !options[:burst_rate].is_a?(Fixnum) || options[:burst_rate] < options[:threshold]
+          raise ArgumentError.new(":burst_rate must be an Integer and larger than :threshold")
+        end
+      end
+    end
+  end
+end

data/lib/prop/limiter.rb

@@ -1,6 +1,8 @@
 require 'prop/rate_limited'
 require 'prop/key'
 require 'prop/options'
+require 'prop/interval_strategy'
+require 'prop/leaky_bucket_strategy'
 
 module Prop
   class Limiter
@@ -54,18 +56,17 @@ module Prop
       # Returns true if the threshold for this handle has been reached, else returns false
       def throttle(handle, key = nil, options = {})
         options, cache_key = prepare(handle, key, options)
-        counter = reader.call(cache_key).to_i
+        counter = @strategy.counter(cache_key, options)
 
         unless disabled?
-          if at_threshold?(counter, options[:threshold])
+          if @strategy.at_threshold?(counter, options)
             unless before_throttle_callback.nil?
               before_throttle_callback.call(handle, key, options[:threshold], options[:interval])
             end
 
             true
           else
-            increment = options.key?(:increment) ? options[:increment].to_i : 1
-            writer.call(cache_key, counter + increment)
+            @strategy.increment(cache_key, options, counter)
 
             yield if block_given?
 
@@ -90,7 +91,7 @@ module Prop
           raise Prop::RateLimited.new(options.merge(:cache_key => cache_key, :handle => handle))
         end
 
-        block_given? ? yield : reader.call(cache_key).to_i
+        block_given? ? yield : @strategy.counter(cache_key, options)
       end
 
       # Public: Allows to query whether the given handle/key combination is currently throttled
@@ -101,7 +102,8 @@ module Prop
       # Returns true if a call to `throttle!` with same parameters would raise, otherwise false
       def throttled?(handle, key = nil, options = {})
         options, cache_key = prepare(handle, key, options)
-        reader.call(cache_key).to_i >= options[:threshold]
+        counter = @strategy.counter(cache_key, options)
+        @strategy.at_threshold?(counter, options)
       end
 
       # Public: Resets a specific throttle
@@ -112,7 +114,7 @@ module Prop
       # Returns nothing
       def reset(handle, key = nil, options = {})
         options, cache_key = prepare(handle, key, options)
-        writer.call(cache_key, 0)
+        @strategy.reset(cache_key)
       end
 
       # Public: Counts the number of times the given handle/key combination has been hit in the current window
@@ -123,7 +125,7 @@ module Prop
       # Returns a count of hits in the current window
       def count(handle, key = nil, options = {})
         options, cache_key = prepare(handle, key, options)
-        reader.call(cache_key).to_i
+        @strategy.counter(cache_key, options)
       end
       alias :query :count
 
@@ -134,10 +136,6 @@ module Prop
 
       private
 
-      def at_threshold?(mark, threshold)
-        mark >= threshold
-      end
-
       def disabled?
         !!@disabled
       end
@@ -147,7 +145,10 @@ module Prop
 
         defaults  = handles[handle]
         options   = Prop::Options.build(:key => key, :params => params, :defaults => defaults)
-        cache_key = Prop::Key.build(:key => key, :handle => handle, :interval => options[:interval])
+
+        @strategy = options.fetch(:strategy)
+
+        cache_key = @strategy.build(:key => key, :handle => handle, :interval => options[:interval])
 
         [ options, cache_key ]
       end

data/lib/prop/options.rb

@@ -10,15 +10,22 @@ module Prop
       defaults = options.fetch(:defaults)
       result   = defaults.merge(params)
 
-      result[:key]       = Prop::Key.normalize(key)
-      result[:threshold] = result[:threshold].to_i
-      result[:interval]  = result[:interval].to_i
+      result[:key] = Prop::Key.normalize(key)
 
-      raise RuntimeError.new("Invalid threshold setting") unless result[:threshold] > 0
-      raise RuntimeError.new("Invalid interval setting")  unless result[:interval] > 0
+      result[:strategy] = if leaky_bucket.include?(result[:strategy])
+        Prop::LeakyBucketStrategy
+      elsif result[:strategy] == nil
+        Prop::IntervalStrategy
+      else
+        result[:strategy] # allowing any new/unknown strategy to be used
+      end
 
+      result[:strategy].validate_options!(result)
       result
     end
 
+    def self.leaky_bucket
+      [:leaky_bucket, "leaky_bucket"]
+    end
   end
-end
+end

data/lib/prop/rate_limited.rb

@@ -6,9 +6,9 @@ module Prop
       handle    = options.fetch(:handle)
       cache_key = options.fetch(:cache_key)
       interval  = options.fetch(:interval).to_i
-      threshold = options.fetch(:threshold).to_i
+      strategy  = options.fetch(:strategy)
 
-      super("#{handle} threshold of #{threshold} tries per #{interval}s exceeded for key '#{options[:key].inspect}', hash #{cache_key}")
+      super(strategy.threshold_reached(options))
 
       self.description = options[:description]
       self.handle      = handle

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prop
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Morten Primdahl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-31 00:00:00.000000000 Z
+date: 2015-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -66,35 +66,23 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Gem for implementing rate limits.
+description: 
 email: primdahl@me.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".document"
-- ".gemtest"
-- ".gitignore"
-- ".travis.yml"
-- Gemfile
 - LICENSE
 - README.md
-- Rakefile
 - lib/prop.rb
+- lib/prop/interval_strategy.rb
 - lib/prop/key.rb
+- lib/prop/leaky_bucket_strategy.rb
 - lib/prop/limiter.rb
 - lib/prop/middleware.rb
 - lib/prop/options.rb
 - lib/prop/rate_limited.rb
-- prop.gemspec
-- test/helper.rb
-- test/test_key.rb
-- test/test_limiter.rb
-- test/test_middleware.rb
-- test/test_options.rb
-- test/test_prop.rb
-- test/test_rate_limited.rb
-homepage: http://github.com/zendesk/prop
+homepage: https://github.com/zendesk/prop
 licenses:
 - Apache License Version 2.0
 metadata: {}
@@ -113,15 +101,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: prop
-rubygems_version: 2.2.2
+rubyforge_project: 
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: Gem for implementing rate limits.
-test_files:
-- test/test_key.rb
-- test/test_limiter.rb
-- test/test_middleware.rb
-- test/test_options.rb
-- test/test_prop.rb
-- test/test_rate_limited.rb
+test_files: []

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE

data/.gitignore

@@ -1,22 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
-coverage
-rdoc
-pkg
-
-## PROJECT::SPECIFIC
-Gemfile.lock

data/.travis.yml

@@ -1,6 +0,0 @@
-rvm:
-  - 2.0.0
-  - 1.8.7
-  - 1.9.3
-  - jruby
-  - ree

data/Gemfile

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

data/Rakefile

@@ -1,12 +0,0 @@
-require 'bundler/gem_tasks'
-require 'rake/testtask'
-
-Rake::TestTask.new do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
-
-task :default do
-  sh "bundle exec rake test"
-end

data/prop.gemspec

@@ -1,26 +0,0 @@
-Gem::Specification.new "prop", "1.1.0" do |s|
-  s.name              = 'prop'
-  s.version           = '1.1.0'
-  s.date              = '2014-12-31'
-  s.rubyforge_project = 'prop'
-  s.license           = "Apache License Version 2.0"
-
-  s.summary     = "Gem for implementing rate limits."
-  s.description = "Gem for implementing rate limits."
-
-  s.authors  = ["Morten Primdahl"]
-  s.email    = 'primdahl@me.com'
-  s.homepage = 'http://github.com/zendesk/prop'
-
-  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
-  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
-  s.require_paths = %w[lib]
-
-  s.add_development_dependency('rake')
-  s.add_development_dependency('bundler')
-  s.add_development_dependency('minitest')
-  s.add_development_dependency('mocha')
-
-  s.files = `git ls-files`.split("\n")
-  s.test_files = s.files.select { |path| path =~ /^test\/test_.*\.rb/ }
-end

data/test/helper.rb

@@ -1,11 +0,0 @@
-require 'rubygems'
-
-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'

data/test/test_key.rb

@@ -1,24 +0,0 @@
-require 'helper'
-
-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
-
-  describe "#normalize" do
-    it "turn a Fixnum into a String" do
-      assert_equal "3", Prop::Key.normalize(3)
-    end
-
-    it "return a String" do
-      assert_equal "S", Prop::Key.normalize("S")
-    end
-
-    it "flatten and join an Array" do
-      assert_equal "1/B/3", Prop::Key.normalize([ 1, "B", "3" ])
-    end
-  end
-end
-

data/test/test_limiter.rb

@@ -1,153 +0,0 @@
-require 'helper'
-
-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)
-
-    @start = Time.now
-    Time.stubs(:now).returns(@start)
-
-    Prop.reset(:something)
-  end
-
-  describe "#throttle" do
-    describe "when disabled" do
-      before { Prop::Limiter.stubs(:disabled?).returns(true) }
-
-      it "returns nil" do
-        assert_nil Prop.throttle(:something)
-      end
-    end
-
-    describe "when not disabled" do
-      before { Prop::Limiter.stubs(:disabled?).returns(false) }
-
-      describe "and the threshold has been reached" do
-        before { Prop::Limiter.stubs(:at_threshold?).returns(true) }
-
-        it "returns true" do
-          assert Prop.throttle(:something)
-        end
-
-        it "does not increment the throttle count" do
-          Prop.throttle(:something)
-
-          assert_equal 0, Prop.count(:something)
-        end
-
-        describe "when given a block" do
-          before { @test_block_executed = false }
-
-          it "does not execute the block" do
-            Prop.throttle(:something) { @test_block_executed = true }
-
-            refute @test_block_executed
-          end
-        end
-
-        describe "when a before_throttle callback has been specified" do
-          before do
-            Prop.before_throttle do |handle, key, threshold, interval|
-              @handle    = handle
-              @key       = key
-              @threshold = threshold
-              @interval  = interval
-            end
-
-            Prop.throttle(:something, [:extra])
-          end
-
-          it "invokes callback with expected parameters" do
-            assert_equal @handle, :something
-            assert_equal @key, [:extra]
-            assert_equal @threshold, 10
-            assert_equal @interval, 10
-          end
-        end
-      end
-
-      describe "and the threshold has not been reached" do
-        before { Prop::Limiter.stubs(:at_threshold?).returns(false) }
-
-        it "returns false" do
-          refute Prop.throttle(:something)
-        end
-
-        it "increments the throttle count by one" do
-          Prop.throttle(:something)
-
-          assert_equal 1, Prop.count(:something)
-        end
-
-        it "increments the throttle count by the specified number when provided" do
-          Prop.throttle(:something, nil, :increment => 5)
-
-          assert_equal 5, Prop.count(:something)
-        end
-
-        describe "when given a block" do
-          before { @test_block_executed = false }
-
-          it "executes the block" do
-            Prop.throttle(:something) { @test_block_executed = true }
-
-            assert @test_block_executed
-          end
-        end
-      end
-    end
-  end
-
-  describe "#throttle!" do
-    it "throttles the given handle/key combination" do
-      Prop::Limiter.expects(:throttle).with(
-        :something,
-        :key,
-        {
-          :threshold => 10,
-          :interval  => 10,
-          :key       => 'key',
-          :options   => true
-        }
-      )
-
-      Prop.throttle!(:something, :key, :options => true)
-    end
-
-    describe "when the threshold has been reached" do
-      before { Prop::Limiter.stubs(:throttle).returns(true) }
-
-      it "raises a rate-limited exception" do
-        assert_raises(Prop::RateLimited) { Prop.throttle!(:something) }
-      end
-
-      describe "when given a block" do
-        before { @test_block_executed = false }
-
-        it "does not executes the block" do
-          begin
-            Prop.throttle!(:something) { @test_block_executed = true }
-          rescue Prop::RateLimited
-            refute @test_block_executed
-          end
-        end
-      end
-    end
-
-    describe "when the threshold has not been reached" do
-      it "returns the counter value" do
-        assert_equal Prop.count(:something) + 1, Prop.throttle!(:something)
-      end
-
-      describe "when given a block" do
-        it "returns the return value of the block" do
-          assert_equal 'block_value', Prop.throttle!(:something) { 'block_value' }
-        end
-      end
-    end
-  end
-end

data/test/test_middleware.rb

@@ -1,46 +0,0 @@
-require 'helper'
-
-require 'prop/middleware'
-require 'prop/rate_limited'
-
-
-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
-
-    it "return the response" do
-      assert_equal "response", @middleware.call(@env)
-    end
-  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
-
-    it "return the rate limited message" do
-      response = @middleware.call(@env)
-
-      assert_equal 429, response[0]
-      assert_equal ["Boom!"], response[2]
-    end
-
-    describe "with a custom error handler" do
-      before do
-        @middleware = Prop::Middleware.new(@app, :error_handler => Proc.new { |env, error| "Oops" })
-      end
-
-      it "allow setting a custom error handler" do
-        assert_equal "Oops", @middleware.call(@env)
-      end
-    end
-  end
-end

data/test/test_options.rb

@@ -1,44 +0,0 @@
-require 'helper'
-
-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
-
-    describe "when given valid input" do
-      before do
-        @options = Prop::Options.build(@args)
-      end
-
-      it "support defaults" do
-        assert_equal "moo", @options[:baz]
-      end
-
-      it "override defaults" do
-        assert_equal "bif", @options[:foo]
-      end
-    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
-
-      it "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 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

data/test/test_prop.rb

@@ -1,205 +0,0 @@
-require 'helper'
-
-# Integration level tests
-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
-
-  describe "#defaults" do
-    it "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
-    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
-
-      assert_raises(Prop::RateLimited) { Prop.throttle!(:hello_there, 'some key') }
-      assert_equal 5, Prop.throttle!(:hello_there, 'some key', :threshold => 20)
-    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
-
-  describe "#disable" do
-    before do
-      Prop.configure :hello, :threshold => 10, :interval => 10
-    end
-
-    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)
-        assert Prop::Limiter.send(:disabled?)
-      end
-      assert !Prop::Limiter.send(:disabled?)
-      assert_equal 3, Prop.throttle!(:hello)
-    end
-  end
-
-  describe "#reset" do
-    before do
-      Prop.configure :hello, :threshold => 10, :interval => 10
-
-      5.times do |i|
-        assert_equal (i + 1), Prop.throttle!(:hello)
-      end
-    end
-
-    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)
-
-      assert_equal 3, Prop.throttle!(:hello, 'wibble')
-      Prop.reset(:hello, 'wibble')
-      assert_equal 1, Prop.throttle!(:hello, 'wibble')
-    end
-  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
-
-  describe "#count" do
-    before do
-      Prop.configure(:hello, :threshold => 20, :interval => 20)
-      Prop.throttle!(:hello)
-      Prop.throttle!(:hello)
-    end
-
-    it "be aliased by #count" do
-      assert_equal Prop.count(:hello), 2
-    end
-
-    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
-      Prop.configure(:hello, :threshold => 20, :interval => 20)
-      3.times do |i|
-        assert_equal (i + 1), Prop.throttle!(:hello, nil, :threshold => 10, :interval => 10)
-      end
-    end
-
-    it "reset counter when time window is passed" do
-      Prop.configure(:hello, :threshold => 20, :interval => 20)
-      3.times do |i|
-        assert_equal (i + 1), Prop.throttle!(:hello, nil, :threshold => 10, :interval => 10)
-      end
-
-      Time.stubs(:now).returns(@start + 20)
-
-      3.times do |i|
-        assert_equal (i + 1), Prop.throttle!(:hello, nil, :threshold => 10, :interval => 10)
-      end
-    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
-
-      assert_equal 5, Prop.query(:hello)
-    end
-
-    it "support custom increments" do
-      Prop.configure(:hello, :threshold => 100, :interval => 10)
-
-      Prop.throttle!(:hello)
-      Prop.throttle!(:hello)
-
-      assert_equal 2, Prop.query(:hello)
-
-      Prop.throttle!(:hello, nil, :increment => 48)
-
-      assert_equal 50, Prop.query(:hello)
-    end
-
-    it "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
-    end
-
-    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
-
-  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
-
-  describe "#configurations" do
-    it "returns the configuration" do
-      Prop.configure(:something, :threshold => 100, :interval => 30)
-      config = Prop.configurations[:something]
-      assert_equal 100, config[:threshold]
-      assert_equal 30, config[:interval]
-    end
-  end
-end

data/test/test_rate_limited.rb

@@ -1,39 +0,0 @@
-require 'helper'
-
-describe Prop::RateLimited do
-  before do
-    time = Time.at(1333685680)
-    Time.stubs(:now).returns(time)
-
-    Prop.configure :foo, :threshold => 10, :interval => 60, :category => :api
-
-    @error = Prop::RateLimited.new(
-      :handle => :foo,
-      :threshold => 10,
-      :interval => 60,
-      :cache_key => "wibble",
-      :description => "Boom!"
-    )
-  end
-
-  describe "#initialize" do
-    it "returns 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
-  end
-
-  describe "#config" do
-    it "returns the original configuration" do
-      assert_equal 10, @error.config[:threshold]
-      assert_equal 60, @error.config[:interval]
-      assert_equal :api, @error.config[:category]
-    end
-  end
-end