berater 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87d3bdb61a68a8b69dd7cb285dafb174a403acf19ff7586f90ed8b7cb50b7f76
-  data.tar.gz: fff71dd4d8ae28baf7c504efdc27df71f03219b32c1a959dddfd3d035845d058
+  metadata.gz: 5c5cc50ba02c18bf9ef9f6b9c1dd6ccb8f8af0297df95757ac13406dc4539c40
+  data.tar.gz: f80341dccff30ca3f344f3bdf21de44b1ef1715bfaf4140933a91252ddb7231e
 SHA512:
-  metadata.gz: c9fb5c0c7ec100d2f50a3b6c6cfa449af052c1b78cff174b545e179c5fcc1324c2a5faafc90e7f7ec64ce200e47571d51b02eb56398d716c487abc7731c0cece
-  data.tar.gz: 148c566413d6593f229143e2871116b45947eae5b101d8bb2f59ce3bdfe89ed4ee1b7aaedfcaedbc80eef8a25a14fab83ad5e540172c41f31f27d7f296161235
+  metadata.gz: ada3fffc841e71498f652dc990eed482bccc942b86280fc5ee736d49fdf99d8ab2f921b5b52d96f3588c268c34343669c00e0be8822c462a3e6f9dcf954a4005
+  data.tar.gz: 0363abef69cfdad8140d89373b5088cfa8a6259f16716011c82ceb1e2e9e948cdb4d44ddd36aaf1d05b121dc7d275d0ee34571a0a3ee9b964f4286375ec356cf

data/lib/berater/concurrency_limiter.rb

@@ -63,15 +63,10 @@ module Berater
     LUA
     )
 
-    def limit(capacity: nil, cost: 1, &block)
-      capacity ||= @capacity
-
-      # since fractional cost is not supported, capacity behaves like int
+    protected def acquire_lock(capacity, cost)
+      # fractional cost is not supported, but make it work
       capacity = capacity.to_i
-
-      unless cost.is_a?(Integer) && cost >= 0
-        raise ArgumentError, "invalid cost: #{cost}"
-      end
+      cost = cost.ceil
 
       # timestamp in milliseconds
       ts = (Time.now.to_f * 10**3).to_i
@@ -87,16 +82,10 @@ module Berater
       release_fn = if cost > 0
         proc { release(lock_ids) }
       end
-      lock = Lock.new(capacity, count, release_fn)
 
-      yield_lock(lock, &block)
+      Lock.new(capacity, count, release_fn)
     end
 
-    def overloaded?
-      limit(cost: 0) { false }
-    rescue Overloaded
-      true
-    end
     alias incapacitated? overloaded?
 
     private def release(lock_ids)

data/lib/berater/inhibitor.rb

@@ -7,14 +7,11 @@ module Berater
       super(key, 0, **opts)
     end
 
-    def limit(**opts)
-      raise Inhibited
-    end
+    alias inhibited? overloaded?
 
-    def overloaded?
-      true
+    protected def acquire_lock(*)
+      raise Inhibited
     end
-    alias inhibited? overloaded?
 
   end
 end

data/lib/berater/limiter.rb

@@ -7,12 +7,34 @@ module Berater
       options[:redis] || Berater.redis
     end
 
-    def limit
-      raise NotImplementedError
+    def limit(capacity: nil, cost: 1, &block)
+      capacity ||= @capacity
+
+      unless capacity.is_a?(Numeric)
+        raise ArgumentError, "invalid capacity: #{capacity}"
+      end
+
+      unless cost.is_a?(Numeric) && cost >= 0
+        raise ArgumentError, "invalid cost: #{cost}"
+      end
+
+      lock = acquire_lock(capacity, cost)
+
+      if block_given?
+        begin
+          yield lock
+        ensure
+          lock.release
+        end
+      else
+        lock
+      end
     end
 
     def overloaded?
-      raise NotImplementedError
+      limit(cost: 0) { false }
+    rescue Overloaded
+      true
     end
 
     def to_s
@@ -60,20 +82,12 @@ module Berater
       @capacity = capacity
     end
 
-    def cache_key(key)
-      "#{self.class}:#{key}"
+    def acquire_lock(capacity, cost)
+      raise NotImplementedError
     end
 
-    def yield_lock(lock, &block)
-      if block_given?
-        begin
-          yield lock
-        ensure
-          lock.release
-        end
-      else
-        lock
-      end
+    def cache_key(key)
+      "#{self.class}:#{key}"
     end
 
   end

