berater 0.5.0 → 0.7.1

data/lib/berater/rspec.rb

@@ -1,10 +1,10 @@
 require 'berater'
 require 'berater/rspec/matchers'
 require 'berater/test_mode'
-require 'rspec'
+require 'rspec/core'
 
 RSpec.configure do |config|
-  config.include(BeraterMatchers)
+  config.include(Berater::Matchers)
 
   config.after do
     Berater.expunge rescue nil

data/lib/berater/rspec/matchers.rb

@@ -1,23 +1,20 @@
-module BeraterMatchers
-  class Overloaded
-    def initialize(type)
-      @type = type
-    end
-
-    def supports_block_expectations?
-      true
-    end
+module Berater
+  module Matchers
+    class Overloaded
+      def supports_block_expectations?
+        true
+      end
 
-    def matches?(obj)
-      begin
+      def matches?(obj)
         case obj
         when Proc
-          # eg. expect { ... }.to be_overrated
+          # eg. expect { ... }.to be_overloaded
           res = obj.call
 
           if res.is_a? Berater::Limiter
             # eg. expect { Berater.new(...) }.to be_overloaded
-            res.overloaded?
+            @limiter = res
+            @limiter.utilization >= 1
           else
             # eg. expect { Berater(...)  }.to be_overloaded
             # eg. expect { limiter.limit }.to be_overloaded
@@ -25,38 +22,40 @@ module BeraterMatchers
           end
         when Berater::Limiter
           # eg. expect(Berater.new(...)).to be_overloaded
-          obj.overloaded?
+          @limiter = obj
+          @limiter.utilization >= 1
         end
-      rescue @type
+      rescue Berater::Overloaded
         true
       end
-    end
 
-    # def description
-    # it { expect { Berater.new(:inhibitor) }.not_to be_overrated }
+      def description
+        if @limiter
+          "be overloaded"
+        else
+          "raise #{Berater::Overloaded}"
+        end
+      end
 
-    def failure_message
-      "expected #{@type} to be raised"
-    end
+      def failure_message
+        if @limiter
+          "expected to be overloaded"
+        else
+          "expected #{Berater::Overloaded} to be raised"
+        end
+      end
 
-    def failure_message_when_negated
-      "did not expect #{@type} to be raised"
+      def failure_message_when_negated
+        if @limiter
+          "expected not to be overloaded"
+        else
+          "did not expect #{Berater::Overloaded} to be raised"
+        end
+      end
     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)
+    def be_overloaded
+      Overloaded.new
+    end
   end
 end

data/lib/berater/test_mode.rb

@@ -11,42 +11,26 @@ module Berater
     end
 
     @test_mode = mode
-
-    # overload class methods
-    unless Berater::Limiter.singleton_class.ancestors.include?(TestMode)
-      Berater::Limiter.singleton_class.prepend(TestMode)
-    end
   end
 
   module TestMode
-    def new(*args, **opts)
-      return super unless Berater.test_mode
-
-      # chose a stub class with desired behavior
-      stub_klass = case Berater.test_mode
+    def acquire_lock(*)
+      case Berater.test_mode
       when :pass
-        Berater::Unlimiter
+        Lock.new(Float::INFINITY, 0)
       when :fail
-        Berater::Inhibitor
-      end
-
-      # don't stub self
-      return super if self < stub_klass
-
-      # swap out limit and overloaded? methods with stub
-      super.tap do |instance|
-        stub = stub_klass.allocate
-        stub.send(:initialize, *args, **opts)
-
-        instance.define_singleton_method(:limit) do |**opts, &block|
-          stub.limit(**opts, &block)
-        end
-
-        instance.define_singleton_method(:overloaded?) do
-          stub.overloaded?
-        end
+        raise Overloaded
+      else
+        super
       end
     end
   end
 
 end
+
+# stub each Limiter subclass
+ObjectSpace.each_object(Class).each do |klass|
+  next unless klass < Berater::Limiter
+
+  klass.prepend(Berater::TestMode)
+end

