berater 0.6.1 → 0.9.0

data/lib/berater/rspec.rb

@@ -1,14 +1,13 @@
 require 'berater'
 require 'berater/rspec/matchers'
 require 'berater/test_mode'
-require 'rspec'
+require 'rspec/core'
 
 RSpec.configure do |config|
   config.include(Berater::Matchers)
 
   config.after do
     Berater.expunge rescue nil
-    Berater.redis.script(:flush) rescue nil
     Berater.reset
   end
 end

data/lib/berater/rspec/matchers.rb

@@ -1,10 +1,6 @@
 module Berater
   module Matchers
     class Overloaded
-      def initialize(type)
-        @type = type
-      end
-
       def supports_block_expectations?
         true
       end
@@ -12,13 +8,13 @@ module Berater
       def matches?(obj)
         case obj
         when Proc
-          # eg. expect { ... }.to be_overrated
+          # eg. expect { ... }.to be_overloaded
           res = obj.call
 
           if res.is_a? Berater::Limiter
             # eg. expect { Berater.new(...) }.to be_overloaded
             @limiter = res
-            res.overloaded?
+            @limiter.utilization >= 1
           else
             # eg. expect { Berater(...)  }.to be_overloaded
             # eg. expect { limiter.limit }.to be_overloaded
@@ -27,55 +23,39 @@ module Berater
         when Berater::Limiter
           # eg. expect(Berater.new(...)).to be_overloaded
           @limiter = obj
-          obj.overloaded?
+          @limiter.utilization >= 1
         end
-      rescue @type
+      rescue Berater::Overloaded
         true
       end
 
       def description
         if @limiter
-          "be #{verb}"
+          "be overloaded"
         else
-          "raise #{@type}"
+          "raise #{Berater::Overloaded}"
         end
       end
 
       def failure_message
         if @limiter
-          "expected to be #{verb}"
+          "expected to be overloaded"
         else
-          "expected #{@type} to be raised"
+          "expected #{Berater::Overloaded} to be raised"
         end
       end
 
       def failure_message_when_negated
         if @limiter
-          "expected not to be #{verb}"
+          "expected not to be overloaded"
         else
-          "did not expect #{@type} to be raised"
+          "did not expect #{Berater::Overloaded} to be raised"
         end
       end
-
-      private def verb
-        @type.to_s.split('::')[-1].downcase
-      end
     end
 
     def be_overloaded
-      Overloaded.new(Berater::Overloaded)
-    end
-
-    def be_overrated
-      Overloaded.new(Berater::RateLimiter::Overrated)
-    end
-
-    def be_incapacitated
-      Overloaded.new(Berater::ConcurrencyLimiter::Incapacitated)
-    end
-
-    def be_inhibited
-      Overloaded.new(Berater::Inhibitor::Inhibited)
+      Overloaded.new
     end
   end
 end

data/lib/berater/static_limiter.rb

@@ -0,0 +1,49 @@
+module Berater
+  class StaticLimiter < Limiter
+
+    LUA_SCRIPT = Berater::LuaScript(<<~LUA
+      local key = KEYS[1]
+      local capacity = tonumber(ARGV[1])
+      local cost = tonumber(ARGV[2])
+
+      local count = redis.call('GET', key) or 0
+      local allowed = (count + cost) <= capacity
+
+      if allowed then
+        count = count + cost
+        redis.call('SET', key, count)
+      end
+
+      return { tostring(count), allowed }
+    LUA
+    )
+
+    protected def acquire_lock(capacity, cost)
+      if cost == 0
+        # utilization check
+        count = redis.get(cache_key) || "0"
+        allowed = true
+      else
+        count, allowed = LUA_SCRIPT.eval(
+          redis, [ cache_key ], [ capacity, cost ],
+        )
+      end
+
+      # Redis returns Floats as strings to maintain precision
+      count = count.include?('.') ? count.to_f : count.to_i
+
+      raise Overloaded unless allowed
+
+      release_fn = if cost > 0
+        proc { redis.incrbyfloat(cache_key, -cost) }
+      end
+
+      Lock.new(capacity, count, release_fn)
+    end
+
+    def to_s
+      "#<#{self.class}(#{key}: #{capacity})>"
+    end
+
+  end
+end

