berater 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 305ca5d94c6d92dd4b8bf73f2da7a03e15d419c7
-  data.tar.gz: 83a209c930780a32cf5cda81d1c932d1f8756f88
+SHA256:
+  metadata.gz: f1a54a65428bf73c9a8840d95900215411a7320d87af5297cbc75039976e182c
+  data.tar.gz: 5804acf97ae46ab33bf8366438304a301d183fb0b8da48f4b872252769e79a54
 SHA512:
-  metadata.gz: b0970141263af6e4b8461c0b974b01abd0873890d295e613e07db5fbb48ba0b736db44b67638e2eb8aa5f3d220d043ad3e7daaf17e58e00cabe999d67bd66f4d
-  data.tar.gz: d5d02d7331d13c355f3e3d2c56091552507a30e3ae7d978cbaa555984381c04033bd3d93441e8dd58bee9c019de7dd493a983ad28ad5b3bbd3c3fd23b6af8021
+  metadata.gz: c4f2f7002db193351b915c0f21b4ff6a704c20e90e7ff5815a5bfef3f38064608a367e7e150cf430e2d87a8b7b10420a3ec00a1c211bc4edcd04d0c479af3eb8
+  data.tar.gz: '06489eb2f8769e349b163d49b9a6e6a0f1a8d55b97ded73fcdeb01652b0048e4dd3d940fc71075041129b1f280120d44eec906d258056d720c1f07ac23089cb7'

data/lib/berater.rb

@@ -1,30 +1,62 @@
+require 'berater/base_limiter'
+require 'berater/concurrency_limiter'
+require 'berater/inhibitor'
+require 'berater/rate_limiter'
+require 'berater/unlimiter'
+require 'berater/version'
+
+
 module Berater
-  VERSION = '0.0.1'
+  extend self
 
-  class << self
+  Overloaded = BaseLimiter::Overloaded
 
-    def init redis
-      @@redis = redis
-    end
+  MODES = {}
+
+  attr_accessor :redis, :mode
 
+  def configure
+    self.mode = :unlimited # default
 
-    def incr key, limit, seconds
-      ts = Time.now.to_i
+    yield self
+  end
 
-      # bucket into time slot
-      rkey = "%s:%s:%d" % [ self.to_s, key, ts - ts % seconds ]
+  def new(mode, *args, **opts)
+    klass = MODES[mode.to_sym]
 
-      count = @@redis.multi do
-        @@redis.incr rkey
-        @@redis.expire rkey, seconds * 2
-      end.first
+    unless klass
+      raise ArgumentError, "invalid mode: #{mode}"
+    end
 
-      raise LimitExceeded if count > limit
+    klass.new(*args, **opts)
+  end
 
-      count
+  def register(mode, klass)
+    MODES[mode.to_sym] = klass
+  end
+
+  def mode=(mode)
+    unless MODES.include? mode.to_sym
+      raise ArgumentError, "invalid mode: #{mode}"
     end
 
+    @mode = mode.to_sym
+  end
+
+  def limit(*args, **opts, &block)
+    mode = opts.delete(:mode) { self.mode }
+    new(mode, *args, **opts).limit(&block)
+  end
+
+  def expunge
+    redis.scan_each(match: "#{self.name}*") do |key|
+      redis.del key
+    end
   end
 
-  class LimitExceeded < RuntimeError; end
 end
+
+Berater.register(:concurrency, Berater::ConcurrencyLimiter)
+Berater.register(:inhibited, Berater::Inhibitor)
+Berater.register(:rate, Berater::RateLimiter)
+Berater.register(:unlimited, Berater::Unlimiter)

data/lib/berater/base_limiter.rb

@@ -0,0 +1,34 @@
+module Berater
+  class BaseLimiter
+
+    class Overloaded < RuntimeError; end
+
+    attr_reader :options
+
+    def initialize(**opts)
+      @options = opts
+    end
+
+    def key
+      if options[:key]
+        "#{self.class}:#{options[:key]}"
+      else
+        # default value
+        self.class.to_s
+      end
+    end
+
+    def redis
+      options[:redis] || Berater.redis
+    end
+
+    def limit(**opts)
+      raise NotImplementedError
+    end
+
+    def self.limit(*args, **opts, &block)
+      self.new(*args, **opts).limit(&block)
+    end
+
+  end
+end

data/lib/berater/concurrency_limiter.rb

