berater 0.4.0 → 0.7.0

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = '0.4.0'
+  VERSION = '0.7.0'
 end

data/spec/berater_spec.rb

@@ -7,12 +7,12 @@ describe Berater do
   it { is_expected.to respond_to :configure }
 
   describe '.configure' do
-    it 'can be set via configure' do
+    it 'is used with a block' do
       Berater.configure do |c|
         c.redis = :redis
       end
 
-      expect(Berater.redis).to eq :redis
+      expect(Berater.redis).to be :redis
     end
   end
 
@@ -25,8 +25,8 @@ describe Berater do
   end
 
   describe '.new' do
-    context 'unlimited mode' do
-      let(:limiter) { Berater.new(:key, :unlimited) }
+    context 'Unlimiter mode' do
+      let(:limiter) { Berater.new(:key, Float::INFINITY) }
 
       it 'instantiates an Unlimiter' do
         expect(limiter).to be_a Berater::Unlimiter
@@ -39,18 +39,13 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:key, :unlimited, redis: redis)
+        limiter = Berater.new(:key, Float::INFINITY, redis: redis)
         expect(limiter.redis).to be redis
       end
-
-      it 'works with convinience' do
-        expect(Berater).to receive(:new).and_return(limiter)
-        expect {|b| Berater(:key, :unlimited, &b) }.to yield_control
-      end
     end
 
-    context 'inhibited mode' do
-      let(:limiter) { Berater.new(:key, :inhibited) }
+    context 'Inhibitor mode' do
+      let(:limiter) { Berater.new(:key, 0) }
 
       it 'instantiates an Inhibitor' do
         expect(limiter).to be_a Berater::Inhibitor
@@ -63,18 +58,13 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:key, :inhibited, redis: redis)
+        limiter = Berater.new(:key, 0, redis: redis)
         expect(limiter.redis).to be redis
       end
-
-      it 'works with convinience' do
-        expect(Berater).to receive(:new).and_return(limiter)
-        expect { Berater(:key, :inhibited) }.to be_inhibited
-      end
     end
 
     context 'rate mode' do
-      let(:limiter) { Berater.new(:key, :rate, 1, :second) }
+      let(:limiter) { Berater.new(:key, 1, interval: :second) }
 
       it 'instantiates a RateLimiter' do
         expect(limiter).to be_a Berater::RateLimiter
@@ -87,18 +77,13 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:key, :rate, 1, :second, redis: redis)
+        limiter = Berater.new(:key, 1, interval: :second, redis: redis)
         expect(limiter.redis).to be redis
       end
-
-      it 'works with convinience' do
-        expect(Berater).to receive(:new).and_return(limiter)
-        expect {|b| Berater(:key, :rate, 1, :second, &b) }.to yield_control
-      end
     end
 
     context 'concurrency mode' do
-      let(:limiter) { Berater.new(:key, :concurrency, 1) }
+      let(:limiter) { Berater.new(:key, 1) }
 
       it 'instantiates a ConcurrencyLimiter' do
         expect(limiter).to be_a Berater::ConcurrencyLimiter
@@ -111,61 +96,39 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:key, :concurrency, 1, redis: redis)
+        limiter = Berater.new(:key, 1, redis: redis)
         expect(limiter.redis).to be redis
       end
-
-      it 'works with convinience' do
-        expect(Berater).to receive(:new).and_return(limiter)
-        expect {|b| Berater(:key, :concurrency, 1, &b) }.to yield_control
-      end
     end
+  end
 
-    context 'with DSL' do
-      it 'instatiates an Unlimiter' do
-        limiter = Berater.new(:key) { unlimited }
-        expect(limiter).to be_a Berater::Unlimiter
-        expect(limiter.key).to be :key
-      end
-
-      it 'instatiates an Inhibiter' do
-        limiter = Berater.new(:key) { inhibited }
-        expect(limiter).to be_a Berater::Inhibitor
-        expect(limiter.key).to be :key
-      end
-
-      it 'instatiates a RateLimiter' do
-        limiter = Berater.new(:key) { 1.per second }
-        expect(limiter).to be_a Berater::RateLimiter
-        expect(limiter.key).to be :key
-        expect(limiter.count).to be 1
-        expect(limiter.interval).to be :second
-      end
-
-      it 'instatiates a ConcurrencyLimiter' do
-        limiter = Berater.new(:key, timeout: 2) { 1.at_once }
-        expect(limiter).to be_a Berater::ConcurrencyLimiter
-        expect(limiter.key).to be :key
-        expect(limiter.capacity).to be 1
-        expect(limiter.timeout).to be 2
+  describe 'Berater() - convenience method' do
+    RSpec.shared_examples 'test convenience' do |klass, capacity, **opts|
+      it 'creates a limiter' do
+        limiter = Berater(:key, capacity, **opts)
+        expect(limiter).to be_a klass
       end
 