data/lib/berater/unlimiter.rb

@@ -5,12 +5,14 @@ module Berater
       super(key, Float::INFINITY, **opts)
     end
 
-    def limit(**opts, &block)
-      yield_lock(Lock.new(self, Float::INFINITY, 0), &block)
+    protected
+
+    def capacity=(*)
+      @capacity = Float::INFINITY
     end
 
-    def overloaded?
-      false
+    def acquire_lock(*)
+      Lock.new(Float::INFINITY, 0)
     end
 
   end

data/lib/berater/utils.rb

@@ -3,12 +3,12 @@ module Berater
     extend self
 
     refine Object do
-      def to_usec
-        Berater::Utils.to_usec(self)
+      def to_msec
+        Berater::Utils.to_msec(self)
       end
     end
 
-    def to_usec(val)
+    def to_msec(val)
       res = val
 
       if val.is_a? String
@@ -39,7 +39,7 @@ module Berater
         raise ArgumentError, "infinite values not allowed"
       end
 
-      (res * 10**6).to_i
+      (res * 10**3).to_i
     end
 
   end

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = '0.5.0'
+  VERSION = '0.7.1'
 end

data/spec/berater_spec.rb

@@ -25,7 +25,7 @@ describe Berater do
   end
 
   describe '.new' do
-    context 'unlimited mode' do
+    context 'Unlimiter mode' do
       let(:limiter) { Berater.new(:key, Float::INFINITY) }
 
       it 'instantiates an Unlimiter' do
@@ -44,7 +44,7 @@ describe Berater do
       end
     end
 
-    context 'inhibited mode' do
+    context 'Inhibitor mode' do
       let(:limiter) { Berater.new(:key, 0) }
 
       it 'instantiates an Inhibitor' do
@@ -64,7 +64,7 @@ describe Berater do
     end
 
     context 'rate mode' do
-      let(:limiter) { Berater.new(:key, 1, :second) }
+      let(:limiter) { Berater.new(:key, 1, interval: :second) }
 
       it 'instantiates a RateLimiter' do
         expect(limiter).to be_a Berater::RateLimiter
@@ -77,7 +77,7 @@ describe Berater do
 
       it 'accepts options' do
         redis = double('Redis')
-        limiter = Berater.new(:key, 1, :second, redis: redis)
+        limiter = Berater.new(:key, 1, interval: :second, redis: redis)
         expect(limiter.redis).to be redis
       end
     end
@@ -103,20 +103,20 @@ describe Berater do
   end
 
   describe 'Berater() - convenience method' do
-    RSpec.shared_examples 'test convenience' do |klass, *args|
+    RSpec.shared_examples 'test convenience' do |klass, capacity, **opts|
       it 'creates a limiter' do
-        limiter = Berater(:key, *args)
+        limiter = Berater(:key, capacity, **opts)
         expect(limiter).to be_a klass
       end
 
       context 'with a block' do
         it 'creates a limiter and calls limit' do
-          limiter = Berater(:key, *args)
+          limiter = Berater(:key, capacity, **opts)
           expect(klass).to receive(:new).and_return(limiter)
           expect(limiter).to receive(:limit).and_call_original
 
           begin
-            res = Berater(:key, *args) { true }
+            res = Berater(:key, capacity, **opts) { true }
             expect(res).to be true
           rescue Berater::Overloaded
             expect(klass).to be Berater::Inhibitor
@@ -127,7 +127,7 @@ describe Berater do
 
     include_examples 'test convenience', Berater::Unlimiter, Float::INFINITY
     include_examples 'test convenience', Berater::Inhibitor, 0
-    include_examples 'test convenience', Berater::RateLimiter, 1, :second
+    include_examples 'test convenience', Berater::RateLimiter, 1, interval: :second
     include_examples 'test convenience', Berater::ConcurrencyLimiter, 1
   end
 

data/spec/concurrency_limiter_spec.rb