@@ -0,0 +1,149 @@
+module Berater
+  class ConcurrencyLimiter < BaseLimiter
+
+    class Incapacitated < Overloaded; end
+
+    attr_reader :capacity, :timeout
+
+    def initialize(capacity, **opts)
+      super(**opts)
+
+      self.capacity = capacity
+      self.timeout = opts[:timeout] || 0
+    end
+
+    def capacity=(capacity)
+      unless capacity.is_a? Integer
+        raise ArgumentError, "expected Integer, found #{capacity.class}"
+      end
+
+      raise ArgumentError, "capacity must be >= 0" unless capacity >= 0
+
+      @capacity = capacity
+    end
+
+    def timeout=(timeout)
+      unless timeout.is_a? Integer
+        raise ArgumentError, "expected Integer, found #{timeout.class}"
+      end
+
+      raise ArgumentError, "timeout must be >= 0" unless timeout >= 0
+
+      @timeout = timeout
+    end
+
+    class Lock
+      attr_reader :limiter, :id
+
+      def initialize(limiter, id)
+        @limiter = limiter
+        @id = id
+        @released = false
+        @locked_at = Time.now
+      end
+
+      def release
+        raise 'lock already released' if released?
+        raise 'lock expired' if expired?
+
+        @released = limiter.release(self)
+      end
+
+      def released?
+        @released
+      end
+
+      def expired?
+        @locked_at + limiter.timeout < Time.now
+      end
+    end
+
+    LUA_SCRIPT = <<~LUA.gsub(/^\s*(--.*\n)?/, '')
+      local key = KEYS[1]
+      local capacity = tonumber(ARGV[1])
+      local ttl = tonumber(ARGV[2])
+
+      local exists
+      local count
+      local lock
+      local ts = unpack(redis.call('TIME'))
+
+      -- check to see if key already exists
+      if ttl == 0 then
+        exists = redis.call('EXISTS', key)
+      else
+        -- and refresh TTL while we're at it
+        exists = redis.call('EXPIRE', key, ttl * 2)
+      end
+
+      if exists == 1 then
+        -- purge stale hosts
+        if ttl > 0 then
+          redis.call('ZREMRANGEBYSCORE', key, '-inf', ts - ttl)
+        end
+
+        -- check capacity (subtract one for next lock entry)
+        count = redis.call('ZCARD', key) - 1
+
+        if count < capacity then
+          -- yay, grab a lock
+
+          -- regenerate next lock entry, which has score inf
+          lock = unpack(redis.call('ZPOPMAX', key))
+          redis.call('ZADD', key, 'inf', (lock + 1) % 2^52)
+
+          count = count + 1
+        end
+      else
+        count = 1
+        lock = "1"
+
+        -- create structure to track locks and next id
+        redis.call('ZADD', key, 'inf', lock + 1)
+
+        if ttl > 0 then
+          redis.call('EXPIRE', key, ttl * 2)
+        end
+      end
+
+      if lock then
+        -- store lock and timestamp
+        redis.call('ZADD', key, ts, lock)
+      end
+
+      return { count, lock }
+    LUA
+
+    def limit(**opts, &block)
+      unless opts.empty?
+        return self.class.new(
+          capacity,
+          **options.merge(opts)
+          # **options.merge(timeout: timeout).merge(opts)
+        ).limit(&block)
+      end
+
+      count, lock_id = redis.eval(LUA_SCRIPT, [ key ], [ capacity, timeout ])
+
+      raise Incapacitated unless lock_id
+
+      lock = Lock.new(self, lock_id)
+
+      if block_given?
+        begin
+          yield
+        ensure
+          release(lock)
+        end
+      else
+        lock
+      end
+    end
+
+    def release(lock)
+      res = redis.zrem(key, lock.id)
+      res == true || res == 1
+    end
+
+  end
+end

data/lib/berater/inhibitor.rb

@@ -0,0 +1,21 @@
+module Berater
+  class Inhibitor < BaseLimiter
+
+    class Inhibited < Overloaded; end
+
+    def initialize(*args, **opts)
+      super(**opts)
+    end
+
+    def limit(**opts, &block)
+      unless opts.empty?
+        return self.class.new(
+          **options.merge(opts)
+        ).limit(&block)
+      end
+
+      raise Inhibited
+    end
+
+  end
+end

data/lib/berater/rate_limiter.rb

