berater 0.2.0 → 0.6.1

data/spec/limiter_spec.rb

@@ -0,0 +1,71 @@
+describe Berater::Limiter do
+  it 'can not be initialized' do
+    expect { described_class.new }.to raise_error(NotImplementedError)
+  end
+
+  describe 'abstract methods' do
+    let(:limiter) { Class.new(described_class).new(:key, 1) }
+
+    it do
+      expect { limiter.limit }.to raise_error(NotImplementedError)
+      expect { limiter.overloaded? }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '==' do
+    let(:limiter)  { Berater::RateLimiter.new(:key, 1, :second) }
+
+    it 'equals itself' do
+      expect(limiter).to eq limiter
+    end
+
+    it 'equals something with the same initialization parameters' do
+      expect(limiter).to eq(
+        Berater::RateLimiter.new(:key, 1, :second)
+      )
+    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)
+      )
+
+      expect(limiter).not_to eq(
+        Berater::RateLimiter.new(:keyz, 1, :second)
+      )
+
+      expect(limiter).not_to eq(
+        Berater::RateLimiter.new(:key, 1, :minute)
+      )
+    end
+
+    it 'does not equal something altogether different' do
+      expect(limiter).not_to eq(
+        Berater::ConcurrencyLimiter.new(:key, 1)
+      )
+    end
+
+    it 'works for ConcurrencyLimiter too' do
+      limiter = Berater::ConcurrencyLimiter.new(:key, 1)
+      expect(limiter).to eq limiter
+
+      expect(limiter).not_to eq(
+        Berater::ConcurrencyLimiter.new(:key, 1, timeout: 1)
+      )
+    end
+
+    it 'and the others' do
+      unlimiter = Berater::Unlimiter.new
+      expect(unlimiter).to eq unlimiter
+
+      expect(unlimiter).not_to eq Berater::Inhibitor.new
+    end
+  end
+
+end

data/spec/lua_script_spec.rb

@@ -0,0 +1,97 @@
+describe Berater::LuaScript do
+  subject { Berater::LuaScript('return redis.call("PING")') }
+
+  before { redis.script(:flush) }
+
+  let(:redis) { Berater.redis }
+
+  it { is_expected.to be_a Berater::LuaScript }
+
+  describe '#eval' do
+    def ping
+      expect(subject.eval(redis)).to eq 'PONG'
+    end
+
+    it { ping }
+
+    it 'loads the script into redis' do
+      expect(redis).to receive(:evalsha).once.and_call_original
+      expect(redis).to receive(:eval).once.and_call_original
+      ping
+      expect(subject.loaded?(redis)).to be true
+    end
+  end
+
+  describe '#load' do
+    it 'loads script into redis' do
+      expect(redis.script(:exists, subject.sha)).to be false
+      subject.load(redis)
+      expect(redis.script(:exists, subject.sha)).to be true
+    end
+
+    it 'returns the sha' do
+      expect(subject.load(redis)).to eq subject.sha
+    end
+
+    it 'validates the returned sha' do
+      allow(redis).to receive(:script).with(:flush).and_call_original
+      expect(redis).to receive(:script).with(:load, String).and_return('abc')
+      expect { subject.load(redis) }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '#loaded?' do
+    it do
+      expect(subject.loaded?(redis)).to be false
+      subject.load(redis)
+      expect(subject.loaded?(redis)).to be true
+    end
+  end
+
+  describe '#to_s' do
+    it { expect(subject.to_s).to be subject.source }
+  end
+
+  describe '#minify' do
+    subject do
+      expect(
+        Berater::LuaScript(lua).send(:minify)
+      ).to eq expected
+    end
+
+    context do
+      let(:lua) do <<-LUA
+          -- this comment gets removed
+          redis.call('PING')  -- this one too
+        LUA
+      end
+
+      let(:expected) { "redis.call('PING')" }
+
+      it { subject }
+    end
+
+    context 'with if statement' do
+      let(:lua) do <<~LUA
+          if condition then
+            call
+          end
+
+          return 123
+        LUA
+      end
+
+      let(:expected) do
+        [
+          'if condition then',
+          'call',
+          'end',
+          'return 123'
+        ].join "\n"
+      end
+
+      it { subject }
+    end
+  end
+
+end

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

@@ -1,4 +1,5 @@
-describe 'be_overloaded' do
+describe Berater::Matchers::Overloaded do
+
   context 'Berater::Unlimiter' do
     let(:limiter) { Berater.new(:key, :unlimited) }
 
@@ -32,7 +33,7 @@ describe 'be_overloaded' do
   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 +68,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 }
@@ -115,4 +116,71 @@ describe 'be_overloaded' do
       end
     end
   end