data/lib/berater/rate_limiter.rb

@@ -63,9 +63,7 @@ module Berater
     LUA
     )
 
-    def limit(capacity: nil, cost: 1, &block)
-      capacity ||= @capacity
-
+    protected def acquire_lock(capacity, cost)
       # timestamp in milliseconds
       ts = (Time.now.to_f * 10**3).to_i
 
@@ -77,15 +75,9 @@ module Berater
 
       raise Overrated unless allowed
 
-      lock = Lock.new(capacity, count)
-      yield_lock(lock, &block)
+      Lock.new(capacity, count)
     end
 
-    def overloaded?
-      limit(cost: 0) { false }
-    rescue Overrated
-      true
-    end
     alias overrated? overloaded?
 
     def to_s

data/lib/berater/rspec/matchers.rb

@@ -10,29 +10,27 @@ module Berater
       end
 
       def matches?(obj)
-        begin
-          case obj
-          when Proc
-            # eg. expect { ... }.to be_overrated
-            res = obj.call
+        case obj
+        when Proc
+          # eg. expect { ... }.to be_overrated
+          res = obj.call
 
-            if res.is_a? Berater::Limiter
-              # eg. expect { Berater.new(...) }.to be_overloaded
-              @limiter = res
-              res.overloaded?
-            else
-              # eg. expect { Berater(...)  }.to be_overloaded
-              # eg. expect { limiter.limit }.to be_overloaded
-              false
-            end
-          when Berater::Limiter
-            # eg. expect(Berater.new(...)).to be_overloaded
-            @limiter = obj
-            obj.overloaded?
+          if res.is_a? Berater::Limiter
+            # eg. expect { Berater.new(...) }.to be_overloaded
+            @limiter = res
+            res.overloaded?
+          else
+            # eg. expect { Berater(...)  }.to be_overloaded
+            # eg. expect { limiter.limit }.to be_overloaded
+            false
           end
-        rescue @type
-          true
+        when Berater::Limiter
+          # eg. expect(Berater.new(...)).to be_overloaded
+          @limiter = obj
+          obj.overloaded?
         end
+      rescue @type
+        true
       end
 
       def description

data/lib/berater/test_mode.rb

@@ -11,42 +11,33 @@ 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
+        # find class specific Overloaded error
+        e = self.class.constants.map do |name|
+          self.class.const_get(name)
+        end.find do |const|
+          const < Berater::Overloaded
+        end || Berater::Overloaded
+
+        raise e
+      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,16 +5,14 @@ module Berater
       super(key, Float::INFINITY, **opts)
     end
 
-    def limit(**opts, &block)
-      yield_lock(Lock.new(Float::INFINITY, 0), &block)
-    end
+    protected
 
-    def overloaded?
-      false
+    def capacity=(*)
+      @capacity = Float::INFINITY
     end
 
-    protected def capacity=(*)
-      @capacity = Float::INFINITY
+    def acquire_lock(*)
+      Lock.new(Float::INFINITY, 0)
     end
 
   end

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = '0.6.0'
+  VERSION = '0.6.1'
 end

data/spec/concurrency_limiter_spec.rb

@@ -124,6 +124,12 @@ describe Berater::ConcurrencyLimiter do
       expect(limiter).to be_incapacitated
     end
 
+    it 'accepts a dynamic capacity' do
+      expect { limiter.limit(capacity: 0) }.to be_incapacitated
+      5.times { limiter.limit(capacity: 10) }
+      expect { limiter }.to be_incapacitated
+    end
+
     context 'with cost parameter' do
       it { expect { limiter.limit(cost: 4) }.to be_incapacitated }
 
@@ -154,17 +160,21 @@ describe Berater::ConcurrencyLimiter do
         expect(limiter).to be_incapacitated
       end
 
-      it 'accepts a dynamic capacity' do
-        limiter = described_class.new(:key, 1)
-
-        expect { limiter.limit(capacity: 0) }.to be_incapacitated
-        5.times { limiter.limit(capacity: 10) }
-        expect { limiter }.to be_incapacitated
+      context 'with fractional costs' do
+        it 'rounds up' do
+          limiter.limit(cost: 1.5)
+          expect(limiter).to be_incapacitated
+        end
+
+        it 'accumulates correctly' do
+          limiter.limit(cost: 0.5) # => 1
+          limiter.limit(cost: 0.7) # => 2
+          expect(limiter).to be_incapacitated
+        end
       end
 