@@ -0,0 +1,84 @@
+module Berater
+  class RateLimiter < BaseLimiter
+
+    class Overrated < Overloaded; end
+
+    attr_accessor :count, :interval
+
+    def initialize(count, interval, **opts)
+      super(**opts)
+
+      self.count = count
+      self.interval = interval
+    end
+
+    def count=(count)
+      unless count.is_a? Integer
+        raise ArgumentError, "expected Integer, found #{count.class}"
+      end
+
+      raise ArgumentError, "count must be >= 0" unless count >= 0
+
+      @count = count
+    end
+
+    def interval=(interval)
+      @interval = interval.dup
+
+      case @interval
+      when Integer
+        raise ArgumentError, "interval must be >= 0" unless @interval >= 0
+      when String
+        @interval = @interval.to_sym
+      when Symbol
+      else
+        raise ArgumentError, "unexpected interval type: #{interval.class}"
+      end
+
+      if @interval.is_a? Symbol
+        case @interval
+        when :sec, :second, :seconds
+          @interval = 1
+        when :min, :minute, :minutes
+          @interval = 60
+        when :hour, :hours
+          @interval = 60 * 60
+        else
+          raise ArgumentError, "unexpected interval value: #{interval}"
+        end
+      end
+
+      @interval
+    end
+
+    def limit(**opts, &block)
+      unless opts.empty?
+        return self.class.new(
+          count,
+          interval,
+          options.merge(opts)
+        ).limit(&block)
+      end
+
+      ts = Time.now.to_i
+
+      # bucket into time slot
+      rkey = "%s:%d" % [ key, ts - ts % @interval ]
+
+      count, _ = redis.multi do
+        redis.incr rkey
+        redis.expire rkey, @interval * 2
+      end
+
+      raise Overrated if count > @count
+
+      if block_given?
+        yield
+      else
+        count
+      end
+    end
+
+  end
+end
+

data/lib/berater/unlimiter.rb

@@ -0,0 +1,19 @@
+module Berater
+  class Unlimiter < BaseLimiter
+
+    def initialize(*args, **opts)
+      super(**opts)
+    end
+
+    def limit(**opts, &block)
+      unless opts.empty?
+        return self.class.new(
+          **options.merge(opts)
+        ).limit(&block)
+      end
+
+      yield if block_given?
+    end
+
+  end
+end

data/lib/berater/version.rb

@@ -0,0 +1,3 @@
+module Berater
+  VERSION = '0.1.0'
+end

data/spec/berater_spec.rb