+
+  context 'when matchers fail' do
+    let(:unlimiter) { Berater::Unlimiter.new }
+    let(:inhibitor) { Berater::Inhibitor.new }
+
+    it 'catches false negatives' do
+      expect {
+        expect(unlimiter).to be_overloaded
+      }.to fail_including('expected to be overloaded')
+
+      expect {
+        expect { unlimiter }.to be_overloaded
+      }.to fail_including('expected to be overloaded')
+
+      expect {
+        expect { unlimiter.limit }.to be_overloaded
+      }.to fail_including("expected #{Berater::Overloaded} to be raised")
+
+      expect {
+        expect { 123 }.to be_overloaded
+      }.to fail_including("expected #{Berater::Overloaded} to be raised")
+    end
+
+    it 'catches false positives' do
+      expect {
+        expect(inhibitor).not_to be_overloaded
+      }.to fail_including('expected not to be overloaded')
+
+      expect {
+        expect { inhibitor }.not_to be_overloaded
+      }.to fail_including('expected not to be overloaded')
+
+      expect {
+        expect { inhibitor.limit }.not_to be_overloaded
+      }.to fail_including("did not expect #{Berater::Overloaded} to be raised")
+
+      expect {
+        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

data/spec/rate_limiter_spec.rb

@@ -1,12 +1,13 @@
 describe Berater::RateLimiter do
+  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.interval).to eq 1
+      expect(limiter.capacity).to eq 1
+      expect(limiter.interval).to eq :second
     end
 
     it 'has default values' do
@@ -14,71 +15,48 @@ 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(1.5) }
+    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(-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, 1) }
-      it { expect_interval(:second, 1) }
-      it { expect_interval(:seconds, 1) }
+    # see spec/utils_spec.rb for more
 
-      it { expect_interval(:min, 60) }
-      it { expect_interval(:minute, 60) }
-      it { expect_interval(:minutes, 60) }
+    subject { described_class.new(:key, 1, :second) }
 
-      it { expect_interval(:hour, 3600) }
-      it { expect_interval(:hours, 3600) }
+    it 'saves the interval in original and millisecond format' do
+      expect(subject.interval).to be :second
+      expect(subject.instance_variable_get(:@interval_msec)).to be 10**3
     end
 
-    context 'with strings' do
-      it { expect_interval('sec', 1) }
-      it { expect_interval('minute', 60) }
-      it { expect_interval('hours', 3600) }
-    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 'must be > 0' do
+      expect {
+        described_class.new(:key, 1, 0)
+      }.to raise_error(ArgumentError)
 
-      it { expect_bad_interval(-1) }
-      it { expect_bad_interval(:secondz) }
-      it { expect_bad_interval('huor') }
+      expect {
+        described_class.new(:key, 1, -1)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -100,43 +78,151 @@ describe Berater::RateLimiter do
       expect(limiter).to be_overrated
     end
 
-    it 'limit resets over time' do
+    it 'resets limit over time' do
       3.times { limiter.limit }
       expect(limiter).to be_overrated
 
-      # travel forward a second
       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) }
+    context 'with millisecond precision' do
+      it 'resets limit over time' do
+        3.times { limiter.limit }
+        expect(limiter).to be_overrated
+
+        # 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
+      end
+
+      it 'works when drip rate is < 1 per millisecond' do
+        limiter = described_class.new(:key, 2_000, :second)
 
-    it 'works as expected' do
-      expect(limiter_one.limit).not_to be_overrated
+        limiter.capacity.times { limiter.limit }
+        expect(limiter).to be_overrated
 
-      expect(limiter_one).to be_overrated
-      expect(limiter_two).to be_overrated
+        Timecop.freeze(0.001)
+        expect(limiter).not_to be_overrated
+
+        2.times { limiter.limit }
+      end
+    end
+
+    context 'when capacity is a Float' do
+      let(:limiter) { described_class.new(:key, 1.5, :second) }
+
+      it 'still works' do
+        limiter.limit
+        expect(limiter).not_to be_overrated
+
+        expect { limiter.limit }.to be_overrated
+
+        limiter.limit(cost: 0.5)
+      end
+    end
+
+    it 'accepts a dynamic capacity' do
+      limiter = described_class.new(:key, 1, :second)
+
+      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 }
+
+      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
+
+    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_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) }
+
+      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
 
-  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) }
+  describe '#overloaded?' do
+    let(:limiter) { 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' 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(capacity, interval, expected)
+      expect(
+        described_class.new(:key, capacity, interval).to_s
+      ).to match(expected)
+    end
 
-      expect(limiter_one).to be_overrated
-      expect(limiter_two.limit).not_to be_overrated
+    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).to be_overrated
-      expect(limiter_two).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