berater 0.4.0 → 0.5.0

data/spec/matchers_spec.rb

@@ -16,6 +16,12 @@ describe 'be_overloaded' do
     it { expect { limiter.limit }.not_to be_inhibited }
     it { expect { limiter.limit }.not_to be_overrated }
     it { expect { limiter.limit }.not_to be_incapacitated }
+
+    it 'catches false positives' do
+      expect {
+        expect { limiter }.to be_overloaded
+      }.to fail
+    end
   end
 
   context 'Berater::Inhibitor' do
@@ -29,10 +35,16 @@ describe 'be_overloaded' do
 
     it { expect { limiter.limit }.to be_overloaded }
     it { expect { limiter.limit }.to be_inhibited }
+
+    it 'catches false negatives' do
+      expect {
+        expect { limiter }.not_to be_overloaded
+      }.to fail
+    end
   end
 
   context 'Berater::RateLimiter' do
-    let(:limiter) { Berater.new(:key, :rate, 1, :second) }
+    let(:limiter) { Berater.new(:key, 1, :second) }
 
     it { expect(limiter).not_to be_overloaded }
     it { expect(limiter).not_to be_inhibited }
@@ -67,7 +79,7 @@ describe 'be_overloaded' do
   end
 
   context 'Berater::ConcurrencyLimiter' do
-    let(:limiter) { Berater.new(:key, :concurrency, 1) }
+    let(:limiter) { Berater.new(:key, 1) }
 
     it { expect(limiter).not_to be_overloaded }
     it { expect(limiter).not_to be_inhibited }

data/spec/rate_limiter_spec.rb

@@ -1,12 +1,12 @@
 describe Berater::RateLimiter do
-  it_behaves_like 'a limiter', Berater.new(:key, :rate, 3, :second)
+  it_behaves_like 'a limiter', Berater.new(:key, 3, :second)
 
   describe '.new' do
     let(:limiter) { described_class.new(:key, 1, :second) }
 
     it 'initializes' do
       expect(limiter.key).to be :key
-      expect(limiter.count).to eq 1
+      expect(limiter.capacity).to eq 1
       expect(limiter.interval).to eq :second
     end
 
@@ -15,82 +15,38 @@ describe Berater::RateLimiter do
     end
   end
 
-  describe '#count' do
-    def expect_count(count)
-      limiter = described_class.new(:key, count, :second)
-      expect(limiter.count).to eq count
+  describe '#capacity' do
+    def expect_capacity(capacity)
+      limiter = described_class.new(:key, capacity, :second)
+      expect(limiter.capacity).to eq capacity
     end
 
-    it { expect_count(0) }
-    it { expect_count(1) }
-    it { expect_count(100) }
+    it { expect_capacity(0) }
+    it { expect_capacity(1) }
+    it { expect_capacity(100) }
 
     context 'with erroneous values' do
-      def expect_bad_count(count)
+      def expect_bad_capacity(capacity)
         expect do
-          described_class.new(:key, count, :second)
+          described_class.new(:key, capacity, :second)
         end.to raise_error ArgumentError
       end
 
-      it { expect_bad_count(0.5) }
-      it { expect_bad_count(-1) }
-      it { expect_bad_count('1') }
-      it { expect_bad_count(:one) }
+      it { expect_bad_capacity(0.5) }
+      it { expect_bad_capacity(-1) }
+      it { expect_bad_capacity('1') }
+      it { expect_bad_capacity(:one) }
     end
   end
 
   describe '#interval' do
-    def expect_interval(interval, expected)
-      limiter = described_class.new(:key, 1, interval)
-      expect(limiter.interval).to eq expected
-    end
-
-    context 'with ints' do
-      it { expect_interval(0, 0) }
-      it { expect_interval(1, 1) }
-      it { expect_interval(33, 33) }
-    end
-
-    context 'with symbols' do
-      it { expect_interval(:sec, :second) }
-      it { expect_interval(:second, :second) }
-      it { expect_interval(:seconds, :second) }
-
-      it { expect_interval(:min, :minute) }
-      it { expect_interval(:minute, :minute) }
-      it { expect_interval(:minutes, :minute) }
-
-      it { expect_interval(:hour, :hour) }
-      it { expect_interval(:hours, :hour) }
-    end
-
-    context 'with strings' do
-      it { expect_interval('sec', :second) }
-      it { expect_interval('minute', :minute) }
-      it { expect_interval('hours', :hour) }
-    end
-
-    context 'with erroneous values' do
-      def expect_bad_interval(interval)
-        expect do
-          described_class.new(:key, 1, interval)
-        end.to raise_error(ArgumentError)
-      end
-
-      it { expect_bad_interval(-1) }
-      it { expect_bad_interval(:secondz) }
-      it { expect_bad_interval('huor') }
-    end
+    # see spec/utils_spec.rb for more
 