data/lib/berater/test_mode.rb

@@ -1,43 +1,47 @@
 require 'berater'
 
 module Berater
-  extend self
 
-  attr_reader :test_mode
+  module TestMode
+    attr_reader :test_mode
+
+    def test_mode=(mode)
+      unless [ nil, :pass, :fail ].include?(mode)
+        raise ArgumentError, "invalid mode: #{Berater.test_mode}"
+      end
 
-  def test_mode=(mode)
-    unless [ nil, :pass, :fail ].include?(mode)
-      raise ArgumentError, "invalid mode: #{Berater.test_mode}"
+      @test_mode = mode
     end
 
-    @test_mode = mode
+    def reset
+      super
+      @test_mode = nil
+    end
   end
 
-  module TestMode
-    def acquire_lock(*)
-      case Berater.test_mode
-      when :pass
-        Lock.new(Float::INFINITY, 0)
-      when :fail
-        # find class specific Overloaded error
-        e = self.class.constants.map do |name|
-          self.class.const_get(name)
-        end.find do |const|
-          const < Berater::Overloaded
-        end || Berater::Overloaded
-
-        raise e
-      else
-        super
+  class Limiter
+    module TestMode
+      def acquire_lock(*)
+        case Berater.test_mode
+        when :pass
+          Lock.new(Float::INFINITY, 0)
+        when :fail
+          raise Overloaded
+        else
+          super
+        end
       end
     end
   end
 
 end
 
+# prepend class methods
+Berater.singleton_class.prepend Berater::TestMode
+
 # stub each Limiter subclass
 ObjectSpace.each_object(Class).each do |klass|
   next unless klass < Berater::Limiter
 
-  klass.prepend(Berater::TestMode)
+  klass.prepend Berater::Limiter::TestMode
 end

data/lib/berater/unlimiter.rb

@@ -5,6 +5,10 @@ module Berater
       super(key, Float::INFINITY, **opts)
     end
 
+    def to_s
+      "#<#{self.class}>"
+    end
+
     protected
 
     def capacity=(*)

data/lib/berater/utils.rb

@@ -42,5 +42,14 @@ module Berater
       (res * 10**3).to_i
     end
 
+    def convenience_fn(klass, *args, **opts, &block)
+      limiter = klass.new(*args, **opts)
+      if block_given?
+        limiter.limit(&block)
+      else
+        limiter
+      end
+    end
+
   end
 end

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = '0.6.1'
+  VERSION = '0.9.0'
 end

data/spec/berater_spec.rb

@@ -24,50 +24,33 @@ describe Berater do
     end
   end
 
-  describe '.new' do
-    context 'unlimited mode' do
-      let(:limiter) { Berater.new(:key, Float::INFINITY) }
+  describe '.limiters' do
+    subject { Berater.limiters }
 
-      it 'instantiates an Unlimiter' do
-        expect(limiter).to be_a Berater::Unlimiter
-        expect(limiter.key).to be :key
-      end
-
-      it 'inherits redis' do
-        expect(limiter.redis).to be Berater.redis
-      end
+    let(:limiter) { Berater(:key, 1) }
 
-      it 'accepts options' do
-        redis = double('Redis')
-        limiter = Berater.new(:key, Float::INFINITY, redis: redis)
-        expect(limiter.redis).to be redis
-      end
+    it 'provides access to predefined limiters' do
+      expect(Berater.limiters).to be_a Berater::LimiterSet
     end
 
-    context 'inhibited mode' do
-      let(:limiter) { Berater.new(:key, 0) }
+    it 'resets with Berater' do
+      subject << limiter
+      is_expected.not_to be_empty
 
-      it 'instantiates an Inhibitor' do
-        expect(limiter).to be_a Berater::Inhibitor
-        expect(limiter.key).to be :key
-      end
+      Berater.reset
+      is_expected.to be_empty
+    end
+  end
 
-      it 'inherits redis' do
-        expect(limiter.redis).to be Berater.redis
-      end
+  shared_examples 'a Berater' do |klass, capacity, **opts|
+    describe '.new' do
+      let(:limiter) { Berater.new(:key, capacity, **opts) }
 