-      it 'does not accept mode/args and dsl block' do
-        expect {
-          Berater.new(:key, :rate) { 1.per second }
-        }.to raise_error(ArgumentError)
+      context 'with a block' do
+        it 'creates a limiter and calls limit' do
+          limiter = Berater(:key, capacity, **opts)
+          expect(klass).to receive(:new).and_return(limiter)
+          expect(limiter).to receive(:limit).and_call_original
 
-        expect {
-          Berater.new(:key, :concurrency, 2) { 3.at_once }
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'requires either mode or dsl block' do
-        expect {
-          Berater.new(:key)
-        }.to raise_error(ArgumentError)
+          begin
+            res = Berater(:key, capacity, **opts) { true }
+            expect(res).to be true
+          rescue Berater::Overloaded
+            expect(klass).to be Berater::Inhibitor
+          end
+        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, interval: :second
+    include_examples 'test convenience', Berater::ConcurrencyLimiter, 1
   end
 
 end

data/spec/concurrency_limiter_spec.rb

@@ -18,11 +18,12 @@ 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) }
     it { expect_capacity(1) }
+    it { expect_capacity(1.5) }
     it { expect_capacity(10_000) }
 
     context 'with erroneous values' do
@@ -32,7 +33,6 @@ describe Berater::ConcurrencyLimiter do
         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) }
@@ -40,31 +40,23 @@ describe Berater::ConcurrencyLimiter do
   end
 
   describe '#timeout' do
-    def expect_timeout(timeout)
-      limiter = described_class.new(:key, 1, timeout: timeout)
-      expect(limiter.timeout).to eq timeout
-    end
-
-    it { expect_timeout(0) }
-    it { expect_timeout(1) }
-    it { expect_timeout(10_000) }
+    # see spec/utils_spec.rb
 
-    context 'with erroneous values' do
-      def expect_bad_timeout(timeout)
-        expect do
-          described_class.new(:key, 1, timeout: timeout)
-        end.to raise_error ArgumentError
-      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)
+    end
 
-      it { expect_bad_timeout(0.5) }
-      it { expect_bad_timeout(-1) }
-      it { expect_bad_timeout('1') }
-      it { expect_bad_timeout(:one) }
+    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
     end
   end
 
   describe '#limit' do
-    let(:limiter) { described_class.new(:key, 2) }
+    let(:limiter) { described_class.new(:key, 2, timeout: 30) }
 
     it 'works' do
       expect {|b| limiter.limit(&b) }.to yield_control
@@ -85,80 +77,190 @@ 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
-  end
 
-  context 'with same key, different limiters' do
-    let(:limiter_one) { described_class.new(:key, 1) }
-    let(:limiter_two) { described_class.new(:key, 1) }
+    context 'when capacity is a Float' do
+      let(:limiter) { described_class.new(:key, 1.5) }
 
-    it { expect(limiter_one.key).to eq limiter_two.key }
+      it 'still works' do
+        lock = limiter.limit
 
-    it 'works as expected' do
-      expect(limiter_one.limit).to be_a Berater::Lock
+        # since fractional cost is not supported
+        expect(lock.capacity).to be 1
+        expect(limiter).to be_overloaded
+      end
+    end
 
-      expect(limiter_one).to be_incapacitated
-      expect(limiter_two).to be_incapacitated
+    it 'limit resets over time' do
+      2.times { limiter.limit }
+      expect(limiter).to be_overloaded
+
+      Timecop.freeze(30)
+
+      2.times { limiter.limit }
+      expect(limiter).to be_overloaded
     end
-  end
 