-    context 'interprets values' do
-      def expect_sec(interval, expected)
-        limiter = described_class.new(:key, 1, interval)
-        expect(limiter.instance_variable_get(:@interval_sec)).to eq expected
-      end
+    subject { described_class.new(:key, 1, :second) }
 
-      it { expect_sec(:second, 1) }
-      it { expect_sec(:minute, 60) }
-      it { expect_sec(:hour, 3600) }
+    it 'saves the interval in original and microsecond format' do
+      expect(subject.interval).to be :second
+      expect(subject.instance_variable_get(:@interval_usec)).to be 10**6
     end
   end
 
@@ -112,50 +68,101 @@ describe Berater::RateLimiter do
       expect(limiter).to be_overrated
     end
 
-    it 'limit resets over time' do
+    it 'limit resets over time, with millisecond precision' do
       3.times { limiter.limit }
       expect(limiter).to be_overrated
 
-      # travel forward a second
+      # travel forward to just before the count decrements
+      Timecop.freeze(0.333)
+      expect(limiter).to be_overrated
+
+      # traveling one more millisecond will decrement the count
+      Timecop.freeze(0.001)
+      limiter.limit
+      expect(limiter).to be_overrated
+
+      # traveling 1 second will reset the count
       Timecop.freeze(1)
 
       3.times { limiter.limit }
       expect(limiter).to be_overrated
     end
-  end
 
-  context 'with same key, different limiters' do
-    let(:limiter_one) { described_class.new(:key, 1, :second) }
-    let(:limiter_two) { described_class.new(:key, 1, :second) }
+    it 'accepts a dynamic capacity' do
+      limiter = described_class.new(:key, 1, :second)
 
-    it 'works as expected' do
-      expect(limiter_one.limit).not_to be_overrated
+      expect { limiter.limit(capacity: 0) }.to be_overrated
+      5.times { limiter.limit(capacity: 10) }
+      expect { limiter }.to be_overrated
+    end
+
+    context 'works with cost parameter' do
+      it { expect { limiter.limit(cost: 4) }.to be_overrated }
 
-      expect(limiter_one).to be_overrated
-      expect(limiter_two).to be_overrated
+      it 'works within limit' do
+        limiter.limit(cost: 3)
+        expect { limiter.limit }.to be_overrated
+      end
+
+      it 'resets over time' do
+        limiter.limit(cost: 3)
+        expect(limiter).to be_overrated
+
+        Timecop.freeze(1)
+        expect(limiter).not_to be_overrated
+      end
+
+      it 'can be a Float' do
+        2.times { limiter.limit(cost: 1.5) }
+        expect(limiter).to be_overrated
+      end
     end
-  end
 
-  context 'with different keys, different limiters' do
-    let(:limiter_one) { described_class.new(:one, 1, :second) }
-    let(:limiter_two) { described_class.new(:two, 2, :second) }
+    context 'with same key, different limiters' do
+      let(:limiter_one) { described_class.new(:key, 1, :second) }
+      let(:limiter_two) { described_class.new(:key, 1, :second) }
 
-    it 'works as expected' do
-      expect(limiter_one.limit).not_to be_overrated
-      expect(limiter_two.limit).not_to be_overrated
+      it 'works as expected' do
+        expect(limiter_one.limit).not_to be_overrated
 
-      expect(limiter_one).to be_overrated
-      expect(limiter_two.limit).not_to be_overrated
+        expect(limiter_one).to be_overrated
+        expect(limiter_two).to be_overrated
+      end
+    end
+
+    context 'with different keys, different limiters' do
+      let(:limiter_one) { described_class.new(:one, 1, :second) }
+      let(:limiter_two) { described_class.new(:two, 2, :second) }
 