@@ -18,11 +18,12 @@ describe Berater::ConcurrencyLimiter do
   describe '#capacity' do
     def expect_capacity(capacity)
       limiter = described_class.new(:key, capacity)
-      expect(limiter.capacity).to eq capacity
+      expect(limiter.capacity).to eq capacity.to_i
     end
 
     it { expect_capacity(0) }
     it { expect_capacity(1) }
+    it { expect_capacity(1.5) }
     it { expect_capacity(10_000) }
 
     context 'with erroneous values' do
@@ -32,7 +33,6 @@ describe Berater::ConcurrencyLimiter do
         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) }
@@ -42,16 +42,16 @@ describe Berater::ConcurrencyLimiter do
   describe '#timeout' do
     # see spec/utils_spec.rb
 
-    it 'saves the interval in original and microsecond format' do
+    it 'saves the interval in original and millisecond format' do
       limiter = described_class.new(:key, 1, timeout: 3)
       expect(limiter.timeout).to be 3
-      expect(limiter.instance_variable_get(:@timeout_usec)).to be (3 * 10**6)
+      expect(limiter.instance_variable_get(:@timeout_msec)).to be (3 * 10**3)
     end
 
     it 'handles infinity' do
       limiter = described_class.new(:key, 1, timeout: Float::INFINITY)
       expect(limiter.timeout).to be Float::INFINITY
-      expect(limiter.instance_variable_get(:@timeout_usec)).to be 0
+      expect(limiter.instance_variable_get(:@timeout_msec)).to be 0
     end
   end
 
@@ -77,77 +77,104 @@ describe Berater::ConcurrencyLimiter do
       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_overloaded
     end
 
     context 'with capacity 0' do
       let(:limiter) { described_class.new(:key, 0) }
 
       it 'always fails' do
-        expect(limiter).to be_incapacitated
+        expect(limiter).to be_overloaded
+      end
+    end
+
+    context 'when capacity is a Float' do
+      let(:limiter) { described_class.new(:key, 1.5) }
+
+      it 'still works' do
+        lock = limiter.limit
+
+        # since fractional cost is not supported
+        expect(lock.capacity).to be 1
+        expect(limiter).to be_overloaded
       end
     end
 
     it 'limit resets over time' do
       2.times { limiter.limit }
-      expect(limiter).to be_incapacitated
+      expect(limiter).to be_overloaded
 
       Timecop.freeze(30)
 
       2.times { limiter.limit }
-      expect(limiter).to be_incapacitated
+      expect(limiter).to be_overloaded
     end
 
     it 'limit resets with millisecond precision' do
       2.times { limiter.limit }
-      expect(limiter).to be_incapacitated
+      expect(limiter).to be_overloaded
 
       # travel forward to just before first lock times out
       Timecop.freeze(29.999)
-      expect(limiter).to be_incapacitated
+      expect(limiter).to be_overloaded
 
       # traveling one more millisecond will decrement the count
       Timecop.freeze(0.001)
       2.times { limiter.limit }
-      expect(limiter).to be_incapacitated
+      expect(limiter).to be_overloaded
+    end
+
+    it 'accepts a dynamic capacity' do
+      expect { limiter.limit(capacity: 0) }.to be_overloaded
+      5.times { limiter.limit(capacity: 10) }
+      expect { limiter }.to be_overloaded
     end
 
     context 'with cost parameter' do
-      it { expect { limiter.limit(cost: 4) }.to be_incapacitated }
+      it { expect { limiter.limit(cost: 4) }.to be_overloaded }
 
       it 'works within limit' do
         limiter.limit(cost: 2)
-        expect(limiter).to be_incapacitated
+        expect(limiter).to be_overloaded
       end
 
       it 'releases full cost' do
         lock = limiter.limit(cost: 2)
-        expect(limiter).to be_incapacitated
+        expect(limiter).to be_overloaded
 
         lock.release
-        expect(limiter).not_to be_incapacitated
+        expect(limiter).not_to be_overloaded
 
         lock = limiter.limit(cost: 2)
