berater 0.1.2 → 0.4.0

data/spec/inhibitor_spec.rb

@@ -1,36 +1,24 @@
 describe Berater::Inhibitor do
-  before { Berater.mode = :inhibited }
-
   describe '.new' do
     it 'initializes without any arguments or options' do
       expect(described_class.new).to be_a described_class
     end
 
     it 'initializes with any arguments and options' do
-      expect(described_class.new(:abc, x: 123)).to be_a described_class
+      expect(described_class.new(:abc, :def, x: 123)).to be_a described_class
     end
 
     it 'has default values' do
-      expect(described_class.new.key).to eq described_class.to_s
+      expect(described_class.new.key).to be :inhibitor
       expect(described_class.new.redis).to be Berater.redis
     end
   end
 
-  describe '.limit' do
-    it 'always limits' do
-      expect { described_class.limit }.to be_inhibited
-    end
-
-    it 'works with any arguments or options' do
-      expect { described_class.limit(:abc, x: 123) }.to be_inhibited
-    end
-  end
-
   describe '#limit' do
     let(:limiter) { described_class.new }
 
     it 'always limits' do
-      expect { described_class.limit }.to be_inhibited
+      expect { limiter.limit }.to be_inhibited
     end
   end
 

data/spec/{matcher_spec.rb → matchers_spec.rb}

@@ -1,6 +1,6 @@
 describe 'be_overloaded' do
   context 'Berater::Unlimiter' do
-    let(:limiter) { Berater.new(:unlimited) }
+    let(:limiter) { Berater.new(:key, :unlimited) }
 
     it { expect(limiter).not_to be_overloaded }
     it { expect(limiter).not_to be_inhibited }
@@ -19,7 +19,7 @@ describe 'be_overloaded' do
   end
 
   context 'Berater::Inhibitor' do
-    let(:limiter) { Berater.new(:inhibited) }
+    let(:limiter) { Berater.new(:key, :inhibited) }
 
     it { expect(limiter).to be_overloaded }
     it { expect(limiter).to be_inhibited }
@@ -32,7 +32,7 @@ describe 'be_overloaded' do
   end
 
   context 'Berater::RateLimiter' do
-    let(:limiter) { Berater.new(:rate, 1, :second) }
+    let(:limiter) { Berater.new(:key, :rate, 1, :second) }
 
     it { expect(limiter).not_to be_overloaded }
     it { expect(limiter).not_to be_inhibited }
@@ -67,7 +67,7 @@ describe 'be_overloaded' do
   end
 
   context 'Berater::ConcurrencyLimiter' do
-    let(:limiter) { Berater.new(:concurrency, 1) }
+    let(:limiter) { Berater.new(:key, :concurrency, 1) }
 
     it { expect(limiter).not_to be_overloaded }
     it { expect(limiter).not_to be_inhibited }

data/spec/rate_limiter_spec.rb

@@ -1,23 +1,23 @@
 describe Berater::RateLimiter do
-  before { Berater.mode = :rate }
+  it_behaves_like 'a limiter', Berater.new(:key, :rate, 3, :second)
 
   describe '.new' do
-    let(:limiter) { described_class.new(1, :second) }
+    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.interval).to eq 1
+      expect(limiter.interval).to eq :second
     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 '#count' do
     def expect_count(count)
-      limiter = described_class.new(count, :second)
+      limiter = described_class.new(:key, count, :second)
       expect(limiter.count).to eq count
     end
 
@@ -28,7 +28,7 @@ describe Berater::RateLimiter do
     context 'with erroneous values' do
       def expect_bad_count(count)
         expect do
-          described_class.new(count, :second)
+          described_class.new(:key, count, :second)
         end.to raise_error ArgumentError
       end
 
@@ -41,7 +41,7 @@ describe Berater::RateLimiter do
 
   describe '#interval' do
     def expect_interval(interval, expected)
-      limiter = described_class.new(1, interval)
+      limiter = described_class.new(:key, 1, interval)
       expect(limiter.interval).to eq expected
     end
 
@@ -52,28 +52,28 @@ describe Berater::RateLimiter do
     end
 
     context 'with symbols' do
-      it { expect_interval(:sec, 1) }
-      it { expect_interval(:second, 1) }
-      it { expect_interval(:seconds, 1) }
+      it { expect_interval(:sec, :second) }
+      it { expect_interval(:second, :second) }
+      it { expect_interval(:seconds, :second) }
 
-      it { expect_interval(:min, 60) }
-      it { expect_interval(:minute, 60) }
-      it { expect_interval(:minutes, 60) }
+      it { expect_interval(:min, :minute) }
+      it { expect_interval(:minute, :minute) }
+      it { expect_interval(:minutes, :minute) }
 
-      it { expect_interval(:hour, 3600) }
-      it { expect_interval(:hours, 3600) }
+      it { expect_interval(:hour, :hour) }
+      it { expect_interval(:hours, :hour) }
     end
 
     context 'with strings' do
-      it { expect_interval('sec', 1) }
-      it { expect_interval('minute', 60) }
-      it { expect_interval('hours', 3600) }
+      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(1, interval)
+          described_class.new(:key, 1, interval)
         end.to raise_error(ArgumentError)
       end
 
@@ -81,85 +81,110 @@ describe Berater::RateLimiter do
       it { expect_bad_interval(:secondz) }
       it { expect_bad_interval('huor') }
     end
-  end
 
-  describe '#limit' do
-    let(:limiter) { described_class.new(3, :second) }
+    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
 
-    it 'works' do
-      expect(limiter.limit).to eq 1
+      it { expect_sec(:second, 1) }
+      it { expect_sec(:minute, 60) }
+      it { expect_sec(:hour, 3600) }
     end
+  end
 
-    it 'counts' do
-      expect(limiter.limit).to eq 1
-      expect(limiter.limit).to eq 2
-      expect(limiter.limit).to eq 3
-    end
+  describe '#limit' do
+    let(:limiter) { described_class.new(:key, 3, :second) }
 
-    it 'yields' do
+    it 'works' do
       expect {|b| limiter.limit(&b) }.to yield_control
       expect(limiter.limit { 123 }).to eq 123
     end
 
+    it 'works without a block' do
+      expect(limiter.limit).to be_a Berater::Lock
+    end
+
     it 'limits excessive calls' do
       3.times { limiter.limit }
 
-      expect { limiter.limit }.to be_overrated
+      expect(limiter).to be_overrated
     end
 
     it 'limit resets over time' do
-      expect(limiter.limit).to eq 1
-      expect(limiter.limit).to eq 2
-      expect(limiter.limit).to eq 3
+      3.times { limiter.limit }
       expect(limiter).to be_overrated
 
       # travel forward a second
       Timecop.freeze(1)
 
-      expect(limiter.limit).to eq 1
-      expect(limiter.limit).to eq 2
-      expect(limiter.limit).to eq 3
+      3.times { limiter.limit }
       expect(limiter).to be_overrated
     end
   end
 
   context 'with same key, different limiters' do
-    let(:limiter_one) { described_class.new(1, :second) }
-    let(:limiter_two) { described_class.new(1, :second) }
+    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).to eq 1
+      expect(limiter_one.limit).not_to be_overrated
 
-      expect { limiter_one }.to be_overrated
-      expect { limiter_two }.to be_overrated
+      expect(limiter_one).to be_overrated
+      expect(limiter_two).to be_overrated
     end
   end
 
-  context 'with different keys, same limiter' do
-    let(:limiter) { described_class.new(1, :second) }
+  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) }
 
     it 'works as expected' do
-      expect { limiter.limit(key: :one) }.not_to be_overrated
-      expect { limiter.limit(key: :one) }.to be_overrated
+      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.limit(key: :two) }.not_to be_overrated
-      expect { limiter.limit(key: :two) }.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(1, :second, key: :one) }
-    let(:limiter_two) { described_class.new(2, :second, key: :two) }
+  describe '#to_s' do
+    def check(count, interval, expected)
+      expect(
+        described_class.new(:key, count, interval).to_s
+      ).to match(expected)
+    end
 
-    it 'works as expected' do
-      expect(limiter_one.limit).to eq 1
-      expect(limiter_two.limit).to eq 1
+    it 'works with symbols' do
+      check(1, :second, /1 per second/)
+      check(1, :minute, /1 per minute/)
+      check(1, :hour, /1 per hour/)
+    end
+
+    it 'works with strings' do
+      check(1, 'second', /1 per second/)
+      check(1, 'minute', /1 per minute/)
+      check(1, 'hour', /1 per hour/)
+    end
 
-      expect { limiter_one.limit }.to be_overrated
-      expect(limiter_two.limit).to eq 2
+    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
 
-      expect { limiter_one.limit }.to be_overrated
-      expect { limiter_two.limit }.to be_overrated
+    it 'works with integers' do
+      check(1, 1, /1 every second/)
+      check(1, 2, /1 every 2 seconds/)
+      check(2, 3, /2 every 3 seconds/)
     end
   end
 

data/spec/test_mode_spec.rb

@@ -0,0 +1,183 @@
+require 'berater/test_mode'
+
+describe 'Berater.test_mode' do
+  after { Berater.test_mode = nil }
+
+  describe 'Unlimiter' do
+    let(:limiter) { 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
+    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
+    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
+    end
+  end
+
+  describe 'Inhibitor' do
+    let(:limiter) { 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
+    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
+    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
+    end
+  end
+
+  describe 'RateLimiter' do
+    let(:limiter) { Berater::RateLimiter.new(:key, 1, :second) }
+
+    shared_examples 'a RateLimiter' do
+      it { expect(limiter).to be_a Berater::RateLimiter }
+
+      it 'checks arguments' do
+        expect {
+          Berater::RateLimiter.new(:key, 1)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when test_mode = nil' do
+      before { Berater.test_mode = nil }
+
+      it_behaves_like 'a RateLimiter'
+
+      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
+      end
+    end
+
+    context 'when test_mode = :pass' 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
+    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
+    end
+  end
+
+  describe 'ConcurrencyLimiter' do
+    let(:limiter) { Berater::ConcurrencyLimiter.new(:key, 1) }
+
+    shared_examples 'a ConcurrencyLimiter' do
+      it { expect(limiter).to be_a Berater::ConcurrencyLimiter }
+
+      it 'checks arguments' do
+        expect {
+          Berater::ConcurrencyLimiter.new(:key, 1.0)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when test_mode = nil' do
+      before { Berater.test_mode = nil }
+
+      it_behaves_like 'a ConcurrencyLimiter'
+
+      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
+      end
+    end
+
+    context 'when test_mode = :pass' 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
+    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
+    end
+  end
+
+end