@@ -0,0 +1,192 @@
+describe Berater do
+
+  it 'is connected to Redis' do
+    expect(Berater.redis.ping).to eq 'PONG'
+  end
+
+  it { is_expected.to respond_to :configure }
+
+  describe '.configure' do
+    it 'can be set via configure' do
+      Berater.configure do |c|
+        c.mode = :rate
+      end
+
+      expect(Berater.mode).to eq :rate
+    end
+  end
+
+  describe '.redis' do
+    it 'can be reset' do
+      expect(Berater.redis).not_to be_nil
+      Berater.redis = nil
+      expect(Berater.redis).to be_nil
+    end
+  end
+
+  describe '.mode' do
+    it 'validates inputs' do
+      expect { Berater.mode = :foo }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'unlimited mode' do
+    before { Berater.mode = :unlimited }
+
+    describe '.new' do
+      let(:limiter) { Berater.new(:unlimited) }
+
+      it 'instantiates an Unlimiter' do
+        expect(limiter).to be_a Berater::Unlimiter
+      end
+
+      it 'inherits redis' do
+        expect(limiter.redis).to be Berater.redis
+      end
+
+      it 'accepts options' do
+        redis = double('Redis')
+        limiter = Berater.new(:unlimited, key: 'key', redis: redis)
+        expect(limiter.key).to match(/key/)
+        expect(limiter.redis).to be redis
+      end
+    end
+
+    describe '.limit' do
+      it 'works' do
+        expect(Berater.limit).to be_nil
+      end
+
+      it 'yields' do
+        expect {|b| Berater.limit(&b) }.to yield_control
+      end
+
+      it 'never limits' do
+        10.times { expect(Berater.limit { 123 } ).to eq 123 }
+      end
+    end
+  end
+
+  context 'inhibited mode' do
+    before { Berater.mode = :inhibited }
+
+    describe '.new' do
+      let(:limiter) { Berater.new(:inhibited) }
+
+      it 'instantiates an Inhibitor' do
+        expect(limiter).to be_a Berater::Inhibitor
+      end
+
+      it 'inherits redis' do
+        expect(limiter.redis).to be Berater.redis
+      end
+
+      it 'accepts options' do
+        redis = double('Redis')
+        limiter = Berater.new(:inhibited, key: 'key', redis: redis)
+        expect(limiter.key).to match(/key/)
+        expect(limiter.redis).to be redis
+      end
+    end
+
+    describe '.limit' do
+      it 'always limits' do
+        expect { Berater.limit }.to be_inhibited
+      end
+    end
+  end
+
+  context 'rate mode' do
+    before { Berater.mode = :rate }
+
+    describe '.limiter' do
+      let(:limiter) { Berater.new(:rate, 1, :second) }
+
+      it 'instantiates a RateLimiter' do
+        expect(limiter).to be_a Berater::RateLimiter
+      end
+
+      it 'inherits redis' do
+        expect(limiter.redis).to be Berater.redis
+      end
+
+      it 'accepts options' do
+        redis = double('Redis')
+        limiter = Berater.new(:rate, 1, :second, key: 'key', redis: redis)
+        expect(limiter.key).to match(/key/)
+        expect(limiter.redis).to be redis
+      end
+    end
+
+    describe '.limit' do
+      it 'works' do
+        expect(Berater.limit(1, :second)).to eq 1
+      end
+
+      it 'yields' do
+        expect {|b| Berater.limit(2, :second, &b) }.to yield_control
+        expect(Berater.limit(2, :second) { 123 }).to eq 123
+      end
+
+      it 'limits excessive calls' do
+        expect(Berater.limit(1, :second)).to eq 1
+        expect { Berater.limit(1, :second) }.to be_overrated
+      end
+
+      it 'accepts options' do
+        redis = double('Redis')
+        expect(redis).to receive(:multi)
+
+        Berater.limit(1, :second, redis: redis) rescue nil
+      end
+    end
+  end
+
+  context 'concurrency mode' do
+    before { Berater.mode = :concurrency }
+
+    describe '.limiter' do
+      let(:limiter) { Berater.new(:concurrency, 1) }
+
+      it 'instantiates a ConcurrencyLimiter' do
+        expect(limiter).to be_a Berater::ConcurrencyLimiter
+      end
+
+      it 'inherits redis' do
+        expect(limiter.redis).to be Berater.redis
+      end
+
+      it 'accepts options' do
+        redis = double('Redis')
+        limiter = Berater.new(:concurrency, 1, key: 'key', redis: redis)
+        expect(limiter.key).to match(/key/)
+        expect(limiter.redis).to be redis
+      end
+    end
+
+    describe '.limit' do
+      it 'works (without blocks by returning a lock)' do
+        lock = Berater.limit(1)
+        expect(lock).to be_a Berater::ConcurrencyLimiter::Lock
+        expect(lock.release).to be true
+      end
+
+      it 'yields' do
+        expect {|b| Berater.limit(1, &b) }.to yield_control
+      end
+
+      it 'limits excessive calls' do
+        Berater.limit(1)
+        expect { Berater.limit(1) }.to be_incapacitated
+      end
+
+      it 'accepts options' do
+        redis = double('Redis')
+        expect(redis).to receive(:eval)
+
+        Berater.limit(1, redis: redis) rescue nil
+      end
+    end
+  end
+
+end

data/spec/concurrency_limiter_spec.rb

