berater 0.2.0 → 0.6.1

data/spec/concurrency_limiter_spec.rb

@@ -1,4 +1,7 @@
 describe Berater::ConcurrencyLimiter do
+  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(:key, 1) }
 
@@ -20,6 +23,7 @@ describe Berater::ConcurrencyLimiter do
 
     it { expect_capacity(0) }
     it { expect_capacity(1) }
+    it { expect_capacity(1.5) }
     it { expect_capacity(10_000) }
 
     context 'with erroneous values' do
@@ -29,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) }
@@ -37,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, timeout: 1) }
+    let(:limiter) { described_class.new(:key, 2, timeout: 30) }
 
     it 'works' do
       expect {|b| limiter.limit(&b) }.to yield_control
@@ -85,89 +80,200 @@ describe Berater::ConcurrencyLimiter do
       expect(limiter).to be_incapacitated
     end
 
-    it 'times out locks' do
-      expect(limiter.limit).to be_a Berater::Lock
-      expect(limiter.limit).to be_a Berater::Lock
+    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.travel(1)
+      Timecop.freeze(30)
 
-      expect(limiter.limit).to be_a Berater::Lock
-      expect(limiter.limit).to be_a Berater::Lock
+      2.times { limiter.limit }
       expect(limiter).to be_incapacitated
     end
 
-    context 'with capacity 0' do
-      let(:limiter) { described_class.new(:key, 0) }
+    it 'limit resets with millisecond precision' do
+      2.times { limiter.limit }
+      expect(limiter).to be_incapacitated
 
-      it 'always fails' do
+      # travel forward to just before first lock times out
+      Timecop.freeze(29.999)
+      expect(limiter).to be_incapacitated
+
+      # traveling one more millisecond will decrement the count
+      Timecop.freeze(0.001)
+      2.times { limiter.limit }
+      expect(limiter).to be_incapacitated
+    end
+
+    it 'accepts a dynamic capacity' do
+      expect { limiter.limit(capacity: 0) }.to be_incapacitated
+      5.times { limiter.limit(capacity: 10) }
+      expect { limiter }.to be_incapacitated
+    end
+
+    context 'with cost parameter' do
+      it { expect { limiter.limit(cost: 4) }.to be_incapacitated }
+
+      it 'works within limit' do
+        limiter.limit(cost: 2)
+        expect(limiter).to be_incapacitated
+      end
+
+      it 'releases full cost' do
+        lock = limiter.limit(cost: 2)
+        expect(limiter).to be_incapacitated
+
+        lock.release
+        expect(limiter).not_to be_incapacitated
+
+        lock = limiter.limit(cost: 2)
         expect(limiter).to be_incapacitated
       end
+
+      it 'respects timeout' do
+        limiter.limit(cost: 2)
+        expect(limiter).to be_incapacitated
+
+        Timecop.freeze(30)
+        expect(limiter).not_to be_incapacitated
+
+        limiter.limit(cost: 2)
+        expect(limiter).to be_incapacitated
+      end
+
+      context 'with fractional costs' do
+        it 'rounds up' do
+          limiter.limit(cost: 1.5)
+          expect(limiter).to be_incapacitated
+        end
+
+        it 'accumulates correctly' do
+          limiter.limit(cost: 0.5) # => 1
+          limiter.limit(cost: 0.7) # => 2
+          expect(limiter).to be_incapacitated
+        end
+      end
+
+      it 'only allows positive values' do
+        expect { limiter.limit(cost: -1) }.to raise_error(ArgumentError)
+      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 'with same key, different limiters' do
+      let(:limiter_one) { described_class.new(:key, 1) }
+      let(:limiter_two) { described_class.new(:key, 1) }
 
-    it { expect(limiter_one.key).to eq limiter_two.key }
+      it { expect(limiter_one.key).to eq limiter_two.key }
 
-    it 'works as expected' do
-      expect(limiter_one.limit).to be_a Berater::Lock
+      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_incapacitated
+        expect(limiter_two).to be_incapacitated
+      end
     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) }
+    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::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::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(:one, 1) }
-    let(:limiter_two) { described_class.new(:two, 1) }
+    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::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::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
 

data/spec/dsl_refinement_spec.rb

@@ -0,0 +1,46 @@
+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
+    expect(limiter.key).to be :key
+    expect(limiter.capacity).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
+  end
+
+  it 'does not accept args and dsl block' do
+    expect {
+      Berater.new(:key, 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)
+  end
+
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,72 @@
+require 'berater/dsl'
+
+describe Berater::DSL do
+  def check(expected, &block)
+    expect(Berater::DSL.eval(&block)).to eq expected
+  end
+
+  context 'rate mode' do
+    it 'has keywords' do
+      check(:second) { second }
+      check(:minute) { minute }
+      check(:hour) { hour }
+    end
+
+    it 'parses' do
+      check([ 1, :second ]) { 1.per second }
+      check([ 3, :minute ]) { 3.per minute }
+      check([ 5, :hour ]) { 5.every hour }
+    end
+
+    it 'cleans up afterward' do
+      check([ 1, :second ]) { 1.per second }
+
+      expect(Integer).not_to respond_to(:per)
+      expect(Integer).not_to respond_to(:every)
+    end
+
+    it 'works with variables' do
+      count = 1
+      interval = :second
+
+      check([ count, interval ]) { count.per interval }
+    end
+  end
+
+  context 'concurrency mode' do
+    it 'parses' do
+      check([ 1 ]) { 1.at_once }
+      check([ 3 ]) { 3.at_a_time }
+      check([ 5 ]) { 5.concurrently }
+    end
+
+    it 'cleans up afterward' do
+      check([ 1 ]) { 1.at_once }
+
+      expect(Integer).not_to respond_to(:at_once)
+      expect(Integer).not_to respond_to(:at_a_time)
+      expect(Integer).not_to respond_to(:concurrently)
+    end
+
+    it 'works with constants' do
+      class Foo
+        CAPACITY = 3
+      end
+
+      check([ Foo::CAPACITY ]) { Foo::CAPACITY.at_once }
+    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

@@ -15,11 +15,9 @@ describe Berater::Inhibitor do
   end
 
   describe '#limit' do
-    let(:limiter) { described_class.new }
+    subject { described_class.new }
 
-    it 'always limits' do
-      expect { limiter.limit }.to be_inhibited
-    end
+    it_behaves_like 'it is overloaded'
   end
 
 end