berater 0.1.2 → 0.4.0

data/lib/berater/rspec.rb

@@ -0,0 +1,12 @@
+require 'berater'
+require 'berater/rspec/matchers'
+require 'berater/test_mode'
+require 'rspec'
+
+RSpec.configure do |config|
+  config.include(BeraterMatchers)
+
+  config.after do
+    Berater.expunge rescue nil
+  end
+end

data/lib/berater/rspec/matchers.rb

@@ -0,0 +1,60 @@
+module BeraterMatchers
+  class Overloaded
+    def initialize(type)
+      @type = type
+    end
+
+    def supports_block_expectations?
+      true
+    end
+
+    def matches?(obj)
+      begin
+        case obj
+        when Proc
+          # eg. expect { ... }.to be_overrated
+          res = obj.call
+
+          if res.is_a? Berater::Limiter
+            # eg. expect { Berater.new(...) }.to be_overrated
+            res.limit {}
+          end
+        when Berater::Limiter
+          # eg. expect(Berater.new(...)).to be_overrated
+          obj.limit {}
+        end
+
+        false
+      rescue @type
+        true
+      end
+    end
+
+    # def description
+    # it { expect { Berater.new(:inhibitor) }.not_to be_overrated }
+
+    def failure_message
+      "expected #{@type} to be raised"
+    end
+
+    def failure_message_when_negated
+      "did not expect #{@type} to be raised"
+    end
+  end
+
+  def be_overloaded
+    Overloaded.new(Berater::Overloaded)
+  end
+
+  def be_overrated
+    Overloaded.new(Berater::RateLimiter::Overrated)
+  end
+
+  def be_incapacitated
+    Overloaded.new(Berater::ConcurrencyLimiter::Incapacitated)
+  end
+
+  def be_inhibited
+    Overloaded.new(Berater::Inhibitor::Inhibited)
+  end
+end

data/lib/berater/test_mode.rb

@@ -0,0 +1,43 @@
+require 'berater'
+
+module Berater
+  extend self
+
+  attr_reader :test_mode
+
+  def test_mode=(mode)
+    unless [ nil, :pass, :fail ].include?(mode)
+      raise ArgumentError, "invalid mode: #{Berater.test_mode}"
+    end
+
+    @test_mode = mode
+  end
+
+  class Limiter
+    def self.new(*args, **opts)
+      return super unless Berater.test_mode
+
+      # chose a stub class with desired behavior
+      stub_klass = case Berater.test_mode
+      when :pass
+        Berater::Unlimiter
+      when :fail
+        Berater::Inhibitor
+      end
+
+      # don't stub self
+      return super if self < stub_klass
+
+      # swap out limit method with stub
+      super.tap do |instance|
+        stub = stub_klass.allocate
+        stub.send(:initialize, *args, **opts)
+
+        instance.define_singleton_method(:limit) do |&block|
+          stub.limit(&block)
+        end
+      end
+    end
+  end
+
+end

data/lib/berater/unlimiter.rb

@@ -1,18 +1,22 @@
 module Berater
-  class Unlimiter < BaseLimiter
+  class Unlimiter < Limiter
 
-    def initialize(*args, **opts)
-      super(**opts)
+    def initialize(key = :unlimiter, *args, **opts)
+      super(key, **opts)
     end
 
-    def limit(**opts, &block)
-      unless opts.empty?
-        return self.class.new(
-          **options.merge(opts)
-        ).limit(&block)
-      end
+    def limit
+      lock = Lock.new(self, 0, 0)
 
-      yield if block_given?
+      if block_given?
+        begin
+          yield lock
+        ensure
+          lock.release
+        end
+      else
+        lock
+      end
     end
 
   end

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = '0.1.2'
+  VERSION = '0.4.0'
 end

data/spec/berater_spec.rb

@@ -9,10 +9,10 @@ describe Berater do
   describe '.configure' do
     it 'can be set via configure' do
       Berater.configure do |c|
-        c.mode = :rate
+        c.redis = :redis
       end
 
-      expect(Berater.mode).to eq :rate
+      expect(Berater.redis).to eq :redis
     end
   end
 
@@ -24,20 +24,13 @@ describe Berater do
     end
   end
 
-  describe '.mode' do
-    it 'validates inputs' do
-      expect { Berater.mode = :foo }.to raise_error(ArgumentError)
-    end
-  end
-
-  context 'unlimited mode' do
-    before { Berater.mode = :unlimited }
-
-    describe '.new' do
-      let(:limiter) { Berater.new(:unlimited) }
+  describe '.new' do
+    context 'unlimited mode' do
+      let(:limiter) { Berater.new(:key, :unlimited) }
 
       it 'instantiates an Unlimiter' do
         expect(limiter).to be_a Berater::Unlimiter
+        expect(limiter.key).to be :key
       end
 
       it 'inherits redis' do
@@ -46,35 +39,22 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:unlimited, key: 'key', redis: redis)
-        expect(limiter.key).to match(/key/)
+        limiter = Berater.new(:key, :unlimited, redis: redis)
         expect(limiter.redis).to be redis
       end
