berater 0.1.4 → 0.6.0

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = '0.1.4'
+  VERSION = '0.6.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.mode = :rate
+        c.redis = :redis
       end
 
-      expect(Berater.mode).to eq :rate
+      expect(Berater.redis).to be :redis
     end
   end
 
@@ -24,20 +24,13 @@ describe Berater do
     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) }
+  describe '.new' do
+    context 'unlimited mode' do
+      let(:limiter) { Berater.new(:key, Float::INFINITY) }
 
       it 'instantiates an Unlimiter' do
         expect(limiter).to be_a Berater::Unlimiter
+        expect(limiter.key).to be :key
       end
 
       it 'inherits redis' do
@@ -46,35 +39,17 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:unlimited, key: 'key', redis: redis)
-        expect(limiter.key).to match(/key/)
+        limiter = Berater.new(:key, Float::INFINITY, redis: redis)
         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) }
+    context 'inhibited mode' do
+      let(:limiter) { Berater.new(:key, 0) }
 
       it 'instantiates an Inhibitor' do
         expect(limiter).to be_a Berater::Inhibitor
+        expect(limiter.key).to be :key
       end
 
       it 'inherits redis' do
@@ -83,27 +58,17 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:inhibited, key: 'key', redis: redis)
-        expect(limiter.key).to match(/key/)
+        limiter = Berater.new(:key, 0, redis: redis)
         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) }
+    context 'rate mode' do
+      let(:limiter) { Berater.new(:key, 1, :second) }
 
       it 'instantiates a RateLimiter' do
         expect(limiter).to be_a Berater::RateLimiter
+        expect(limiter.key).to be :key
       end
 
       it 'inherits redis' do
@@ -112,44 +77,17 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:rate, 1, :second, key: 'key', redis: redis)
-        expect(limiter.key).to match(/key/)
+        limiter = Berater.new(:key, 1, :second, redis: redis)
         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) }
+    context 'concurrency mode' do
+      let(:limiter) { Berater.new(:key, 1) }
 
       it 'instantiates a ConcurrencyLimiter' do
         expect(limiter).to be_a Berater::ConcurrencyLimiter
+        expect(limiter.key).to be :key
       end
 
       it 'inherits redis' do
@@ -158,35 +96,39 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:concurrency, 1, key: 'key', redis: redis)
-        expect(limiter.key).to match(/key/)
+        limiter = Berater.new(:key, 1, redis: redis)
         expect(limiter.redis).to be redis
       end
     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
+  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
 
-      it 'accepts options' do
-        redis = double('Redis')
-        expect(redis).to receive(:eval)
+      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
 
-        Berater.limit(1, redis: redis) rescue nil
+          begin
+            res = Berater(:key, *args) { 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, :second
+    include_examples 'test convenience', Berater::ConcurrencyLimiter, 1
   end
 
 end

data/spec/concurrency_limiter_spec.rb

@@ -1,37 +1,38 @@
 describe Berater::ConcurrencyLimiter do
-  before { Berater.mode = :concurrency }
+  it_behaves_like 'a limiter', described_class.new(:key, 1)
+  it_behaves_like 'a limiter', described_class.new(:key, 1, timeout: 1)
 
   describe '.new' do
-    let(:limiter) { described_class.new(1) }
+    let(:limiter) { described_class.new(:key, 1) }
 
     it 'initializes' do
+      expect(limiter.key).to be :key
       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)
+      limiter = described_class.new(:key, capacity)
       expect(limiter.capacity).to eq capacity
     end
 
     it { expect_capacity(0) }
     it { expect_capacity(1) }
+    it { expect_capacity(1.5) }
     it { expect_capacity(10_000) }
 
     context 'with erroneous values' do
       def expect_bad_capacity(capacity)
         expect do
-          described_class.new(capacity)
+          described_class.new(:key, 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) }
@@ -39,31 +40,23 @@ describe Berater::ConcurrencyLimiter do
   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) }
+    # see spec/utils_spec.rb
 
-    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 '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(2, timeout: 1) }
+    let(:limiter) { described_class.new(:key, 2, timeout: 30) }
 
     it 'works' do
       expect {|b| limiter.limit(&b) }.to yield_control
@@ -81,121 +74,196 @@ describe Berater::ConcurrencyLimiter do
     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.limit).to be_a Berater::Lock
+      expect(limiter.limit).to be_a Berater::Lock
+
+      expect(limiter).to be_incapacitated
+    end
+
+    context 'with capacity 0' do
+      let(:limiter) { described_class.new(:key, 0) }
+
+      it 'always fails' do
+        expect(limiter).to be_incapacitated
+      end
+    end
+
+    context 'when capacity is a Float' do
+      let(:limiter) { described_class.new(:key, 1.5) }
+
+      it 'still works' do
+        lock = limiter.limit
+
+        # since fractional cost is not supported
+        expect(lock.capacity).to be 1
+        expect(limiter).to be_incapacitated
+      end
+    end
 
+    it 'limit resets over time' do
+      2.times { limiter.limit }
+      expect(limiter).to be_incapacitated
+
+      Timecop.freeze(30)
+
+      2.times { limiter.limit }
       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
+    it 'limit resets with millisecond precision' do
+      2.times { limiter.limit }
       expect(limiter).to be_incapacitated
 
-      Timecop.travel(1)
+      # travel forward to just before first lock times out
+      Timecop.freeze(29.999)
+      expect(limiter).to be_incapacitated
 