@@ -0,0 +1,189 @@
+describe Berater::ConcurrencyLimiter do
+  before { Berater.mode = :concurrency }
+
+  describe '.new' do
+    let(:limiter) { described_class.new(1) }
+
+    it 'initializes' do
+      expect(limiter.capacity).to be 1
+    end
+
+    it 'has default values' do
+      expect(limiter.key).to eq described_class.to_s
+      expect(limiter.redis).to be Berater.redis
+    end
+  end
+
+  describe '#capacity' do
+    def expect_capacity(capacity)
+      limiter = described_class.new(capacity)
+      expect(limiter.capacity).to eq capacity
+    end
+
+    it { expect_capacity(0) }
+    it { expect_capacity(1) }
+    it { expect_capacity(10_000) }
+
+    context 'with erroneous values' do
+      def expect_bad_capacity(capacity)
+        expect do
+          described_class.new(capacity)
+        end.to raise_error ArgumentError
+      end
+
+      it { expect_bad_capacity(0.5) }
+      it { expect_bad_capacity(-1) }
+      it { expect_bad_capacity('1') }
+      it { expect_bad_capacity(:one) }
+    end
+  end
+
+  describe '#timeout' do
+    def expect_timeout(timeout)
+      limiter = described_class.new(1, timeout: timeout)
+      expect(limiter.timeout).to eq timeout
+    end
+
+    it { expect_timeout(0) }
+    it { expect_timeout(1) }
+    it { expect_timeout(10_000) }
+
+    context 'with erroneous values' do
+      def expect_bad_timeout(timeout)
+        expect do
+          described_class.new(1, timeout: timeout)
+        end.to raise_error ArgumentError
+      end
+
+      it { expect_bad_timeout(0.5) }
+      it { expect_bad_timeout(-1) }
+      it { expect_bad_timeout('1') }
+      it { expect_bad_timeout(:one) }
+    end
+  end
+
+  describe '#limit' do
+    let(:limiter) { described_class.new(2, timeout: 1) }
+
+    it 'works' do
+      expect {|b| limiter.limit(&b) }.to yield_control
+    end
+
+    it 'works many times if workers complete and return locks' do
+      30.times do
+        expect {|b| limiter.limit(&b) }.to yield_control
+      end
+    end
+
+    it 'limits excessive calls' do
+      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+
+      expect { limiter }.to be_incapacitated
+    end
+
+    it 'times out locks' do
+      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      expect { limiter }.to be_incapacitated
+
+      sleep(1)
+
+      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      expect { limiter }.to be_incapacitated
+    end
+  end
+
+  context 'with same key, different limiters' do
+    let(:limiter_one) { described_class.new(1) }
+    let(:limiter_two) { described_class.new(1) }
+
+    it { expect(limiter_one.key).to eq limiter_two.key }
+
+    it 'works as expected' do
+      expect(limiter_one.limit).to be_a Berater::ConcurrencyLimiter::Lock
+
+      expect { limiter_one }.to be_incapacitated
+      expect { limiter_two }.to be_incapacitated
+    end
+  end
+
+  context 'with different keys, same limiter' do
+    let(:limiter) { described_class.new(1) }
+
+    it 'works as expected' do
+      one_lock = limiter.limit(key: :one)
+      expect(one_lock).to be_a Berater::ConcurrencyLimiter::Lock
+
+      expect { limiter.limit(key: :one) {} }.to be_incapacitated
+      expect { limiter.limit(key: :two) {} }.not_to be_incapacitated
+
+      two_lock = limiter.limit(key: :two)
+      expect(two_lock).to be_a Berater::ConcurrencyLimiter::Lock
+
+      expect { limiter.limit(key: :one) {} }.to be_incapacitated
+      expect { limiter.limit(key: :two) {} }.to be_incapacitated
+
+      one_lock.release
+      expect { limiter.limit(key: :one) {} }.not_to be_incapacitated
+      expect { limiter.limit(key: :two) {} }.to be_incapacitated
+
+      two_lock.release
+      expect { limiter.limit(key: :one) {} }.not_to be_incapacitated
+      expect { limiter.limit(key: :two) {} }.not_to be_incapacitated
+    end
+  end
+
+  context 'with same key, different capacities' do
+    let(:limiter_one) { described_class.new(1) }
+    let(:limiter_two) { described_class.new(2) }
+
+    it { expect(limiter_one.capacity).not_to eq limiter_two.capacity }
+
+    it 'works as expected' do
+      one_lock = limiter_one.limit
+      expect(one_lock).to be_a Berater::ConcurrencyLimiter::Lock
+
+      expect { limiter_one }.to be_incapacitated
+      expect { limiter_two }.not_to be_incapacitated
+
+      two_lock = limiter_two.limit
+      expect(two_lock).to be_a Berater::ConcurrencyLimiter::Lock
+
+      expect { limiter_one }.to be_incapacitated
+      expect { limiter_two }.to be_incapacitated
+
+      one_lock.release
+      expect { limiter_one }.to be_incapacitated
+      expect { limiter_two }.not_to be_incapacitated
+
+      two_lock.release
+      expect { limiter_one }.not_to be_incapacitated
+      expect { limiter_two }.not_to be_incapacitated
+    end
+  end
+
+  context 'with different keys, different limiters' do
+    let(:limiter_one) { described_class.new(1, key: :one) }
+    let(:limiter_two) { described_class.new(1, key: :two) }
+
+    it 'works as expected' do
+      expect { limiter_one }.not_to be_incapacitated
+      expect { limiter_two }.not_to be_incapacitated
+
+      one_lock = limiter_one.limit
+      expect(one_lock).to be_a Berater::ConcurrencyLimiter::Lock
+
+      expect { limiter_one }.to be_incapacitated
+      expect { limiter_two }.not_to be_incapacitated
+
+      two_lock = limiter_two.limit
+      expect(two_lock).to be_a Berater::ConcurrencyLimiter::Lock
+
+      expect { limiter_one }.to be_incapacitated
+      expect { limiter_two }.to be_incapacitated
+    end
+  end
+
+end

data/spec/concurrency_lock_spec.rb