-        expect(limiter).to be_incapacitated
+        expect(limiter).to be_overloaded
       end
 
       it 'respects timeout' do
         limiter.limit(cost: 2)
-        expect(limiter).to be_incapacitated
+        expect(limiter).to be_overloaded
 
         Timecop.freeze(30)
-        expect(limiter).not_to be_incapacitated
+        expect(limiter).not_to be_overloaded
 
         limiter.limit(cost: 2)
-        expect(limiter).to be_incapacitated
+        expect(limiter).to be_overloaded
       end
 
-      it 'accepts a dynamic capacity' do
-        limiter = described_class.new(:key, 1)
+      context 'with fractional costs' do
+        it 'rounds up' do
+          limiter.limit(cost: 1.5)
+          expect(limiter).to be_overloaded
+        end
+
+        it 'accumulates correctly' do
+          limiter.limit(cost: 0.5) # => 1
+          limiter.limit(cost: 0.7) # => 2
+          expect(limiter).to be_overloaded
+        end
+      end
 
-        expect { limiter.limit(capacity: 0) }.to be_incapacitated
-        5.times { limiter.limit(capacity: 10) }
-        expect { limiter }.to be_incapacitated
+      it 'only allows positive values' do
+        expect { limiter.limit(cost: -1) }.to raise_error(ArgumentError)
       end
     end
 
@@ -160,8 +187,8 @@ describe Berater::ConcurrencyLimiter do
       it 'works as expected' do
         expect(limiter_one.limit).to be_a Berater::Lock
 
-        expect(limiter_one).to be_incapacitated
-        expect(limiter_two).to be_incapacitated
+        expect(limiter_one).to be_overloaded
+        expect(limiter_two).to be_overloaded
       end
     end
 
@@ -175,22 +202,22 @@ describe Berater::ConcurrencyLimiter do
         one_lock = limiter_one.limit
         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_overloaded
+        expect(limiter_two).not_to be_overloaded
 
         two_lock = limiter_two.limit
         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_overloaded
+        expect(limiter_two).to be_overloaded
 
         one_lock.release
-        expect(limiter_one).to be_incapacitated
-        expect(limiter_two).not_to be_incapacitated
+        expect(limiter_one).to be_overloaded
+        expect(limiter_two).not_to be_overloaded
 
         two_lock.release
-        expect(limiter_one).not_to be_incapacitated
-        expect(limiter_two).not_to be_incapacitated
+        expect(limiter_one).not_to be_overloaded
+        expect(limiter_two).not_to be_overloaded
       end
     end
 
@@ -199,41 +226,41 @@ describe Berater::ConcurrencyLimiter do
       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_overloaded
+        expect(limiter_two).not_to be_overloaded
 
         one_lock = limiter_one.limit
         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_overloaded
+        expect(limiter_two).not_to be_overloaded
 
         two_lock = limiter_two.limit
         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_overloaded
+        expect(limiter_two).to be_overloaded
       end
     end
   end
 
-  describe '#overloaded?' do
-    let(:limiter) { described_class.new(:key, 1, timeout: 30) }
+  describe '#utilization' do
+    let(:limiter) { described_class.new(:key, 10, timeout: 30) }
 
     it 'works' do
-      expect(limiter.overloaded?).to be false
-      lock = limiter.limit
-      expect(limiter.overloaded?).to be true
-      lock.release
-      expect(limiter.overloaded?).to be false
-    end
+      expect(limiter.utilization).to be 0.0
 
-    it 'respects timeout' do
-      expect(limiter.overloaded?).to be false
-      lock = limiter.limit
-      expect(limiter.overloaded?).to be true
-      Timecop.freeze(30)
-      expect(limiter.overloaded?).to be false
+      2.times { limiter.limit }
+      expect(limiter.utilization).to be 0.2
+
+      Timecop.freeze(15)
+
+      8.times { limiter.limit }
+      expect(limiter.utilization).to be 1.0
+
+      Timecop.freeze(15)
+
+      expect(limiter.utilization).to be 0.8
     end
   end