-      it 'only allows positive, Integer values' do
+      it 'only allows positive values' do
         expect { limiter.limit(cost: -1) }.to raise_error(ArgumentError)
-        expect { limiter.limit(cost: 1.5) }.to raise_error(ArgumentError)
       end
     end
 

data/spec/test_mode_spec.rb

@@ -1,31 +1,20 @@
-describe Berater::TestMode, order: :defined do
-  let(:reset_test_mode) { true }
-
+describe Berater::TestMode do
   after do
-    Berater.test_mode = nil if reset_test_mode
+    Berater.test_mode = nil
   end
 
-  context 'after test_mode.rb was required, but not used' do
-    let(:reset_test_mode) { false }
-
-    it 'has already been loaded by "berater/rspec", unfortunately' do
-      expect {
-        expect { Berater.test_mode }.to raise_error(NoMethodError)
-      }.to fail
+  context 'after test_mode.rb has been loaded' do
+    it 'monkey patches Berater' do
+      expect(Berater).to respond_to(:test_mode)
     end
 
     it 'defaults to off' do
       expect(Berater.test_mode).to be nil
     end
 
-    it 'did not prepend .new yet' do
-      expect(Berater::Limiter.singleton_class.ancestors).not_to include(described_class)
-    end
-
-    it 'prepends when first turned on' do
-      Berater.test_mode = :pass
-
-      expect(Berater::Limiter.singleton_class.ancestors).to include(described_class)
+    it 'prepends Limiter subclasses' do
+      expect(Berater::Unlimiter.ancestors).to include(described_class)
+      expect(Berater::Inhibitor.ancestors).to include(described_class)
     end
 
     it 'preserves the original functionality via super' do
@@ -50,6 +39,20 @@ describe Berater::TestMode, order: :defined do
     it 'validates input' do
       expect { Berater.test_mode = :foo }.to raise_error(ArgumentError)
     end
+
+    it 'works no matter when limiter was created' do
+      limiter = Berater::Unlimiter.new
+      expect(limiter).not_to be_overloaded
+
+      Berater.test_mode = :fail
+      expect(limiter).to be_overloaded
+    end
+
+    it 'supports a generic expectation' do
+      Berater.test_mode = :pass
+      expect_any_instance_of(Berater::Limiter).to receive(:limit)
+      Berater::Unlimiter.new.limit
+    end
   end
 
   shared_examples 'it always works, without redis' do
@@ -72,10 +75,6 @@ describe Berater::TestMode, order: :defined do
     end
 
     it_behaves_like 'it is overloaded'
-
-    it 'never works' do
-      expect { subject }.to be_overloaded
-    end
   end
 
   describe 'Unlimiter' do
@@ -100,6 +99,11 @@ describe Berater::TestMode, order: :defined do
 
       it { is_expected.to be_a Berater::Unlimiter }
       it_behaves_like 'it never works, without redis'
+
+      it 'supports class specific logic' do
+        expect(subject.overloaded?).to be true
+        expect { subject.limit }.to raise_error(Berater::Overloaded)
+      end
     end
   end
 
@@ -125,6 +129,11 @@ describe Berater::TestMode, order: :defined do
 
       it { is_expected.to be_a Berater::Inhibitor }
       it_behaves_like 'it never works, without redis'
+
+      it 'supports class specific logic' do
+        expect(subject.inhibited?).to be true
+        expect { subject.limit }.to raise_error(Berater::Inhibitor::Inhibited)
+      end
     end
   end
 
@@ -166,6 +175,11 @@ describe Berater::TestMode, order: :defined do
 
       it_behaves_like 'a RateLimiter'
       it_behaves_like 'it never works, without redis'
+
+      it 'supports class specific logic' do
+        expect(subject.overrated?).to be true
+        expect { subject.limit }.to raise_error(Berater::RateLimiter::Overrated)
+      end
     end
   end
 
@@ -200,6 +214,11 @@ describe Berater::TestMode, order: :defined do
       it { is_expected.to be_a Berater::ConcurrencyLimiter }
 
       it_behaves_like 'it never works, without redis'
+
+      it 'supports class specific logic' do
+        expect(subject.incapacitated?).to be true
+        expect { subject.limit }.to raise_error(Berater::ConcurrencyLimiter::Incapacitated)
+      end
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: berater
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-07 00:00:00.000000000 Z
+date: 2021-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis