berater 0.0.1 → 0.1.4

data/spec/concurrency_limiter_spec.rb

@@ -0,0 +1,202 @@
+describe Berater::ConcurrencyLimiter do
+  before { Berater.mode = :concurrency }
+
+  describe '.new' do
+    let(:limiter) { described_class.new(1) }
+
+    it 'initializes' do
+      expect(limiter.capacity).to be 1
+    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 '#capacity' do
+    def expect_capacity(capacity)
+      limiter = described_class.new(capacity)
+      expect(limiter.capacity).to eq capacity
+    end
+
+    it { expect_capacity(0) }
+    it { expect_capacity(1) }
+    it { expect_capacity(10_000) }
+
+    context 'with erroneous values' do
+      def expect_bad_capacity(capacity)
+        expect do
+          described_class.new(capacity)
+        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) }
+    end
+  end
+
+  describe '#timeout' do
+    def expect_timeout(timeout)
+      limiter = described_class.new(1, timeout: timeout)
+      expect(limiter.timeout).to eq timeout
+    end
+
+    it { expect_timeout(0) }
+    it { expect_timeout(1) }
+    it { expect_timeout(10_000) }
+
+    context 'with erroneous values' do
+      def expect_bad_timeout(timeout)
+        expect do
+          described_class.new(1, timeout: timeout)
+        end.to raise_error ArgumentError
+      end
+
+      it { expect_bad_timeout(0.5) }
+      it { expect_bad_timeout(-1) }
+      it { expect_bad_timeout('1') }
+      it { expect_bad_timeout(:one) }
+    end
+  end
+
+  describe '#limit' do
+    let(:limiter) { described_class.new(2, timeout: 1) }
+
+    it 'works' do
+      expect {|b| limiter.limit(&b) }.to yield_control
+    end
+
+    it 'works many times if workers release locks' do
+      30.times do
+        expect {|b| limiter.limit(&b) }.to yield_control
+      end
+
+      30.times do
+        lock = limiter.limit
+        lock.release
+      end
+    end
+
+    it 'limits excessive calls' do
+      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+
+      expect(limiter).to be_incapacitated
+    end
+
+    it 'times out locks' do
+      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(limiter).to be_incapacitated
+
+      Timecop.travel(1)
+
+      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
+      expect(limiter).to be_incapacitated
+    end
+
+    context 'with capacity 0' do
+      let(:limiter) { described_class.new(0) }
+
+      it 'always fails' do
+        expect(limiter).to be_incapacitated
+      end
+    end
+  end
+
+  context 'with same key, different limiters' do
+    let(:limiter_one) { described_class.new(1) }
+    let(:limiter_two) { described_class.new(1) }
+
+    it { expect(limiter_one.key).to eq limiter_two.key }
+
+    it 'works as expected' do
+      expect(limiter_one.limit).to be_a Berater::ConcurrencyLimiter::Lock
+
+      expect(limiter_one).to be_incapacitated
+      expect(limiter_two).to be_incapacitated
+    end
+  end
+
+  context 'with different keys, same limiter' do
+    let(:limiter) { described_class.new(1) }
+
+    it 'works as expected' do
+      one_lock = limiter.limit(key: :one)
+      expect(one_lock).to be_a Berater::ConcurrencyLimiter::Lock
+
+      expect { limiter.limit(key: :one) {} }.to be_incapacitated
+      expect { limiter.limit(key: :two) {} }.not_to be_incapacitated
+
+      two_lock = limiter.limit(key: :two)
+      expect(two_lock).to be_a Berater::ConcurrencyLimiter::Lock
+
+      expect { limiter.limit(key: :one) {} }.to be_incapacitated
+      expect { limiter.limit(key: :two) {} }.to be_incapacitated
+
+      one_lock.release
+      expect { limiter.limit(key: :one) {} }.not_to be_incapacitated
+      expect { limiter.limit(key: :two) {} }.to be_incapacitated
+
+      two_lock.release
+      expect { limiter.limit(key: :one) {} }.not_to be_incapacitated
+      expect { limiter.limit(key: :two) {} }.not_to be_incapacitated
+    end
+  end
+
+  context 'with same key, different capacities' do
+    let(:limiter_one) { described_class.new(1) }
+    let(:limiter_two) { described_class.new(2) }
+
+    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::ConcurrencyLimiter::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::ConcurrencyLimiter::Lock
+
+      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
+
+      two_lock.release
+      expect(limiter_one).not_to be_incapacitated
+      expect(limiter_two).not_to be_incapacitated
+    end
+  end
+
+  context 'with different keys, different limiters' do
+    let(:limiter_one) { described_class.new(1, key: :one) }
+    let(:limiter_two) { described_class.new(1, key: :two) }
+
+    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::ConcurrencyLimiter::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::ConcurrencyLimiter::Lock
+
+      expect(limiter_one).to be_incapacitated
+      expect(limiter_two).to be_incapacitated
+    end
+  end
+
+end