-    end
-
-    describe '.limit' do
-      it 'works' do
-        expect(Berater.limit).to be_nil
-      end
 
-      it 'yields' do
-        expect {|b| Berater.limit(&b) }.to yield_control
-      end
-
-      it 'never limits' do
-        10.times { expect(Berater.limit { 123 } ).to eq 123 }
+      it 'works with convinience' do
+        expect(Berater).to receive(:new).and_return(limiter)
+        expect {|b| Berater(:key, :unlimited, &b) }.to yield_control
       end
     end
-  end
 
-  context 'inhibited mode' do
-    before { Berater.mode = :inhibited }
-
-    describe '.new' do
-      let(:limiter) { Berater.new(:inhibited) }
+    context 'inhibited mode' do
+      let(:limiter) { Berater.new(:key, :inhibited) }
 
       it 'instantiates an Inhibitor' do
         expect(limiter).to be_a Berater::Inhibitor
+        expect(limiter.key).to be :key
       end
 
       it 'inherits redis' do
@@ -83,27 +63,22 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:inhibited, key: 'key', redis: redis)
-        expect(limiter.key).to match(/key/)
+        limiter = Berater.new(:key, :inhibited, redis: redis)
         expect(limiter.redis).to be redis
       end
-    end
 
-    describe '.limit' do
-      it 'always limits' do
-        expect { Berater.limit }.to be_inhibited
+      it 'works with convinience' do
+        expect(Berater).to receive(:new).and_return(limiter)
+        expect { Berater(:key, :inhibited) }.to be_inhibited
       end
     end
-  end
 
-  context 'rate mode' do
-    before { Berater.mode = :rate }
-
-    describe '.limiter' do
-      let(:limiter) { Berater.new(:rate, 1, :second) }
+    context 'rate mode' do
+      let(:limiter) { Berater.new(:key, :rate, 1, :second) }
 
       it 'instantiates a RateLimiter' do
         expect(limiter).to be_a Berater::RateLimiter
+        expect(limiter.key).to be :key
       end
 
       it 'inherits redis' do
@@ -112,44 +87,22 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:rate, 1, :second, key: 'key', redis: redis)
-        expect(limiter.key).to match(/key/)
+        limiter = Berater.new(:key, :rate, 1, :second, redis: redis)
         expect(limiter.redis).to be redis
       end
-    end
-
-    describe '.limit' do
-      it 'works' do
-        expect(Berater.limit(1, :second)).to eq 1
-      end
-
-      it 'yields' do
-        expect {|b| Berater.limit(2, :second, &b) }.to yield_control
-        expect(Berater.limit(2, :second) { 123 }).to eq 123
-      end
 
-      it 'limits excessive calls' do
-        expect(Berater.limit(1, :second)).to eq 1
-        expect { Berater.limit(1, :second) }.to be_overrated
-      end
-
-      it 'accepts options' do
-        redis = double('Redis')
-        expect(redis).to receive(:multi)
-
-        Berater.limit(1, :second, redis: redis) rescue nil
+      it 'works with convinience' do
+        expect(Berater).to receive(:new).and_return(limiter)
+        expect {|b| Berater(:key, :rate, 1, :second, &b) }.to yield_control
       end
     end
-  end
-
-  context 'concurrency mode' do
-    before { Berater.mode = :concurrency }
 
-    describe '.limiter' do
-      let(:limiter) { Berater.new(:concurrency, 1) }
+    context 'concurrency mode' do
+      let(:limiter) { Berater.new(:key, :concurrency, 1) }
 
       it 'instantiates a ConcurrencyLimiter' do
         expect(limiter).to be_a Berater::ConcurrencyLimiter
+        expect(limiter.key).to be :key
       end
 
       it 'inherits redis' do
@@ -158,33 +111,59 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:concurrency, 1, key: 'key', redis: redis)
-        expect(limiter.key).to match(/key/)
+        limiter = Berater.new(:key, :concurrency, 1, redis: redis)
         expect(limiter.redis).to be redis
       end
+
+      it 'works with convinience' do
+        expect(Berater).to receive(:new).and_return(limiter)
+        expect {|b| Berater(:key, :concurrency, 1, &b) }.to yield_control
+      end
     end
 
-    describe '.limit' do
-      it 'works (without blocks by returning a lock)' do
-        lock = Berater.limit(1)
-        expect(lock).to be_a Berater::ConcurrencyLimiter::Lock
-        expect(lock.release).to be true
+    context 'with DSL' do
+      it 'instatiates an Unlimiter' do
+        limiter = Berater.new(:key) { unlimited }
+        expect(limiter).to be_a Berater::Unlimiter
+        expect(limiter.key).to be :key
       end
 
-      it 'yields' do
-        expect {|b| Berater.limit(1, &b) }.to yield_control
+      it 'instatiates an Inhibiter' do
+        limiter = Berater.new(:key) { inhibited }
+        expect(limiter).to be_a Berater::Inhibitor
+        expect(limiter.key).to be :key
       end
 
-      it 'limits excessive calls' do
-        Berater.limit(1)
-        expect { Berater.limit(1) }.to be_incapacitated
+      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.count).to be 1
+        expect(limiter.interval).to be :second
       end
 
-      it 'accepts options' do
-        redis = double('Redis')
-        expect(redis).to receive(:eval)
+      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 mode/args and dsl block' do
+        expect {
+          Berater.new(:key, :rate) { 1.per second }
+        }.to raise_error(ArgumentError)
+
+        expect {
+          Berater.new(:key, :concurrency, 2) { 3.at_once }
+        }.to raise_error(ArgumentError)
+      end
 
-        Berater.limit(1, redis: redis) rescue nil
+      it 'requires either mode or dsl block' do
+        expect {
+          Berater.new(:key)
+        }.to raise_error(ArgumentError)
       end
     end
   end

data/spec/concurrency_limiter_spec.rb

@@ -1,22 +1,23 @@
 describe Berater::ConcurrencyLimiter do
-  before { Berater.mode = :concurrency }
+  it_behaves_like 'a limiter', described_class.new(:key, 1)
+  it_behaves_like 'a limiter', described_class.new(:key, 1, timeout: 1)
 
   describe '.new' do
-    let(:limiter) { described_class.new(1) }
+    let(:limiter) { described_class.new(:key, 1) }
 
     it 'initializes' do
+      expect(limiter.key).to be :key
       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)
+      limiter = described_class.new(:key, capacity)
       expect(limiter.capacity).to eq capacity
     end
 
@@ -27,7 +28,7 @@ describe Berater::ConcurrencyLimiter do
     context 'with erroneous values' do
       def expect_bad_capacity(capacity)
         expect do
-          described_class.new(capacity)
+          described_class.new(:key, capacity)
         end.to raise_error ArgumentError
       end
 
@@ -40,7 +41,7 @@ describe Berater::ConcurrencyLimiter do
 
   describe '#timeout' do
     def expect_timeout(timeout)
-      limiter = described_class.new(1, timeout: timeout)
+      limiter = described_class.new(:key, 1, timeout: timeout)
       expect(limiter.timeout).to eq timeout
     end
 
@@ -51,7 +52,7 @@ describe Berater::ConcurrencyLimiter do
     context 'with erroneous values' do
       def expect_bad_timeout(timeout)
         expect do
-          described_class.new(1, timeout: timeout)
+          described_class.new(:key, 1, timeout: timeout)
         end.to raise_error ArgumentError
       end
 
@@ -63,126 +64,114 @@ describe Berater::ConcurrencyLimiter do
   end
 
   describe '#limit' do
-    let(:limiter) { described_class.new(2, timeout: 1) }
+    let(:limiter) { described_class.new(:key, 2) }
 
     it 'works' do
       expect {|b| limiter.limit(&b) }.to yield_control
     end
 
-    it 'works many times if workers complete and return locks' do
+    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.limit).to be_a Berater::Lock
+      expect(limiter.limit).to be_a Berater::Lock
 
-      expect { limiter }.to be_incapacitated
+      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
+    context 'with capacity 0' do
+      let(:limiter) { described_class.new(:key, 0) }
 
-      sleep(1)
-
-      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
-      expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
-      expect { limiter }.to be_incapacitated
+      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) }
+    let(:limiter_one) { described_class.new(:key, 1) }
+    let(:limiter_two) { described_class.new(:key, 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.limit).to be_a Berater::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
+      expect(limiter_one).to be_incapacitated
+      expect(limiter_two).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) }
+    let(:limiter_one) { described_class.new(:key, 1) }
+    let(:limiter_two) { described_class.new(:key, 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(one_lock).to be_a Berater::Lock
 
-      expect { limiter_one }.to be_incapacitated
-      expect { limiter_two }.not_to be_incapacitated
+      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(two_lock).to be_a Berater::Lock
 
-      expect { limiter_one }.to be_incapacitated
-      expect { limiter_two }.to be_incapacitated
+      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
+      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
+      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) }
+    let(:limiter_one) { described_class.new(:one, 1) }
+    let(:limiter_two) { described_class.new(:two, 1) }
 
     it 'works as expected' do
-      expect { limiter_one }.not_to be_incapacitated
-      expect { limiter_two }.not_to be_incapacitated
+      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(one_lock).to be_a Berater::Lock
 
-      expect { limiter_one }.to be_incapacitated
-      expect { limiter_two }.not_to be_incapacitated
+      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(two_lock).to be_a Berater::Lock
 
-      expect { limiter_one }.to be_incapacitated
-      expect { limiter_two }.to be_incapacitated
+      expect(limiter_one).to be_incapacitated
+      expect(limiter_two).to be_incapacitated
+    end
+  end
+
+  describe '#to_s' do
+    def check(capacity, expected)
+      expect(
+        described_class.new(:key, capacity).to_s
+      ).to match(expected)
+    end
+
+    it 'works' do
+      check(1, /1 at a time/)
+      check(3, /3 at a time/)
     end
   end