-      it 'accepts options' do
-        redis = double('Redis')
-        limiter = Berater.new(:key, 0, redis: redis)
-        expect(limiter.redis).to be redis
+      it 'instantiates the right class' do
+        expect(limiter).to be_a klass
       end
-    end
-
-    context 'rate mode' do
-      let(:limiter) { Berater.new(:key, 1, :second) }
 
-      it 'instantiates a RateLimiter' do
-        expect(limiter).to be_a Berater::RateLimiter
+      it 'sets the key' do
         expect(limiter.key).to be :key
       end
 
@@ -75,60 +58,45 @@ describe Berater do
         expect(limiter.redis).to be Berater.redis
       end
 
-      it 'accepts options' do
+      it 'accepts an optional redis parameter' do
         redis = double('Redis')
-        limiter = Berater.new(:key, 1, :second, redis: redis)
+        limiter = Berater.new(:key, capacity, opts.merge(redis: redis))
         expect(limiter.redis).to be redis
       end
     end
 
-    context 'concurrency mode' do
-      let(:limiter) { Berater.new(:key, 1) }
+    describe 'Berater() convenience method' do
+      let(:limiter) { Berater(:key, capacity, **opts) }
 
-      it 'instantiates a ConcurrencyLimiter' do
-        expect(limiter).to be_a Berater::ConcurrencyLimiter
-        expect(limiter.key).to be :key
+      it 'creates a limiter' do
+        expect(limiter).to be_a klass
       end
 
-      it 'inherits redis' do
-        expect(limiter.redis).to be Berater.redis
+      it 'creates an equivalent limiter' do
+        expect(limiter).to eq Berater.new(:key, capacity, **opts)
       end
 
-      it 'accepts options' do
-        redis = double('Redis')
-        limiter = Berater.new(:key, 1, redis: redis)
-        expect(limiter.redis).to be redis
-      end
-    end
-  end
+      context 'with a block' do
+        before { Berater.test_mode = :pass }
 
-  describe 'Berater() - convenience method' do
-    RSpec.shared_examples 'test convenience' do |klass, *args|
-      it 'creates a limiter' do
-        limiter = Berater(:key, *args)
-        expect(limiter).to be_a klass
-      end
+        subject { Berater(:key, capacity, **opts) { 123 } }
 
-      context 'with a block' do
         it 'creates a limiter and calls limit' do
-          limiter = Berater(:key, *args)
           expect(klass).to receive(:new).and_return(limiter)
           expect(limiter).to receive(:limit).and_call_original
+          subject
+        end
 
-          begin
-            res = Berater(:key, *args) { true }
-            expect(res).to be true
-          rescue Berater::Overloaded
-            expect(klass).to be Berater::Inhibitor
-          end
+        it 'yields' do
+          is_expected.to be 123
         end
       end
     end
-
-    include_examples 'test convenience', Berater::Unlimiter, Float::INFINITY
-    include_examples 'test convenience', Berater::Inhibitor, 0
-    include_examples 'test convenience', Berater::RateLimiter, 1, :second
-    include_examples 'test convenience', Berater::ConcurrencyLimiter, 1
   end
 
+  include_examples 'a Berater', Berater::ConcurrencyLimiter, 1, timeout: 1
+  include_examples 'a Berater', Berater::Inhibitor, 0
+  include_examples 'a Berater', Berater::RateLimiter, 1, interval: :second
+  include_examples 'a Berater', Berater::StaticLimiter, 1
+  include_examples 'a Berater', Berater::Unlimiter, Float::INFINITY
 end

data/spec/concurrency_limiter_spec.rb

@@ -18,7 +18,7 @@ describe Berater::ConcurrencyLimiter do
   describe '#capacity' do
     def expect_capacity(capacity)
       limiter = described_class.new(:key, capacity)
-      expect(limiter.capacity).to eq capacity
+      expect(limiter.capacity).to eq capacity.to_i
     end
 
     it { expect_capacity(0) }
@@ -36,22 +36,28 @@ describe Berater::ConcurrencyLimiter do
       it { expect_bad_capacity(-1) }
       it { expect_bad_capacity('1') }
       it { expect_bad_capacity(:one) }
+      it { expect_bad_capacity(Float::INFINITY) }
     end
   end
 
   describe '#timeout' do
     # see spec/utils_spec.rb
 
+    it 'defaults to nil' do
+      limiter = described_class.new(:key, 1)
+      expect(limiter.timeout).to be nil
+    end
+
     it 'saves the interval in original and millisecond format' do
       limiter = described_class.new(:key, 1, timeout: 3)
       expect(limiter.timeout).to be 3
-      expect(limiter.instance_variable_get(:@timeout_msec)).to be (3 * 10**3)
+      expect(limiter.instance_variable_get(:@timeout)).to be (3 * 10**3)
     end
 
     it 'handles infinity' do
       limiter = described_class.new(:key, 1, timeout: Float::INFINITY)
       expect(limiter.timeout).to be Float::INFINITY
-      expect(limiter.instance_variable_get(:@timeout_msec)).to be 0
+      expect(limiter.instance_variable_get(:@timeout)).to be 0
     end
   end
 
@@ -77,14 +83,14 @@ describe Berater::ConcurrencyLimiter do
       expect(limiter.limit).to be_a Berater::Lock
       expect(limiter.limit).to be_a Berater::Lock
 
-      expect(limiter).to be_incapacitated
+      expect(limiter).to be_overloaded
     end
 
     context 'with capacity 0' do
       let(:limiter) { described_class.new(:key, 0) }
 
       it 'always fails' do
-        expect(limiter).to be_incapacitated
+        expect(limiter).to be_overloaded
       end
     end
 
@@ -96,80 +102,80 @@ describe Berater::ConcurrencyLimiter do
 
         # since fractional cost is not supported
         expect(lock.capacity).to be 1
-        expect(limiter).to be_incapacitated
+        expect(limiter).to be_overloaded
       end
     end
 
     it 'limit resets over time' do
       2.times { limiter.limit }
-      expect(limiter).to be_incapacitated
+      expect(limiter).to be_overloaded
 
       Timecop.freeze(30)
 
       2.times { limiter.limit }
-      expect(limiter).to be_incapacitated
+      expect(limiter).to be_overloaded
     end
 
     it 'limit resets with millisecond precision' do
       2.times { limiter.limit }
-      expect(limiter).to be_incapacitated
+      expect(limiter).to be_overloaded
 
       # travel forward to just before first lock times out
       Timecop.freeze(29.999)
-      expect(limiter).to be_incapacitated
+      expect(limiter).to be_overloaded
 
       # traveling one more millisecond will decrement the count
       Timecop.freeze(0.001)
       2.times { limiter.limit }
-      expect(limiter).to be_incapacitated
+      expect(limiter).to be_overloaded
     end
 
     it 'accepts a dynamic capacity' do
-      expect { limiter.limit(capacity: 0) }.to be_incapacitated
+      expect { limiter.limit(capacity: 0) }.to be_overloaded
       5.times { limiter.limit(capacity: 10) }
-      expect { limiter }.to be_incapacitated
+      expect { limiter }.to be_overloaded
     end
 
     context 'with cost parameter' do
-      it { expect { limiter.limit(cost: 4) }.to be_incapacitated }
+      it { expect { limiter.limit(cost: 4) }.to be_overloaded }
 
       it 'works within limit' do
         limiter.limit(cost: 2)
-        expect(limiter).to be_incapacitated
+        expect(limiter).to be_overloaded
       end
 
       it 'releases full cost' do
         lock = limiter.limit(cost: 2)
-        expect(limiter).to be_incapacitated
+        expect(limiter).to be_overloaded
 
         lock.release
-        expect(limiter).not_to be_incapacitated
+        expect(limiter).not_to be_overloaded
 
         lock = limiter.limit(cost: 2)
-        expect(limiter).to be_incapacitated
+        expect(limiter).to be_overloaded
       end
 
       it 'respects timeout' do
         limiter.limit(cost: 2)
-        expect(limiter).to be_incapacitated
+        expect(limiter).to be_overloaded
 
         Timecop.freeze(30)
-        expect(limiter).not_to be_incapacitated
+        expect(limiter).not_to be_overloaded
 
         limiter.limit(cost: 2)