-  context 'with same key, different capacities' do
-    let(:limiter_one) { described_class.new(:key, 1) }
-    let(:limiter_two) { described_class.new(:key, 2) }
+    it 'limit resets with millisecond precision' do
+      2.times { limiter.limit }
+      expect(limiter).to be_overloaded
+
+      # travel forward to just before first lock times out
+      Timecop.freeze(29.999)
+      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_overloaded
+    end
+
+    it 'accepts a dynamic capacity' do
+      expect { limiter.limit(capacity: 0) }.to be_overloaded
+      5.times { limiter.limit(capacity: 10) }
+      expect { limiter }.to be_overloaded
+    end
+
+    context 'with cost parameter' do
+      it { expect { limiter.limit(cost: 4) }.to be_overloaded }
+
+      it 'works within limit' do
+        limiter.limit(cost: 2)
+        expect(limiter).to be_overloaded
+      end
+
+      it 'releases full cost' do
+        lock = limiter.limit(cost: 2)
+        expect(limiter).to be_overloaded
+
+        lock.release
+        expect(limiter).not_to be_overloaded
+
+        lock = limiter.limit(cost: 2)
+        expect(limiter).to be_overloaded
+      end
+
+      it 'respects timeout' do
+        limiter.limit(cost: 2)
+        expect(limiter).to be_overloaded
 
-    it { expect(limiter_one.capacity).not_to eq limiter_two.capacity }
+        Timecop.freeze(30)
+        expect(limiter).not_to be_overloaded
 
-    it 'works as expected' do
-      one_lock = limiter_one.limit
-      expect(one_lock).to be_a Berater::Lock
+        limiter.limit(cost: 2)
+        expect(limiter).to be_overloaded
+      end
 
-      expect(limiter_one).to be_incapacitated
-      expect(limiter_two).not_to be_incapacitated
+      context 'with fractional costs' do
+        it 'rounds up' do
+          limiter.limit(cost: 1.5)
+          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_overloaded
+        end
+      end
 
-      two_lock = limiter_two.limit
-      expect(two_lock).to be_a Berater::Lock
+      it 'only allows positive values' do
+        expect { limiter.limit(cost: -1) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with same key, different limiters' do
+      let(:limiter_one) { described_class.new(:key, 1) }
+      let(:limiter_two) { described_class.new(:key, 1) }
 
-      expect(limiter_one).to be_incapacitated
-      expect(limiter_two).to be_incapacitated
+      it { expect(limiter_one.key).to eq limiter_two.key }
 
-      one_lock.release
-      expect(limiter_one).to be_incapacitated
-      expect(limiter_two).not_to be_incapacitated
+      it 'works as expected' do
+        expect(limiter_one.limit).to be_a Berater::Lock
 
-      two_lock.release
-      expect(limiter_one).not_to be_incapacitated
-      expect(limiter_two).not_to be_incapacitated
+        expect(limiter_one).to be_overloaded
+        expect(limiter_two).to be_overloaded
+      end
+    end
+
+    context 'with same key, different capacities' do
+      let(:limiter_one) { described_class.new(:key, 1) }
+      let(:limiter_two) { described_class.new(:key, 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::Lock
+
+        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_overloaded
+        expect(limiter_two).to be_overloaded
+
+        one_lock.release
+        expect(limiter_one).to be_overloaded
+        expect(limiter_two).not_to be_overloaded
+
+        two_lock.release
+        expect(limiter_one).not_to be_overloaded
+        expect(limiter_two).not_to be_overloaded
+      end
+    end
+
+    context 'with different keys, different limiters' do
+      let(:limiter_one) { described_class.new(:one, 1) }
+      let(:limiter_two) { described_class.new(:two, 1) }
+
+      it 'works as expected' do
+        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_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_overloaded
+        expect(limiter_two).to be_overloaded
+      end
     end
   end
 
-  context 'with different keys, different limiters' do
-    let(:limiter_one) { described_class.new(:one, 1) }
-    let(:limiter_two) { described_class.new(:two, 1) }
+  describe '#utilization' do
+    let(:limiter) { described_class.new(:key, 10, timeout: 30) }
+
+    it 'works' do
+      expect(limiter.utilization).to be 0.0
 
-    it 'works as expected' do
-      expect(limiter_one).not_to be_incapacitated
-      expect(limiter_two).not_to be_incapacitated
+      2.times { limiter.limit }
+      expect(limiter.utilization).to be 0.2
 
-      one_lock = limiter_one.limit
-      expect(one_lock).to be_a Berater::Lock
+      Timecop.freeze(15)
 
-      expect(limiter_one).to be_incapacitated
-      expect(limiter_two).not_to be_incapacitated
+      8.times { limiter.limit }
+      expect(limiter.utilization).to be 1.0
 
-      two_lock = limiter_two.limit
-      expect(two_lock).to be_a Berater::Lock
+      Timecop.freeze(15)
 
-      expect(limiter_one).to be_incapacitated
-      expect(limiter_two).to be_incapacitated
+      expect(limiter.utilization).to be 0.8
     end
   end