-      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
-      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      # traveling one more millisecond will decrement the count
+      Timecop.freeze(0.001)
+      2.times { limiter.limit }
       expect(limiter).to be_incapacitated
     end
 
-    context 'with capacity 0' do
-      let(:limiter) { described_class.new(0) }
+    context 'with cost parameter' do
+      it { expect { limiter.limit(cost: 4) }.to be_incapacitated }
 
-      it 'always fails' do
+      it 'works within limit' do
+        limiter.limit(cost: 2)
         expect(limiter).to be_incapacitated
       end
-    end
-  end
 
-  context 'with same key, different limiters' do
-    let(:limiter_one) { described_class.new(1) }
-    let(:limiter_two) { described_class.new(1) }
+      it 'releases full cost' do
+        lock = limiter.limit(cost: 2)
+        expect(limiter).to be_incapacitated
+
+        lock.release
+        expect(limiter).not_to be_incapacitated
 
-    it { expect(limiter_one.key).to eq limiter_two.key }
+        lock = limiter.limit(cost: 2)
+        expect(limiter).to be_incapacitated
+      end
 
-    it 'works as expected' do
-      expect(limiter_one.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      it 'respects timeout' do
+        limiter.limit(cost: 2)
+        expect(limiter).to be_incapacitated
 
-      expect(limiter_one).to be_incapacitated
-      expect(limiter_two).to be_incapacitated
-    end
-  end
+        Timecop.freeze(30)
+        expect(limiter).not_to be_incapacitated
 
-  context 'with different keys, same limiter' do
-    let(:limiter) { described_class.new(1) }
+        limiter.limit(cost: 2)
+        expect(limiter).to be_incapacitated
+      end
 
-    it 'works as expected' do
-      one_lock = limiter.limit(key: :one)
-      expect(one_lock).to be_a Berater::ConcurrencyLimiter::Lock
+      it 'accepts a dynamic capacity' do
+        limiter = described_class.new(:key, 1)
+
+        expect { limiter.limit(capacity: 0) }.to be_incapacitated
+        5.times { limiter.limit(capacity: 10) }
+        expect { limiter }.to be_incapacitated
+      end
 
-      expect { limiter.limit(key: :one) {} }.to be_incapacitated
-      expect { limiter.limit(key: :two) {} }.not_to be_incapacitated
+      it 'only allows positive, Integer values' do
+        expect { limiter.limit(cost: -1) }.to raise_error(ArgumentError)
+        expect { limiter.limit(cost: 1.5) }.to raise_error(ArgumentError)
+      end
+    end
 
-      two_lock = limiter.limit(key: :two)
-      expect(two_lock).to be_a Berater::ConcurrencyLimiter::Lock
+    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.limit(key: :one) {} }.to be_incapacitated
-      expect { limiter.limit(key: :two) {} }.to be_incapacitated
+      it { expect(limiter_one.key).to eq limiter_two.key }
 
-      one_lock.release
-      expect { limiter.limit(key: :one) {} }.not_to be_incapacitated
-      expect { limiter.limit(key: :two) {} }.to be_incapacitated
+      it 'works as expected' do
+        expect(limiter_one.limit).to be_a Berater::Lock
 
-      two_lock.release
-      expect { limiter.limit(key: :one) {} }.not_to be_incapacitated
-      expect { limiter.limit(key: :two) {} }.not_to be_incapacitated
+        expect(limiter_one).to be_incapacitated
+        expect(limiter_two).to be_incapacitated
+      end
     end
-  end
 
-  context 'with same key, different capacities' do
-    let(:limiter_one) { described_class.new(1) }
-    let(:limiter_two) { described_class.new(2) }
+    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 { 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
+      it 'works as expected' 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_incapacitated
+        expect(limiter_two).not_to be_incapacitated
 
-      two_lock = limiter_two.limit
-      expect(two_lock).to be_a Berater::ConcurrencyLimiter::Lock
+        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_incapacitated
+        expect(limiter_two).to be_incapacitated
 
-      one_lock.release
-      expect(limiter_one).to be_incapacitated
-      expect(limiter_two).not_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
+        two_lock.release
+        expect(limiter_one).not_to be_incapacitated
+        expect(limiter_two).not_to be_incapacitated
+      end
     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) }
+    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_incapacitated
+        expect(limiter_two).not_to be_incapacitated
+
+        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
+
+        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
+      end
+    end
+  end
 
-    it 'works as expected' do
-      expect(limiter_one).not_to be_incapacitated
-      expect(limiter_two).not_to be_incapacitated
+  describe '#overloaded?' do
+    let(:limiter) { described_class.new(:key, 1, timeout: 30) }
 
-      one_lock = limiter_one.limit
-      expect(one_lock).to be_a Berater::ConcurrencyLimiter::Lock
+    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_one).to be_incapacitated
-      expect(limiter_two).not_to be_incapacitated
+    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
+    end
+  end
 
-      two_lock = limiter_two.limit
-      expect(two_lock).to be_a Berater::ConcurrencyLimiter::Lock
+  describe '#to_s' do
+    def check(capacity, expected)
+      expect(
+        described_class.new(:key, capacity).to_s
+      ).to match(expected)
+    end
 
-      expect(limiter_one).to be_incapacitated
-      expect(limiter_two).to be_incapacitated
+    it 'works' do
+      check(1, /1 at a time/)
+      check(3, /3 at a time/)
     end
   end