@@ -0,0 +1,34 @@
+describe Berater::ConcurrencyLimiter::Lock do
+  subject { Berater.limit(1, timeout: 1) }
+
+  before { Berater.mode = :concurrency }
+
+  it { expect(subject.released?).to be false }
+  it { expect(subject.expired?).to be false }
+
+  context 'after being released' do
+    before { subject.release }
+
+    it { expect(subject.released?).to be true }
+    it { expect(subject.expired?).to be false }
+
+    it 'can not be released again' do
+      expect { subject.release }.to raise_error(RuntimeError, /already/)
+    end
+  end
+
+  context 'when enough time passes' do
+    before { subject; Timecop.freeze(2) }
+
+    it 'expires' do
+      expect(subject.expired?).to be true
+    end
+
+    it 'fails to release' do
+      expect { subject.release }.to raise_error(RuntimeError, /expired/)
+    end
+
+    it { expect(subject.released?).to be false }
+  end
+
+end

data/spec/inhibitor_spec.rb

@@ -0,0 +1,37 @@
+describe Berater::Inhibitor do
+  before { Berater.mode = :inhibited }
+
+  describe '.new' do
+    it 'initializes without any arguments or options' do
+      expect(described_class.new).to be_a described_class
+    end
+
+    it 'initializes with any arguments and options' do
+      expect(described_class.new(:abc, x: 123)).to be_a described_class
+    end
+
+    it 'has default values' do
+      expect(described_class.new.key).to eq described_class.to_s
+      expect(described_class.new.redis).to be Berater.redis
+    end
+  end
+
+  describe '.limit' do
+    it 'always limits' do
+      expect { described_class.limit }.to be_inhibited
+    end
+
+    it 'works with any arguments or options' do
+      expect { described_class.limit(:abc, x: 123) }.to be_inhibited
+    end
+  end
+
+  describe '#limit' do
+    let(:limiter) { described_class.new }
+
+    it 'always limits' do
+      expect { described_class.limit }.to be_inhibited
+    end
+  end
+
+end

data/spec/matcher_spec.rb

@@ -0,0 +1,118 @@
+describe 'be_overloaded' do
+  context 'Berater::Unlimiter' do
+    let(:limiter) { Berater.new(:unlimited) }
+
+    it { expect(limiter).not_to be_overloaded }
+    it { expect(limiter).not_to be_inhibited }
+    it { expect(limiter).not_to be_overrated }
+    it { expect(limiter).not_to be_incapacitated }
+
+    it { expect { limiter }.not_to be_overloaded }
+    it { expect { limiter }.not_to be_inhibited }
+    it { expect { limiter }.not_to be_overrated }
+    it { expect { limiter }.not_to be_incapacitated }
+
+    it { expect { limiter.limit }.not_to be_overloaded }
+    it { expect { limiter.limit }.not_to be_inhibited }
+    it { expect { limiter.limit }.not_to be_overrated }
+    it { expect { limiter.limit }.not_to be_incapacitated }
+  end
+
+  context 'Berater::Inhibitor' do
+    let(:limiter) { Berater.new(:inhibited) }
+
+    it { expect(limiter).to be_overloaded }
+    it { expect(limiter).to be_inhibited }
+
+    it { expect { limiter }.to be_overloaded }
+    it { expect { limiter }.to be_inhibited }
+
+    it { expect { limiter.limit }.to be_overloaded }
+    it { expect { limiter.limit }.to be_inhibited }
+  end
+
+  context 'Berater::RateLimiter' do
+    let(:limiter) { Berater.new(:rate, 1, :second) }
+
+    it { expect(limiter).not_to be_overloaded }
+    it { expect(limiter).not_to be_inhibited }
+    it { expect(limiter).not_to be_overrated }
+    it { expect(limiter).not_to be_incapacitated }
+
+    it { expect { limiter }.not_to be_overloaded }
+    it { expect { limiter }.not_to be_inhibited }
+    it { expect { limiter }.not_to be_overrated }
+    it { expect { limiter }.not_to be_incapacitated }
+
+    it { expect { limiter.limit }.not_to be_overloaded }
+    it { expect { limiter.limit }.not_to be_inhibited }
+    it { expect { limiter.limit }.not_to be_overrated }
+    it { expect { limiter.limit }.not_to be_incapacitated }
+
+    context 'once limit is used up' do
+      before { limiter.limit }
+
+      it 'should be_overrated' do
+        expect(limiter).to be_overrated
+      end
+
+      it 'should be_overrated' do
+        expect { limiter }.to be_overrated
+      end
+
+      it 'should be_overrated' do
+        expect { limiter.limit }.to be_overrated
+      end
+    end
+  end
+
+  context 'Berater::ConcurrencyLimiter' do
+    let(:limiter) { Berater.new(:concurrency, 1) }
+
+    it { expect(limiter).not_to be_overloaded }
+    it { expect(limiter).not_to be_inhibited }
+    it { expect(limiter).not_to be_overrated }
+    it { expect(limiter).not_to be_incapacitated }
+
+    it { expect { limiter }.not_to be_overloaded }
+    it { expect { limiter }.not_to be_inhibited }
+    it { expect { limiter }.not_to be_overrated }
+    it { expect { limiter }.not_to be_incapacitated }
+
+    it { expect { limiter.limit }.not_to be_overloaded }
+    it { expect { limiter.limit }.not_to be_inhibited }
+    it { expect { limiter.limit }.not_to be_overrated }
+    it { expect { limiter.limit }.not_to be_incapacitated }
+
+    context 'when lock is released' do
+      it 'should be_incapacitated' do
+        3.times do
+          expect(limiter).not_to be_incapacitated
+        end
+      end
+
+      it 'should be_incapacitated' do
+        3.times do
+          expect { limiter }.not_to be_incapacitated
+        end
+      end
+
+      it 'should be_incapacitated' do
+        3.times do
+          expect { limiter.limit {} }.not_to be_incapacitated
+        end
+      end
+    end
+
+    context 'when lock is *not* released' do
+      it 'should be_incapacitated' do
+        expect { limiter.limit }.not_to be_incapacitated
+        expect { limiter.limit }.to be_incapacitated
+      end
+
+      it 'should be_incapacitated' do
+        expect { 3.times { limiter.limit } }.to be_incapacitated
+      end
+    end
+  end
+end

