berater 0.6.0 → 0.8.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) }
@@ -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,75 +102,85 @@ 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_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_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
 
-      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
+      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
 
-      it 'only allows positive, Integer values' do
+      it 'only allows positive values' do
         expect { limiter.limit(cost: -1) }.to raise_error(ArgumentError)
-        expect { limiter.limit(cost: 1.5) }.to raise_error(ArgumentError)
       end
     end
 
@@ -177,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
 
@@ -192,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
 
@@ -216,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
 

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/inhibitor_spec.rb

@@ -1,7 +1,9 @@
 describe Berater::Inhibitor do
+  subject { described_class.new }
+
   describe '.new' do
     it 'initializes without any arguments or options' do
-      expect(described_class.new).to be_a described_class
+      is_expected.to be_a described_class
     end
 
     it 'initializes with any arguments and options' do
@@ -9,15 +11,18 @@ describe Berater::Inhibitor do
     end
 
     it 'has default values' do
-      expect(described_class.new.key).to be :inhibitor
-      expect(described_class.new.redis).to be Berater.redis
+      expect(subject.key).to be :inhibitor
+      expect(subject.redis).to be Berater.redis
     end
   end
 
   describe '#limit' do
-    subject { described_class.new }
-
     it_behaves_like 'it is overloaded'
   end
 
+  describe '#to_s' do
+    it do
+      expect(subject.to_s).to include described_class.to_s
+    end
+  end
 end

data/spec/limiter_spec.rb

@@ -1,6 +1,6 @@
 describe Berater::Limiter do
   it 'can not be initialized' do
-    expect { described_class.new }.to raise_error(NotImplementedError)
+    expect { described_class.new }.to raise_error(NoMethodError)
   end
 
   describe 'abstract methods' do
@@ -8,11 +8,51 @@ 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
 
-  describe '==' do
+  describe '#limit' do
+    subject { Berater::Unlimiter.new }
+
+    context 'with a capacity parameter' do
+      it 'overrides the stored value' do
+        is_expected.to receive(:acquire_lock).with(3, anything)
+
+        subject.limit(capacity: 3)
+      end
+
+      it 'validates the type' do
+        expect {
+          subject.limit(capacity: 'abc')
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with a cost parameter' do
+      it 'overrides the stored value' do
+        is_expected.to receive(:acquire_lock).with(anything, 2)
+
+        subject.limit(cost: 2)
+      end
+
+      it 'validates' do
+        expect {
+          subject.limit(cost: 'abc')
+        }.to raise_error(ArgumentError)
+
+        expect {
+          subject.limit(cost: -1)
+        }.to raise_error(ArgumentError)
+
+        expect {
+          subject.limit(cost: Float::INFINITY)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#==' do
     let(:limiter)  { Berater::RateLimiter.new(:key, 1, :second) }
 
     it 'equals itself' do
@@ -25,12 +65,6 @@ describe Berater::Limiter do
       )
     end
 
-    it 'equals something with equvalent initialization parameters' do
-      expect(limiter).to eq(
-        Berater::RateLimiter.new(:key, 1, 1)
-      )
-    end
-
     it 'does not equal something different' do
       expect(limiter).not_to eq(
         Berater::RateLimiter.new(:key, 2, :second)
@@ -68,4 +102,56 @@ describe Berater::Limiter do
     end
   end
 
+  describe '#cache_key' do
+    subject { klass.new(:key).send(:cache_key) }
+
+    context 'with Unlimiter' do
+      let(:klass) { Berater::Unlimiter }
+
+      it do
+        is_expected.to eq 'Berater:Unlimiter:key'
+      end
+    end
+
+    context 'with custom limiter' do
+      MyLimiter = Class.new(Berater::Unlimiter)
+
+      let(:klass) { MyLimiter }
+
+      it 'adds Berater prefix' do
+        is_expected.to eq 'Berater:MyLimiter:key'
+      end
+    end
+  end
+
+  describe '.cache_key' do
+    subject { klass.send(:cache_key, :key) }
+
+    context 'with Unlimiter' do
+      let(:klass) { Berater::Unlimiter }
+
+      it do
+        is_expected.to eq 'Berater:Unlimiter:key'
+      end
+    end
+
+    context 'with custom limiter' do
+      MyLimiter = Class.new(Berater::Unlimiter)
+
+      let(:klass) { MyLimiter }
+
+      it 'adds Berater prefix' do
+        is_expected.to eq 'Berater:MyLimiter:key'
+      end
+    end
+  end
+
+  describe '.inherited' do
+    it 'creates convenience methods' do
+      expect(Berater.method(:Unlimiter)).to be_a Method
+      expect(Berater::Unlimiter()).to be_a Berater::Unlimiter
+      expect {|b| Berater::Unlimiter(&b) }.to yield_control
+    end
+  end
+
 end