-      expect(limiter_one).to be_overrated
-      expect(limiter_two).to be_overrated
+      it 'works as expected' do
+        expect(limiter_one.limit).not_to be_overrated
+        expect(limiter_two.limit).not_to be_overrated
+
+        expect(limiter_one).to be_overrated
+        expect(limiter_two.limit).not_to be_overrated
+
+        expect(limiter_one).to be_overrated
+        expect(limiter_two).to be_overrated
+      end
+    end
+  end
+
+  describe '#overloaded?' do
+    let(:limiter) { described_class.new(:key, 1, :second) }
+
+    it 'works' do
+      expect(limiter.overloaded?).to be false
+      limiter.limit
+      expect(limiter.overloaded?).to be true
+      Timecop.freeze(1)
+      expect(limiter.overloaded?).to be false
     end
   end
 
   describe '#to_s' do
-    def check(count, interval, expected)
+    def check(capacity, interval, expected)
       expect(
-        described_class.new(:key, count, interval).to_s
+        described_class.new(:key, capacity, interval).to_s
       ).to match(expected)
     end
 
@@ -171,16 +178,6 @@ describe Berater::RateLimiter do
       check(1, 'hour', /1 per hour/)
     end
 
-    it 'normalizes' do
-      check(1, :sec, /1 per second/)
-      check(1, :seconds, /1 per second/)
-
-      check(1, :min, /1 per minute/)
-      check(1, :minutes, /1 per minute/)
-
-      check(1, :hours, /1 per hour/)
-    end
-
     it 'works with integers' do
       check(1, 1, /1 every second/)
       check(1, 2, /1 every 2 seconds/)

data/spec/riddle_spec.rb

@@ -0,0 +1,102 @@
+# Can you build a rate limiter from a concurrency limiter?  Yes!
+
+class RateRiddler
+  def self.limit(capacity, interval)
+    lock = Berater::ConcurrencyLimiter.new(:key, capacity, timeout: interval).limit
+    yield if block_given?
+    # allow lock to time out rather than be released
+  end
+end
+
+
+describe 'a ConcurrencyLimiter-derived rate limiter' do
+  def limit(&block)
+    RateRiddler.limit(1, :second, &block)
+  end
+
+  it 'works' do
+    expect(limit { 123 }).to eq 123
+  end
+
+  it 'respects limits' do
+    limit
+    expect { limit }.to be_overloaded
+  end
+
+  it 'resets over time' do
+    limit
+    expect { limit }.to be_overloaded
+
+    Timecop.freeze(1)
+
+    limit
+    expect { limit }.to be_overloaded
+  end
+end
+
+
+# Can you build a concurrency limiter from a rate limiter?  Almost...
+
+class ConcurrenyRiddler
+  def self.limit(capacity, timeout: nil)
+    timeout ||= 1_000 # fake infinity
+
+    limiter = Berater::RateLimiter.new(:key, capacity, timeout)
+    limiter.limit
+    yield if block_given?
+  ensure
+    # decrement counter
+    limiter.redis.decr(limiter.send(:cache_key, :key))
+  end
+end
+
+
+describe 'a RateLimiter-derived concurrency limiter' do
+  def limit(capacity = 1, timeout: nil, &block)
+    ConcurrenyRiddler.limit(capacity, timeout: timeout, &block)
+  end
+
+  it 'works' do
+    expect(limit { 123 }).to eq 123
+  end
+
+  it 'respects limits' do
+    limit do
+      # a second, simultaneous request isn't allowed
+      expect { limit }.to be_overloaded
+    end
+
+    # but now it'll work
+    limit
+  end
+
+  it 'resets over time' do
+    limit(timeout: 1) do
+      expect { limit }.to be_overloaded
+
+      # ...wait for it
+      Timecop.freeze(10)
+
+      limit(timeout: 1)
+    end
+  end
+
+  it "has no memory of the order, so timeouts don't work quite right" do
+    limit(2, timeout: 1) do
+      Timecop.freeze(0.5)
+
+      limit(2, timeout: 1) do
+        # this is where the masquerading breaks.  the first lock is still
+        # being held and within it's timeout limit, however the RaterLimiter
+        # decremented the count internally since enough time has passed.
+        # This next call *should* fail, but doesn't.
+
+        expect {
+          expect { limit(2, timeout: 1) }.to be_overloaded
+        }.to fail
+
+        # ...close, but not quite!
+      end
+    end
+  end
+end

data/spec/test_mode_spec.rb

@@ -1,84 +1,138 @@
-require 'berater/test_mode'
+describe Berater::TestMode, order: :defined do
+  let(:reset_test_mode) { true }
 
