berater 0.1.0 → 0.2.0

data/lib/berater/version.rb

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

data/spec/berater_spec.rb

@@ -9,10 +9,10 @@ describe Berater do
   describe '.configure' do
     it 'can be set via configure' do
       Berater.configure do |c|
-        c.mode = :rate
+        c.redis = :redis
       end
 
-      expect(Berater.mode).to eq :rate
+      expect(Berater.redis).to eq :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, :unlimited) }
 
       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,22 @@ 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, :unlimited, 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 }
+      it 'works with convinience' do
+        expect(Berater).to receive(:new).and_return(limiter)
+        expect {|b| Berater(:key, :unlimited, &b) }.to yield_control
       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, :inhibited) }
 
       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 +63,22 @@ 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, :inhibited, redis: redis)
         expect(limiter.redis).to be redis
       end
-    end
 
-    describe '.limit' do
-      it 'always limits' do
-        expect { Berater.limit }.to be_inhibited
+      it 'works with convinience' do
+        expect(Berater).to receive(:new).and_return(limiter)
+        expect { Berater(:key, :inhibited) }.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, :rate, 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 +87,22 @@ 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, :rate, 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
+      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
-  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, :concurrency, 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,33 +111,13 @@ 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, :concurrency, 1, redis: redis)
         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
+      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

data/spec/concurrency_limiter_spec.rb

@@ -1,22 +1,20 @@
 describe Berater::ConcurrencyLimiter do
-  before { Berater.mode = :concurrency }
-
   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
 
@@ -27,7 +25,7 @@ describe Berater::ConcurrencyLimiter do
     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
 
@@ -40,7 +38,7 @@ describe Berater::ConcurrencyLimiter do
 
   describe '#timeout' do
     def expect_timeout(timeout)
-      limiter = described_class.new(1, timeout: timeout)
+      limiter = described_class.new(:key, 1, timeout: timeout)
       expect(limiter.timeout).to eq timeout
     end
 
@@ -51,7 +49,7 @@ describe Berater::ConcurrencyLimiter do
     context 'with erroneous values' do
       def expect_bad_timeout(timeout)
         expect do
-          described_class.new(1, timeout: timeout)
+          described_class.new(:key, 1, timeout: timeout)
         end.to raise_error ArgumentError
       end
 
@@ -63,126 +61,113 @@ describe Berater::ConcurrencyLimiter do
   end
 
   describe '#limit' do
-    let(:limiter) { described_class.new(2, timeout: 1) }
+    let(:limiter) { described_class.new(:key, 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
+    it 'works many times if workers release locks' do
       30.times do
         expect {|b| limiter.limit(&b) }.to yield_control
       end
+
+      30.times do
+        lock = limiter.limit
+        lock.release
+      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.limit).to be_a Berater::Lock
+      expect(limiter.limit).to be_a Berater::Lock
 
-      expect { limiter }.to be_incapacitated
+      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
+      expect(limiter.limit).to be_a Berater::Lock
+      expect(limiter.limit).to be_a Berater::Lock
+      expect(limiter).to be_incapacitated
 
-      sleep(1)
+      Timecop.travel(1)
 
-      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
-      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
-      expect { limiter }.to be_incapacitated
+      expect(limiter.limit).to be_a Berater::Lock
+      expect(limiter.limit).to be_a Berater::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
+    context 'with capacity 0' do
+      let(:limiter) { described_class.new(:key, 0) }
 
-      expect { limiter_one }.to be_incapacitated
-      expect { limiter_two }.to be_incapacitated
+      it 'always fails' do
+        expect(limiter).to be_incapacitated
+      end
     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
+  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
 
   context 'with same key, different capacities' do
-    let(:limiter_one) { described_class.new(1) }
-    let(:limiter_two) { described_class.new(2) }
+    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::ConcurrencyLimiter::Lock
+      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
+      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
+      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
+      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) }
+    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
+      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(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
+      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
     end
   end
 

data/spec/concurrency_lock_spec.rb

@@ -1,34 +1,39 @@
-describe Berater::ConcurrencyLimiter::Lock do
-  subject { Berater.limit(1, timeout: 1) }
+describe Berater::Lock do
+  it_behaves_like 'a lock', Berater.new(:key, :concurrency, 3)
 
-  before { Berater.mode = :concurrency }
+  let(:limiter) { Berater.new(:key, :concurrency, 3) }
 
-  it { expect(subject.released?).to be false }
-  it { expect(subject.expired?).to be false }
+  describe '#expired?' do
+    let!(:lock) { limiter.limit }
 
-  context 'after being released' do
-    before { subject.release }
+    context 'when timeout is not set' do
+      it { expect(limiter.timeout).to eq 0 }
 
-    it { expect(subject.released?).to be true }
-    it { expect(subject.expired?).to be false }
+      it 'never expires' do
+        expect(lock.locked?).to be true
+        expect(lock.expired?).to be false
 
-    it 'can not be released again' do
-      expect { subject.release }.to raise_error(RuntimeError, /already/)
+        Timecop.travel(1_000)
+
+        expect(lock.locked?).to be true
+        expect(lock.expired?).to be false
+      end
     end
-  end
 
-  context 'when enough time passes' do
-    before { subject; Timecop.freeze(2) }
+    context 'when timeout is set and exceeded' do
+      before { Timecop.travel(1) }
 
-    it 'expires' do
-      expect(subject.expired?).to be true
-    end
+      let(:limiter) { Berater.new(:key, :concurrency, 3, timeout: 1) }
 
-    it 'fails to release' do
-      expect { subject.release }.to raise_error(RuntimeError, /expired/)
-    end
+      it 'expires' do
+        expect(lock.expired?).to be true
+        expect(lock.locked?).to be false
+      end
 
-    it { expect(subject.released?).to be false }
+      it 'fails to release' do
+        expect { lock.release }.to raise_error(RuntimeError, /expired/)
+      end
+    end
   end
 
 end