data/spec/rate_limiter_spec.rb

@@ -0,0 +1,166 @@
+describe Berater::RateLimiter do
+  before { Berater.mode = :rate }
+
+  describe '.new' do
+    let(:limiter) { described_class.new(1, :second) }
+
+    it 'initializes' do
+      expect(limiter.count).to eq 1
+      expect(limiter.interval).to eq 1
+    end
+
+    it 'has default values' do
+      expect(limiter.key).to eq described_class.to_s
+      expect(limiter.redis).to be Berater.redis
+    end
+  end
+
+  describe '#count' do
+    def expect_count(count)
+      limiter = described_class.new(count, :second)
+      expect(limiter.count).to eq count
+    end
+
+    it { expect_count(0) }
+    it { expect_count(1) }
+    it { expect_count(100) }
+
+    context 'with erroneous values' do
+      def expect_bad_count(count)
+        expect do
+          described_class.new(count, :second)
+        end.to raise_error ArgumentError
+      end
+
+      it { expect_bad_count(0.5) }
+      it { expect_bad_count(-1) }
+      it { expect_bad_count('1') }
+      it { expect_bad_count(:one) }
+    end
+  end
+
+  describe '#interval' do
+    def expect_interval(interval, expected)
+      limiter = described_class.new(1, interval)
+      expect(limiter.interval).to eq expected
+    end
+
+    context 'with ints' do
+      it { expect_interval(0, 0) }
+      it { expect_interval(1, 1) }
+      it { expect_interval(33, 33) }
+    end
+
+    context 'with symbols' do
+      it { expect_interval(:sec, 1) }
+      it { expect_interval(:second, 1) }
+      it { expect_interval(:seconds, 1) }
+
+      it { expect_interval(:min, 60) }
+      it { expect_interval(:minute, 60) }
+      it { expect_interval(:minutes, 60) }
+
+      it { expect_interval(:hour, 3600) }
+      it { expect_interval(:hours, 3600) }
+    end
+
+    context 'with strings' do
+      it { expect_interval('sec', 1) }
+      it { expect_interval('minute', 60) }
+      it { expect_interval('hours', 3600) }
+    end
+
+    context 'with erroneous values' do
+      def expect_bad_interval(interval)
+        expect do
+          described_class.new(1, interval)
+        end.to raise_error(ArgumentError)
+      end
+
+      it { expect_bad_interval(-1) }
+      it { expect_bad_interval(:secondz) }
+      it { expect_bad_interval('huor') }
+    end
+  end
+
+  describe '#limit' do
+    let(:limiter) { described_class.new(3, :second) }
+
+    it 'works' do
+      expect(limiter.limit).to eq 1
+    end
+
+    it 'counts' do
+      expect(limiter.limit).to eq 1
+      expect(limiter.limit).to eq 2
+      expect(limiter.limit).to eq 3
+    end
+
+    it 'yields' do
+      expect {|b| limiter.limit(&b) }.to yield_control
+      expect(limiter.limit { 123 }).to eq 123
+    end
+
+    it 'limits excessive calls' do
+      3.times { limiter.limit }
+
+      expect { limiter.limit }.to be_overrated
+    end
+
+    it 'limit resets over time' do
+      expect(limiter.limit).to eq 1
+      expect(limiter.limit).to eq 2
+      expect(limiter.limit).to eq 3
+      expect(limiter).to be_overrated
+
+      # travel forward a second
+      Timecop.freeze(1)
+
+      expect(limiter.limit).to eq 1
+      expect(limiter.limit).to eq 2
+      expect(limiter.limit).to eq 3
+      expect(limiter).to be_overrated
+    end
+  end
+
+  context 'with same key, different limiters' do
+    let(:limiter_one) { described_class.new(1, :second) }
+    let(:limiter_two) { described_class.new(1, :second) }
+
+    it 'works as expected' do
+      expect(limiter_one.limit).to eq 1
+
+      expect { limiter_one }.to be_overrated
+      expect { limiter_two }.to be_overrated
+    end
+  end
+
+  context 'with different keys, same limiter' do
+    let(:limiter) { described_class.new(1, :second) }
+
+    it 'works as expected' do
+      expect { limiter.limit(key: :one) }.not_to be_overrated
+      expect { limiter.limit(key: :one) }.to be_overrated
+
+      expect { limiter.limit(key: :two) }.not_to be_overrated
+      expect { limiter.limit(key: :two) }.to be_overrated
+    end
+  end
+
+  context 'with different keys, different limiters' do
+    let(:limiter_one) { described_class.new(1, :second, key: :one) }
+    let(:limiter_two) { described_class.new(2, :second, key: :two) }
+
+    it 'works as expected' do
+      expect(limiter_one.limit).to eq 1
+      expect(limiter_two.limit).to eq 1
+
+      expect { limiter_one.limit }.to be_overrated
+      expect(limiter_two.limit).to eq 2
+
+      expect { limiter_one.limit }.to be_overrated
+      expect { limiter_two.limit }.to be_overrated
+    end
+  end
+
+end