-describe 'Berater.test_mode' do
-  after { Berater.test_mode = nil }
+  after do
+    Berater.test_mode = nil if reset_test_mode
+  end
+
+  context 'after test_mode.rb was required, but not used' do
+    let(:reset_test_mode) { false }
+
+    it 'has already been loaded by "berater/rspec", unfortunately' do
+      expect {
+        expect { Berater.test_mode }.to raise_error(NoMethodError)
+      }.to fail
+    end
+
+    it 'defaults to off' do
+      expect(Berater.test_mode).to be nil
+    end
+
+    it 'did not prepend .new yet' do
+      expect(Berater::Limiter.singleton_class.ancestors).not_to include(described_class)
+    end
+
+    it 'prepends when first turned on' do
+      Berater.test_mode = :pass
+
+      expect(Berater::Limiter.singleton_class.ancestors).to include(described_class)
+    end
+
+    it 'preserves the original functionality via super' do
+      expect { Berater::Limiter.new }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '.test_mode' do
+    it 'can be turned on' do
+      Berater.test_mode = :pass
+      expect(Berater.test_mode).to be :pass
+
+      Berater.test_mode = :fail
+      expect(Berater.test_mode).to be :fail
+    end
+
+    it 'can be turned off' do
+      Berater.test_mode = nil
+      expect(Berater.test_mode).to be nil
+    end
+
+    it 'validates input' do
+      expect { Berater.test_mode = :foo }.to raise_error(ArgumentError)
+    end
+  end
+
+  shared_examples 'it always works, without redis' do
+    before do
+      Berater.redis = nil
+      expect_any_instance_of(Berater::LuaScript).not_to receive(:eval)
+    end
+
+    it_behaves_like 'it is not overloaded'
+
+    it 'always works' do
+      10.times { subject.limit }
+    end
+  end
+
+  shared_examples 'it never works, without redis' do
+    before do
+      Berater.redis = nil
+      expect_any_instance_of(Berater::LuaScript).not_to receive(:eval)
+    end
+
+    it_behaves_like 'it is overloaded'
+
+    it 'never works' do
+      expect { subject }.to be_overloaded
+    end
+  end
 
   describe 'Unlimiter' do
-    let(:limiter) { Berater::Unlimiter.new }
+    subject { Berater::Unlimiter.new }
 
     context 'when test_mode = nil' do
       before { Berater.test_mode = nil }
 
-      it { expect(limiter).to be_a Berater::Unlimiter }
-
-      it 'works per usual' do
-        expect {|block| limiter.limit(&block) }.to yield_control
-        10.times { expect(limiter.limit).to be_a Berater::Lock }
-      end
+      it { is_expected.to be_a Berater::Unlimiter }
+      it_behaves_like 'it always works, without redis'
     end
 
     context 'when test_mode = :pass' do
       before { Berater.test_mode = :pass }
 
-      it { expect(limiter).to be_a Berater::Unlimiter }
-
-      it 'always works' do
-        expect {|block| limiter.limit(&block) }.to yield_control
-        10.times { expect(limiter.limit).to be_a Berater::Lock }
-      end
+      it { is_expected.to be_a Berater::Unlimiter }
+      it_behaves_like 'it always works, without redis'
     end
 
     context 'when test_mode = :fail' do
       before { Berater.test_mode = :fail }
 
-      it { expect(limiter).to be_a Berater::Unlimiter }
-
-      it 'never works' do
-        expect { limiter }.to be_overloaded
-      end
+      it { is_expected.to be_a Berater::Unlimiter }
+      it_behaves_like 'it never works, without redis'
     end
   end
 
   describe 'Inhibitor' do
-    let(:limiter) { Berater::Inhibitor.new }
+    subject { Berater::Inhibitor.new }
 
     context 'when test_mode = nil' do
       before { Berater.test_mode = nil }
 
-      it { expect(limiter).to be_a Berater::Inhibitor }
-
-      it 'works per usual' do
-        expect { limiter }.to be_overloaded
-      end
+      it { is_expected.to be_a Berater::Inhibitor }
+      it_behaves_like 'it never works, without redis'
     end
 
     context 'when test_mode = :pass' do
       before { Berater.test_mode = :pass }
 
-      it { expect(limiter).to be_a Berater::Inhibitor }
-
-      it 'always works' do
-        expect {|block| limiter.limit(&block) }.to yield_control
-        10.times { expect(limiter.limit).to be_a Berater::Lock }
-      end
+      it { is_expected.to be_a Berater::Inhibitor }
+      it_behaves_like 'it always works, without redis'
     end
 
     context 'when test_mode = :fail' do
       before { Berater.test_mode = :fail }
 