data/spec/concurrency_lock_spec.rb

@@ -0,0 +1,92 @@
+describe Berater::ConcurrencyLimiter::Lock do
+  before { Berater.mode = :concurrency }
+
+  let(:limiter) { Berater.new(:concurrency, 3) }
+
+  describe '#contention' do
+    it 'tracks contention' do
+      lock_1 = limiter.limit
+      expect(lock_1.contention).to eq 1
+
+      lock_2 = limiter.limit
+      expect(lock_2.contention).to eq 2
+
+      limiter.limit do |lock_3|
+        expect(lock_3.contention).to eq 3
+      end
+    end
+
+    it 'works in block mode' do
+      lock_1 = limiter.limit
+
+      limiter.limit do |lock_2|
+        expect(lock_1.contention).to eq 1
+        expect(lock_2.contention).to eq 2
+      end
+    end
+  end
+
+  describe '#release' do
+    it 'can not be released twice' do
+      lock = limiter.limit
+      expect(lock.release).to be true
+      expect { lock.release }.to raise_error(RuntimeError, /already/)
+    end
+
+    it 'does not work in block mode' do
+      expect do
+        limiter.limit do |lock|
+          lock.release
+        end
+      end.to raise_error(RuntimeError, /already/)
+    end
+  end
+
+  describe '#released?' do
+    it 'works' do
+      lock = limiter.limit
+      expect(lock.released?).to be false
+
+      lock.release
+      expect(lock.released?).to be true
+    end
+
+    it 'works in block mode' do
+      limiter.limit do |lock|
+        expect(lock.released?).to be false
+      end
+    end
+  end
+
+  describe '#expired?' do
+    let!(:lock) { limiter.limit }
+
+    context 'when timeout is not set' do
+      it { expect(limiter.timeout).to eq 0 }
+
+      it 'never expires' do
+        expect(lock.expired?).to be false
+
+        Timecop.travel(1_000)
+
+        expect(lock.expired?).to be false
+      end
+    end
+
+    context 'when timeout is set and exceeded' do
+      before { Timecop.travel(1) }
+
+      let(:limiter) { Berater.new(:concurrency, 3, timeout: 1) }
+
+      it 'expires' do
+        expect(lock.expired?).to be true
+      end
+
+      it 'fails to release' do
+        expect(lock.released?).to be false
+        expect { lock.release }.to raise_error(RuntimeError, /expired/)
+      end
+    end
+  end
+
+end

data/spec/inhibitor_spec.rb

@@ -0,0 +1,37 @@
+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
+    end
+
+    it 'has default values' do
+      expect(described_class.new.key).to eq described_class.to_s
+      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
+    end
+  end
+
+end

data/spec/matcher_spec.rb

@@ -0,0 +1,118 @@
+describe 'be_overloaded' do
+  context 'Berater::Unlimiter' do
+    let(:limiter) { Berater.new(:unlimited) }
+
+    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(:inhibited) }
+
+    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(:rate, 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
+      end
+
+      it 'should be_overrated' do
+        expect { limiter }.to be_overrated
+      end
+
+      it 'should be_overrated' do
+        expect { limiter.limit }.to be_overrated
+      end
+    end
+  end
+
+  context 'Berater::ConcurrencyLimiter' do
+    let(:limiter) { Berater.new(:concurrency, 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
+        3.times do
+          expect(limiter).not_to be_incapacitated
+        end
+      end
+
+      it 'should be_incapacitated' do
+        3.times do
+          expect { limiter }.not_to be_incapacitated
+        end
+      end
+
+      it 'should be_incapacitated' do
+        3.times do
+          expect { limiter.limit {} }.not_to be_incapacitated
+        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
+      end
+
+      it 'should be_incapacitated' do
+        expect { 3.times { limiter.limit } }.to be_incapacitated
+      end
+    end
+  end
+end