berater 0.6.2 → 0.7.0

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) }
@@ -77,14 +77,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 +96,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 +187,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 +202,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 +226,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
 

data/spec/dsl_refinement_spec.rb

@@ -3,18 +3,6 @@ require 'berater/dsl'
 describe Berater do
   using Berater::DSL
 
-  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

data/spec/dsl_spec.rb

@@ -13,13 +13,13 @@ describe Berater::DSL do
     end
 
     it 'parses' do
-      check([ 1, :second ]) { 1.per second }
-      check([ 3, :minute ]) { 3.per minute }
-      check([ 5, :hour ]) { 5.every hour }
+      check([ 1, interval: :second ]) { 1.per second }
+      check([ 3, interval: :minute ]) { 3.per minute }
+      check([ 5, interval: :hour ]) { 5.every hour }
     end
 
     it 'cleans up afterward' do
-      check([ 1, :second ]) { 1.per second }
+      check([ 1, interval: :second ]) { 1.per second }
 
       expect(Integer).not_to respond_to(:per)
       expect(Integer).not_to respond_to(:every)
@@ -29,7 +29,7 @@ describe Berater::DSL do
       count = 1
       interval = :second
 
-      check([ count, interval ]) { count.per interval }
+      check([ count, interval: interval ]) { count.per interval }
     end
   end
 
@@ -57,16 +57,4 @@ describe Berater::DSL do
     end
   end
 
-  context 'unlimited mode' do
-    it 'has keywords' do
-      check(:unlimited) { unlimited }
-    end
-  end
-
-  context 'inhibited mode' do
-    it 'has keywords' do
-      check(:inhibited) { inhibited }
-    end
-  end
-
 end

data/spec/limiter_spec.rb

@@ -8,7 +8,7 @@ describe Berater::Limiter do
 
     it do
       expect { limiter.limit }.to raise_error(NotImplementedError)
-      expect { limiter.overloaded? }.to raise_error(NotImplementedError)
+      expect { limiter.utilization }.to raise_error(NotImplementedError)
     end
   end
 

data/spec/matchers_spec.rb

@@ -1,118 +1,80 @@
 describe Berater::Matchers::Overloaded do
 
   context 'Berater::Unlimiter' do
-    let(:limiter) { Berater.new(:key, :unlimited) }
+    let(:limiter) { Berater::Unlimiter.new }
 
     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(:key, :inhibited) }
+    let(:limiter) { Berater::Inhibitor.new }
 
     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(:key, 1, :second) }
+    let(:limiter) { Berater::RateLimiter.new(:key, 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
+      it 'should be_overloaded' do
+        expect(limiter).to be_overloaded
       end
 
-      it 'should be_overrated' do
-        expect { limiter }.to be_overrated
+      it 'should be_overloaded' do
+        expect { limiter }.to be_overloaded
       end
 
-      it 'should be_overrated' do
-        expect { limiter.limit }.to be_overrated
+      it 'should be_overloaded' do
+        expect { limiter.limit }.to be_overloaded
       end
     end
   end
 
   context 'Berater::ConcurrencyLimiter' do
-    let(:limiter) { Berater.new(:key, 1) }
+    let(:limiter) { Berater::ConcurrencyLimiter.new(:key, 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
+      it 'should be_overloaded' do
         3.times do
-          expect(limiter).not_to be_incapacitated
+          expect(limiter).not_to be_overloaded
         end
       end
 
-      it 'should be_incapacitated' do
+      it 'should be_overloaded' do
         3.times do
-          expect { limiter }.not_to be_incapacitated
+          expect { limiter }.not_to be_overloaded
         end
       end
 
-      it 'should be_incapacitated' do
+      it 'should be_overloaded' do
         3.times do
-          expect { limiter.limit {} }.not_to be_incapacitated
+          expect { limiter.limit {} }.not_to be_overloaded
         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
+      it 'should be_overloaded' do
+        expect { limiter.limit }.not_to be_overloaded
+        expect { limiter.limit }.to be_overloaded
       end
 
-      it 'should be_incapacitated' do
-        expect { 3.times { limiter.limit } }.to be_incapacitated
+      it 'should be_overloaded' do
+        expect { 3.times { limiter.limit } }.to be_overloaded
       end
     end
   end
@@ -156,31 +118,5 @@ describe Berater::Matchers::Overloaded do
         expect { raise Berater::Overloaded }.not_to be_overloaded
       }.to fail_including("did not expect #{Berater::Overloaded} to be raised")
     end
-
-    it 'supports different verbs' do
-      expect {
-        expect { unlimiter }.to be_overrated
-      }.to fail_including('expected to be overrated')
-
-      expect {
-        expect { unlimiter }.to be_incapacitated
-      }.to fail_including('expected to be incapacitated')
-    end
-
-    it 'supports different exceptions' do
-      expect {
-        expect { 123 }.to be_overrated
-      }.to fail_including(
-        "expected #{Berater::RateLimiter::Overrated} to be raised"
-      )
-
-      expect {
-        expect {
-          raise Berater::ConcurrencyLimiter::Incapacitated
-        }.not_to be_incapacitated
-      }.to fail_including(
-        "did not expect #{Berater::ConcurrencyLimiter::Incapacitated} to be raised"
-      )
-    end
   end
 end