-        expect(limiter).to be_incapacitated
+        expect(limiter).to be_overloaded
       end
 
       context 'with fractional costs' do
         it 'rounds up' do
           limiter.limit(cost: 1.5)
-          expect(limiter).to be_incapacitated
+          expect(limiter).to be_overloaded
         end
 
         it 'accumulates correctly' do
           limiter.limit(cost: 0.5) # => 1
           limiter.limit(cost: 0.7) # => 2
-          expect(limiter).to be_incapacitated
+          expect(limiter).to be_overloaded
         end
       end
 
@@ -187,8 +193,8 @@ describe Berater::ConcurrencyLimiter do
       it 'works as expected' do
         expect(limiter_one.limit).to be_a Berater::Lock
 
-        expect(limiter_one).to be_incapacitated
-        expect(limiter_two).to be_incapacitated
+        expect(limiter_one).to be_overloaded
+        expect(limiter_two).to be_overloaded
       end
     end
 
@@ -202,22 +208,22 @@ describe Berater::ConcurrencyLimiter do
         one_lock = limiter_one.limit
         expect(one_lock).to be_a Berater::Lock
 
-        expect(limiter_one).to be_incapacitated
-        expect(limiter_two).not_to be_incapacitated
+        expect(limiter_one).to be_overloaded
+        expect(limiter_two).not_to be_overloaded
 
         two_lock = limiter_two.limit
         expect(two_lock).to be_a Berater::Lock
 
-        expect(limiter_one).to be_incapacitated
-        expect(limiter_two).to be_incapacitated
+        expect(limiter_one).to be_overloaded
+        expect(limiter_two).to be_overloaded
 
         one_lock.release
-        expect(limiter_one).to be_incapacitated
-        expect(limiter_two).not_to be_incapacitated
+        expect(limiter_one).to be_overloaded
+        expect(limiter_two).not_to be_overloaded
 
         two_lock.release
-        expect(limiter_one).not_to be_incapacitated
-        expect(limiter_two).not_to be_incapacitated
+        expect(limiter_one).not_to be_overloaded
+        expect(limiter_two).not_to be_overloaded
       end
     end
 
@@ -226,41 +232,41 @@ describe Berater::ConcurrencyLimiter do
       let(:limiter_two) { described_class.new(:two, 1) }
 
       it 'works as expected' do
-        expect(limiter_one).not_to be_incapacitated
-        expect(limiter_two).not_to be_incapacitated
+        expect(limiter_one).not_to be_overloaded
+        expect(limiter_two).not_to be_overloaded
 
         one_lock = limiter_one.limit
         expect(one_lock).to be_a Berater::Lock
 
-        expect(limiter_one).to be_incapacitated
-        expect(limiter_two).not_to be_incapacitated
+        expect(limiter_one).to be_overloaded
+        expect(limiter_two).not_to be_overloaded
 
         two_lock = limiter_two.limit
         expect(two_lock).to be_a Berater::Lock
 
-        expect(limiter_one).to be_incapacitated
-        expect(limiter_two).to be_incapacitated
+        expect(limiter_one).to be_overloaded
+        expect(limiter_two).to be_overloaded
       end
     end
   end
 
-  describe '#overloaded?' do
-    let(:limiter) { described_class.new(:key, 1, timeout: 30) }
+  describe '#utilization' do
+    let(:limiter) { described_class.new(:key, 10, timeout: 30) }
 
     it 'works' do
-      expect(limiter.overloaded?).to be false
-      lock = limiter.limit
-      expect(limiter.overloaded?).to be true
-      lock.release
-      expect(limiter.overloaded?).to be false
-    end
+      expect(limiter.utilization).to be 0.0
 
-    it 'respects timeout' do
-      expect(limiter.overloaded?).to be false
-      lock = limiter.limit
-      expect(limiter.overloaded?).to be true
-      Timecop.freeze(30)
-      expect(limiter.overloaded?).to be false
+      2.times { limiter.limit }
+      expect(limiter.utilization).to be 0.2
+
+      Timecop.freeze(15)
+
+      8.times { limiter.limit }
+      expect(limiter.utilization).to be 1.0
+
+      Timecop.freeze(15)
+
+      expect(limiter.utilization).to be 0.8
     end
   end