data/spec/unlimiter_spec.rb

@@ -0,0 +1,61 @@
+describe Berater::Unlimiter do
+  before { Berater.mode = :unlimited }
+
+  describe '.new' do
+    it 'initializes without any arguments or options' do
+      expect(described_class.new).to be_a described_class
+    end
+
+    it 'initializes with any arguments and options' do
+      expect(described_class.new(:abc, x: 123)).to be_a described_class
+    end
+
+    it 'has default values' do
+      expect(described_class.new.key).to eq described_class.to_s
+      expect(described_class.new.redis).to be Berater.redis
+    end
+  end
+
+  describe '.limit' do
+    it 'works' do
+      expect(described_class.limit).to be_nil
+    end
+
+    it 'yields' do
+      expect {|b| described_class.limit(&b) }.to yield_control
+    end
+
+    it 'is never overloaded' do
+      10.times do
+        expect { described_class.limit }.not_to be_overloaded
+      end
+    end
+
+    it 'works with any arguments or options' do
+      expect(described_class.limit(:abc, x: 123)).to be_nil
+    end
+  end
+
+  describe '#limit' do
+    let(:limiter) { described_class.new }
+
+    it 'works' do
+      expect(limiter.limit).to be_nil
+    end
+
+    it 'yields' do
+      expect {|b| limiter.limit(&b) }.to yield_control
+    end
+
+    it 'is never overloaded' do
+      10.times do
+        expect { limiter.limit }.not_to be_overloaded
+      end
+    end
+
+    it 'works with any arguments or options' do
+      expect(limiter.limit(x: 123)).to be_nil
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: berater
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Daniel Pepper
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-08-29 00:00:00.000000000 Z
+date: 2021-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -25,7 +25,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: clockwork
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -42,42 +56,83 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: rate limiter
-email: 
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/berater.rb
-homepage: https://github.com/dpep/berater
+- lib/berater/base_limiter.rb
+- lib/berater/concurrency_limiter.rb
+- lib/berater/inhibitor.rb
+- lib/berater/rate_limiter.rb
+- lib/berater/unlimiter.rb
+- lib/berater/version.rb
+- spec/berater_spec.rb
+- spec/concurrency_limiter_spec.rb
+- spec/concurrency_lock_spec.rb
+- spec/inhibitor_spec.rb
+- spec/matcher_spec.rb
+- spec/rate_limiter_spec.rb
+- spec/unlimiter_spec.rb
+homepage: https://github.com/dpep/berater_rb
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -92,9 +147,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: Berater
-test_files: []
+test_files:
+- spec/rate_limiter_spec.rb
+- spec/matcher_spec.rb
+- spec/concurrency_limiter_spec.rb
+- spec/concurrency_lock_spec.rb
+- spec/berater_spec.rb
+- spec/inhibitor_spec.rb
+- spec/unlimiter_spec.rb