-      it { expect(limiter).to be_a Berater::Inhibitor }
-
-      it 'never works' do
-        expect { limiter }.to be_overloaded
-      end
+      it { is_expected.to be_a Berater::Inhibitor }
+      it_behaves_like 'it never works, without redis'
     end
   end
 
   describe 'RateLimiter' do
-    let(:limiter) { Berater::RateLimiter.new(:key, 1, :second) }
+    subject { Berater::RateLimiter.new(:key, 1, :second) }
 
     shared_examples 'a RateLimiter' do
-      it { expect(limiter).to be_a Berater::RateLimiter }
+      it { is_expected.to be_a Berater::RateLimiter }
 
       it 'checks arguments' do
         expect {
@@ -91,15 +145,12 @@ describe 'Berater.test_mode' do
       before { Berater.test_mode = nil }
 
       it_behaves_like 'a RateLimiter'
+      it_behaves_like 'it is not overloaded'
 
       it 'works per usual' do
-        expect(limiter.redis).to receive(:eval).twice.and_call_original
-        expect(limiter.limit).to be_a Berater::Lock
-        expect { limiter.limit }.to be_overloaded
-      end
-
-      it 'yields per usual' do
-        expect {|block| limiter.limit(&block) }.to yield_control
+        expect(Berater::RateLimiter::LUA_SCRIPT).to receive(:eval).twice.and_call_original
+        expect(subject.limit).to be_a Berater::Lock
+        expect { subject.limit }.to be_overloaded
       end
     end
 
@@ -107,31 +158,22 @@ describe 'Berater.test_mode' do
       before { Berater.test_mode = :pass }
 
       it_behaves_like 'a RateLimiter'
-
-      it 'always works and without calling redis' do
-        expect(limiter.redis).not_to receive(:eval)
-        expect {|block| limiter.limit(&block) }.to yield_control
-        10.times { expect(limiter.limit).to be_a Berater::Lock }
-      end
+      it_behaves_like 'it always works, without redis'
     end
 
     context 'when test_mode = :fail' do
       before { Berater.test_mode = :fail }
 
       it_behaves_like 'a RateLimiter'
-
-      it 'never works and without calling redis' do
-        expect(limiter.redis).not_to receive(:eval)
-        expect { limiter }.to be_overloaded
-      end
+      it_behaves_like 'it never works, without redis'
     end
   end
 
   describe 'ConcurrencyLimiter' do
-    let(:limiter) { Berater::ConcurrencyLimiter.new(:key, 1) }
+    subject { Berater::ConcurrencyLimiter.new(:key, 1) }
 
     shared_examples 'a ConcurrencyLimiter' do
-      it { expect(limiter).to be_a Berater::ConcurrencyLimiter }
+      it { expect(subject).to be_a Berater::ConcurrencyLimiter }
 
       it 'checks arguments' do
         expect {
@@ -144,15 +186,12 @@ describe 'Berater.test_mode' do
       before { Berater.test_mode = nil }
 
       it_behaves_like 'a ConcurrencyLimiter'
+      it_behaves_like 'it is not overloaded'
 
       it 'works per usual' do
-        expect(limiter.redis).to receive(:eval).twice.and_call_original
-        expect(limiter.limit).to be_a Berater::Lock
-        expect { limiter.limit }.to be_overloaded
-      end
-
-      it 'yields per usual' do
-        expect {|block| limiter.limit(&block) }.to yield_control
+        expect(Berater::ConcurrencyLimiter::LUA_SCRIPT).to receive(:eval).twice.and_call_original
+        expect(subject.limit).to be_a Berater::Lock
+        expect { subject.limit }.to be_overloaded
       end
     end
 
@@ -160,23 +199,14 @@ describe 'Berater.test_mode' do
       before { Berater.test_mode = :pass }
 
       it_behaves_like 'a ConcurrencyLimiter'
-
-      it 'always works and without calling redis' do
-        expect(limiter.redis).not_to receive(:eval)
-        expect {|block| limiter.limit(&block) }.to yield_control
-        10.times { expect(limiter.limit).to be_a Berater::Lock }
-      end
+      it_behaves_like 'it always works, without redis'
     end
 
     context 'when test_mode = :fail' do
       before { Berater.test_mode = :fail }
 
       it_behaves_like 'a ConcurrencyLimiter'
-
-      it 'never works and without calling redis' do
-        expect(limiter.redis).not_to receive(:eval)
-        expect { limiter }.to be_overloaded
-      end
+      it_behaves_like 'it never works, without redis'
     end
   end