berater 0.4.0 → 0.7.0

data/spec/dsl_refinement_spec.rb

@@ -0,0 +1,34 @@
+require 'berater/dsl'
+
+describe Berater do
+  using Berater::DSL
+
+  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,60 @@
+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, 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, interval: :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: 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
+
+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

data/spec/limiter_spec.rb

@@ -0,0 +1,107 @@
+describe Berater::Limiter do
+  it 'can not be initialized' do
+    expect { described_class.new }.to raise_error(NoMethodError)
+  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.utilization }.to raise_error(NotImplementedError)
+    end
+  end
+
+  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)
+      end
+    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/matchers_spec.rb

@@ -1,118 +1,122 @@
-describe 'be_overloaded' do
+describe Berater::Matchers::Overloaded do
+
   context 'Berater::Unlimiter' do
-    let(:limiter) { Berater.new(:key, :unlimited) }
+    let(:limiter) { Berater::Unlimiter.new }
 
     it { expect(limiter).not_to be_overloaded }
-    it { expect(limiter).not_to be_inhibited }
-    it { expect(limiter).not_to be_overrated }
-    it { expect(limiter).not_to be_incapacitated }
-
     it { expect { limiter }.not_to be_overloaded }
-    it { expect { limiter }.not_to be_inhibited }
-    it { expect { limiter }.not_to be_overrated }
-    it { expect { limiter }.not_to be_incapacitated }
-
     it { expect { limiter.limit }.not_to be_overloaded }
-    it { expect { limiter.limit }.not_to be_inhibited }
-    it { expect { limiter.limit }.not_to be_overrated }
-    it { expect { limiter.limit }.not_to be_incapacitated }
   end
 
   context 'Berater::Inhibitor' do
-    let(:limiter) { Berater.new(:key, :inhibited) }
+    let(:limiter) { Berater::Inhibitor.new }
 
     it { expect(limiter).to be_overloaded }
-    it { expect(limiter).to be_inhibited }
-
     it { expect { limiter }.to be_overloaded }
-    it { expect { limiter }.to be_inhibited }
-
     it { expect { limiter.limit }.to be_overloaded }
-    it { expect { limiter.limit }.to be_inhibited }
   end
 
   context 'Berater::RateLimiter' do
-    let(:limiter) { Berater.new(:key, :rate, 1, :second) }
+    let(:limiter) { Berater::RateLimiter.new(:key, 1, :second) }
 
     it { expect(limiter).not_to be_overloaded }
-    it { expect(limiter).not_to be_inhibited }
-    it { expect(limiter).not_to be_overrated }
-    it { expect(limiter).not_to be_incapacitated }
-
     it { expect { limiter }.not_to be_overloaded }
-    it { expect { limiter }.not_to be_inhibited }
-    it { expect { limiter }.not_to be_overrated }
-    it { expect { limiter }.not_to be_incapacitated }
-
     it { expect { limiter.limit }.not_to be_overloaded }
-    it { expect { limiter.limit }.not_to be_inhibited }
-    it { expect { limiter.limit }.not_to be_overrated }
-    it { expect { limiter.limit }.not_to be_incapacitated }
 
     context 'once limit is used up' do
       before { limiter.limit }
 
-      it 'should be_overrated' do
-        expect(limiter).to be_overrated
+      it 'should be_overloaded' do
+        expect(limiter).to be_overloaded
       end
 
-      it 'should be_overrated' do
-        expect { limiter }.to be_overrated
+      it 'should be_overloaded' do
+        expect { limiter }.to be_overloaded
       end
 
-      it 'should be_overrated' do
-        expect { limiter.limit }.to be_overrated
+      it 'should be_overloaded' do
+        expect { limiter.limit }.to be_overloaded
       end
     end
   end
 
   context 'Berater::ConcurrencyLimiter' do
-    let(:limiter) { Berater.new(:key, :concurrency, 1) }
+    let(:limiter) { Berater::ConcurrencyLimiter.new(:key, 1) }
 
     it { expect(limiter).not_to be_overloaded }
-    it { expect(limiter).not_to be_inhibited }
-    it { expect(limiter).not_to be_overrated }
-    it { expect(limiter).not_to be_incapacitated }
-
     it { expect { limiter }.not_to be_overloaded }
-    it { expect { limiter }.not_to be_inhibited }
-    it { expect { limiter }.not_to be_overrated }
-    it { expect { limiter }.not_to be_incapacitated }
-
     it { expect { limiter.limit }.not_to be_overloaded }
-    it { expect { limiter.limit }.not_to be_inhibited }
-    it { expect { limiter.limit }.not_to be_overrated }
-    it { expect { limiter.limit }.not_to be_incapacitated }
 
     context 'when lock is released' do
-      it 'should be_incapacitated' do
+      it 'should be_overloaded' do
         3.times do
-          expect(limiter).not_to be_incapacitated
+          expect(limiter).not_to be_overloaded
         end
       end
 
-      it 'should be_incapacitated' do
+      it 'should be_overloaded' do
         3.times do
-          expect { limiter }.not_to be_incapacitated
+          expect { limiter }.not_to be_overloaded
         end
       end
 
-      it 'should be_incapacitated' do
+      it 'should be_overloaded' do
         3.times do
-          expect { limiter.limit {} }.not_to be_incapacitated
+          expect { limiter.limit {} }.not_to be_overloaded
         end
       end
     end
 
     context 'when lock is *not* released' do
-      it 'should be_incapacitated' do
-        expect { limiter.limit }.not_to be_incapacitated
-        expect { limiter.limit }.to be_incapacitated
+      it 'should be_overloaded' do
+        expect { limiter.limit }.not_to be_overloaded
+        expect { limiter.limit }.to be_overloaded
       end
 
-      it 'should be_incapacitated' do
-        expect { 3.times { limiter.limit } }.to be_incapacitated
+      it 'should be_overloaded' do
+        expect { 3.times { limiter.limit } }.to be_overloaded
       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
+  end
 end