berater 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c12ee8f042d6ebb193f114cd093585c14a4a28b802d7a90f79ba5ce41bbd82e6
-  data.tar.gz: d12ebb1107ea0b24208bfb3ff663a98097cd3367c3972418a139cae9b501e4a1
+  metadata.gz: c32c1de752ccc7a2a71e4628b99f3561db623374dabaf95af39aadcc3b1a2d16
+  data.tar.gz: 33019954de1d79522ed7105e9f0a7da3a204df74cacd25aa4b57e749a81047bb
 SHA512:
-  metadata.gz: 491cd616903af917866a41f8b2a4bcc79a469a879f57f1872ce8f4a42c00f1309979c04c142c0083246791aef6cd3847c21197dee0b611ff326ca833cc44ae52
-  data.tar.gz: 7ba3fd90f8b439e4ad2fe1d5a8008c69978a90c206bc6694e9f470796019d2ac849dddaa85039b9c730e3e20edfec3411cc1275598866c63207c209e688f2a3a
+  metadata.gz: 89460a9a81a8d384addb095c425da0eed4fdbe0e15ecd85ee97ffcf4292441deeb34c7e4cd4591adca06096a17f7c131b79c6474d9efb2b635fbe398ad68d00e
+  data.tar.gz: 0a331b939e4c19817c42a8aa8fc5be7fd59d63f6becd5fe6ed1c226690d1524ef040a28d8bcb625d75452ab2f5c8539ddf69093bbd30c4ba9e3353259a3e568d

data/lib/berater.rb

@@ -31,8 +31,10 @@ module Berater
       if opts[:interval]
         args << opts.delete(:interval)
         Berater::RateLimiter
-      else
+      elsif opts[:timeout]
         Berater::ConcurrencyLimiter
+      else
+        Berater::StaticLimiter
       end
     end.yield_self do |klass|
       args = [ key, capacity, *args ].compact
@@ -49,17 +51,13 @@ module Berater
 end
 
 # convenience method
-def Berater(key, capacity, **opts, &block)
-  limiter = Berater.new(key, capacity, **opts)
-  if block_given?
-    limiter.limit(&block)
-  else
-    limiter
-  end
+def Berater(*args, **opts, &block)
+  Berater::Utils.convenience_fn(Berater, *args, **opts, &block)
 end
 
 # load limiters
 require 'berater/concurrency_limiter'
 require 'berater/inhibitor'
 require 'berater/rate_limiter'
+require 'berater/static_limiter'
 require 'berater/unlimiter'

data/lib/berater/concurrency_limiter.rb

@@ -1,21 +1,22 @@
 module Berater
   class ConcurrencyLimiter < Limiter
 
-    attr_reader :timeout
-
     def initialize(key, capacity, **opts)
       super(key, capacity, **opts)
 
-      # round fractional capacity
+      # truncate fractional capacity
       self.capacity = capacity.to_i
 
       self.timeout = opts[:timeout] || 0
     end
 
+    def timeout
+      options[:timeout]
+    end
+
     private def timeout=(timeout)
-      @timeout = timeout
       timeout = 0 if timeout == Float::INFINITY
-      @timeout_msec = Berater::Utils.to_msec(timeout)
+      @timeout = Berater::Utils.to_msec(timeout)
     end
 
     LUA_SCRIPT = Berater::LuaScript(<<~LUA
@@ -72,24 +73,19 @@ module Berater
 
       count, *lock_ids = LUA_SCRIPT.eval(
         redis,
-        [ cache_key(key), cache_key('lock_id') ],
-        [ capacity, ts, @timeout_msec, cost ]
+        [ cache_key, self.class.cache_key('lock_id') ],
+        [ capacity, ts, @timeout, cost ]
       )
 
       raise Overloaded if lock_ids.empty?
 
       release_fn = if cost > 0
-        proc { release(lock_ids) }
+        proc { redis.zrem(cache_key, lock_ids) }
       end
 
       Lock.new(capacity, count, release_fn)
     end
 
-    private def release(lock_ids)
-      res = redis.zrem(cache_key(key), lock_ids)
-      res == true || res == lock_ids.count # depending on which version of Redis
-    end
-
     def to_s
       "#<#{self.class}(#{key}: #{capacity} at a time)>"
     end

data/lib/berater/inhibitor.rb

@@ -5,6 +5,10 @@ module Berater
       super(key, 0, **opts)
     end
 
+    def to_s
+      "#<#{self.class}>"
+    end
+
     protected def acquire_lock(*)
       raise Overloaded
     end

data/lib/berater/limiter.rb

@@ -43,10 +43,6 @@ module Berater
       1.0
     end
 
-    def to_s
-      "#<#{self.class}>"
-    end
-
     def ==(other)
       self.class == other.class &&
       self.key == other.key &&
@@ -92,8 +88,22 @@ module Berater
       raise NotImplementedError
     end
 
-    def cache_key(key)
-      "#{self.class}:#{key}"
+    def cache_key(subkey = nil)
+      instance_key = subkey.nil? ? key : "#{key}:#{subkey}"
+      self.class.cache_key(instance_key)
+    end
+
+    def self.cache_key(key)
+      klass = to_s.split(':')[-1]
+      "Berater:#{klass}:#{key}"
+    end
+
+    def self.inherited(subclass)
+      # automagically create convenience method
+      name = subclass.to_s.split(':')[-1]
+      Berater.define_singleton_method(name) do |*args, **opts, &block|
+        Berater::Utils.convenience_fn(subclass, *args, **opts, &block)
+      end
     end
 
   end

data/lib/berater/lock.rb

@@ -19,7 +19,8 @@ module Berater
       raise 'lock already released' unless locked?
 
       @released_at = Time.now
-      @release_fn ? @release_fn.call : true
+      @release_fn&.call
+      nil
     end
 
   end

data/lib/berater/rate_limiter.rb

@@ -1,18 +1,19 @@
 module Berater
   class RateLimiter < Limiter
 
-    attr_accessor :interval
-
     def initialize(key, capacity, interval, **opts)
+      super(key, capacity, interval, **opts)
       self.interval = interval
-      super(key, capacity, @interval_msec, **opts)
+    end
+
+    def interval
+      args[0]
     end
 
     private def interval=(interval)
-      @interval = interval
-      @interval_msec = Berater::Utils.to_msec(interval)
+      @interval = Berater::Utils.to_msec(interval)
 
-      unless @interval_msec > 0
+      unless @interval > 0
         raise ArgumentError, 'interval must be > 0'
       end
     end
@@ -76,8 +77,8 @@ module Berater
 
       count, allowed = LUA_SCRIPT.eval(
         redis,
-        [ cache_key(key) ],
-        [ ts, capacity, @interval_msec, cost ]
+        [ cache_key ],
+        [ ts, capacity, @interval, cost ]
       )
 
       count = count.include?('.') ? count.to_f : count.to_i

data/lib/berater/rspec.rb

@@ -8,7 +8,6 @@ RSpec.configure do |config|
 
   config.after do
     Berater.expunge rescue nil
-    Berater.redis.script(:flush) rescue nil
     Berater.reset
   end
 end

data/lib/berater/static_limiter.rb

@@ -0,0 +1,49 @@
+module Berater
+  class StaticLimiter < Limiter
+
+    LUA_SCRIPT = Berater::LuaScript(<<~LUA
+      local key = KEYS[1]
+      local capacity = tonumber(ARGV[1])
+      local cost = tonumber(ARGV[2])
+
+      local count = redis.call('GET', key) or 0
+      local allowed = (count + cost) <= capacity
+
+      if allowed then
+        count = count + cost
+        redis.call('SET', key, count)
+      end
+
+      return { tostring(count), allowed }
+    LUA
+    )
+
+    protected def acquire_lock(capacity, cost)
+      if cost == 0
+        # utilization check
+        count = redis.get(cache_key) || "0"
+        allowed = true
+      else
+        count, allowed = LUA_SCRIPT.eval(
+          redis, [ cache_key ], [ capacity, cost ],
+        )
+      end
+
+      # Redis returns Floats as strings to maintain precision
+      count = count.include?('.') ? count.to_f : count.to_i
+
+      raise Overloaded unless allowed
+
+      release_fn = if cost > 0
+        proc { redis.incrbyfloat(cache_key, -cost) }
+      end
+
+      Lock.new(capacity, count, release_fn)
+    end
+
+    def to_s
+      "#<#{self.class}(#{key}: #{capacity})>"
+    end
+
+  end
+end

data/lib/berater/test_mode.rb

@@ -1,36 +1,47 @@
 require 'berater'
 
 module Berater
-  extend self
 
-  attr_reader :test_mode
+  module TestMode
+    attr_reader :test_mode
+
+    def test_mode=(mode)
+      unless [ nil, :pass, :fail ].include?(mode)
+        raise ArgumentError, "invalid mode: #{Berater.test_mode}"
+      end
 
-  def test_mode=(mode)
-    unless [ nil, :pass, :fail ].include?(mode)
-      raise ArgumentError, "invalid mode: #{Berater.test_mode}"
+      @test_mode = mode
     end
 
-    @test_mode = mode
+    def reset
+      super
+      @test_mode = nil
+    end
   end
 
-  module TestMode
-    def acquire_lock(*)
-      case Berater.test_mode
-      when :pass
-        Lock.new(Float::INFINITY, 0)
-      when :fail
-        raise Overloaded
-      else
-        super
+  class Limiter
+    module TestMode
+      def acquire_lock(*)
+        case Berater.test_mode
+        when :pass
+          Lock.new(Float::INFINITY, 0)
+        when :fail
+          raise Overloaded
+        else
+          super
+        end
       end
     end
   end
 
 end
 
+# prepend class methods
+Berater.singleton_class.prepend Berater::TestMode
+
 # stub each Limiter subclass
 ObjectSpace.each_object(Class).each do |klass|
   next unless klass < Berater::Limiter
 
-  klass.prepend(Berater::TestMode)
+  klass.prepend Berater::Limiter::TestMode
 end

data/lib/berater/unlimiter.rb

@@ -5,6 +5,10 @@ module Berater
       super(key, Float::INFINITY, **opts)
     end
 
+    def to_s
+      "#<#{self.class}>"
+    end
+
     protected
 
     def capacity=(*)

data/lib/berater/utils.rb

@@ -42,5 +42,14 @@ module Berater
       (res * 10**3).to_i
     end
 
+    def convenience_fn(klass, *args, **opts, &block)
+      limiter = klass.new(*args, **opts)
+      if block_given?
+        limiter.limit(&block)
+      else
+        limiter
+      end
+    end
+
   end
 end

data/lib/berater/version.rb

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

data/spec/berater_spec.rb

@@ -24,50 +24,15 @@ describe Berater do
     end
   end
 
-  describe '.new' do
-    context 'Unlimiter mode' do
-      let(:limiter) { Berater.new(:key, Float::INFINITY) }
+  shared_examples 'a Berater' do |klass, capacity, **opts|
+    describe '.new' do
+      let(:limiter) { Berater.new(:key, capacity, **opts) }
 
-      it 'instantiates an Unlimiter' do
-        expect(limiter).to be_a Berater::Unlimiter
-        expect(limiter.key).to be :key
-      end
-
-      it 'inherits redis' do
-        expect(limiter.redis).to be Berater.redis
-      end
-
-      it 'accepts options' do
-        redis = double('Redis')
-        limiter = Berater.new(:key, Float::INFINITY, redis: redis)
-        expect(limiter.redis).to be redis
-      end
-    end
-
-    context 'Inhibitor mode' do
-      let(:limiter) { Berater.new(:key, 0) }
-
-      it 'instantiates an Inhibitor' do
-        expect(limiter).to be_a Berater::Inhibitor
-        expect(limiter.key).to be :key
-      end
-
-      it 'inherits redis' do
-        expect(limiter.redis).to be Berater.redis
-      end
-
-      it 'accepts options' do
-        redis = double('Redis')
-        limiter = Berater.new(:key, 0, redis: redis)
-        expect(limiter.redis).to be redis
+      it 'instantiates the right class' do
+        expect(limiter).to be_a klass
       end
-    end
 
-    context 'rate mode' do
-      let(:limiter) { Berater.new(:key, 1, interval: :second) }
-
-      it 'instantiates a RateLimiter' do
-        expect(limiter).to be_a Berater::RateLimiter
+      it 'sets the key' do
         expect(limiter.key).to be :key
       end
 
@@ -75,60 +40,45 @@ describe Berater do
         expect(limiter.redis).to be Berater.redis
       end
 
-      it 'accepts options' do
+      it 'accepts an optional redis parameter' do
         redis = double('Redis')
-        limiter = Berater.new(:key, 1, interval: :second, redis: redis)
+        limiter = Berater.new(:key, capacity, opts.merge(redis: redis))
         expect(limiter.redis).to be redis
       end
     end
 
-    context 'concurrency mode' do
-      let(:limiter) { Berater.new(:key, 1) }
+    describe 'Berater() convenience method' do
+      let(:limiter) { Berater(:key, capacity, **opts) }
 
-      it 'instantiates a ConcurrencyLimiter' do
-        expect(limiter).to be_a Berater::ConcurrencyLimiter
-        expect(limiter.key).to be :key
+      it 'creates a limiter' do
+        expect(limiter).to be_a klass
       end
 
-      it 'inherits redis' do
-        expect(limiter.redis).to be Berater.redis
+      it 'creates an equivalent limiter' do
+        expect(limiter).to eq Berater.new(:key, capacity, **opts)
       end
 
-      it 'accepts options' do
-        redis = double('Redis')
-        limiter = Berater.new(:key, 1, redis: redis)
-        expect(limiter.redis).to be redis
-      end
-    end
-  end
+      context 'with a block' do
+        before { Berater.test_mode = :pass }
 
-  describe 'Berater() - convenience method' do
-    RSpec.shared_examples 'test convenience' do |klass, capacity, **opts|
-      it 'creates a limiter' do
-        limiter = Berater(:key, capacity, **opts)
-        expect(limiter).to be_a klass
-      end
+        subject { Berater(:key, capacity, **opts) { 123 } }
 
-      context 'with a block' do
         it 'creates a limiter and calls limit' do
-          limiter = Berater(:key, capacity, **opts)
           expect(klass).to receive(:new).and_return(limiter)
           expect(limiter).to receive(:limit).and_call_original
+          subject
+        end
 
-          begin
-            res = Berater(:key, capacity, **opts) { true }
-            expect(res).to be true
-          rescue Berater::Overloaded
-            expect(klass).to be Berater::Inhibitor
-          end
+        it 'yields' do
+          is_expected.to be 123
         end
       end
     end
-
-    include_examples 'test convenience', Berater::Unlimiter, Float::INFINITY
-    include_examples 'test convenience', Berater::Inhibitor, 0
-    include_examples 'test convenience', Berater::RateLimiter, 1, interval: :second
-    include_examples 'test convenience', Berater::ConcurrencyLimiter, 1
   end
 
+  include_examples 'a Berater', Berater::ConcurrencyLimiter, 1, timeout: 1
+  include_examples 'a Berater', Berater::Inhibitor, 0
+  include_examples 'a Berater', Berater::RateLimiter, 1, interval: :second
+  include_examples 'a Berater', Berater::StaticLimiter, 1
+  include_examples 'a Berater', Berater::Unlimiter, Float::INFINITY
 end

data/spec/concurrency_limiter_spec.rb

@@ -36,22 +36,28 @@ describe Berater::ConcurrencyLimiter do
       it { expect_bad_capacity(-1) }
       it { expect_bad_capacity('1') }
       it { expect_bad_capacity(:one) }
+      it { expect_bad_capacity(Float::INFINITY) }
     end
   end
 
   describe '#timeout' do
     # see spec/utils_spec.rb
 
+    it 'defaults to nil' do
+      limiter = described_class.new(:key, 1)
+      expect(limiter.timeout).to be nil
+    end
+
     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_msec)).to be (3 * 10**3)
+      expect(limiter.instance_variable_get(:@timeout)).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_msec)).to be 0
+      expect(limiter.instance_variable_get(:@timeout)).to be 0
     end
   end
 

data/spec/inhibitor_spec.rb

@@ -1,7 +1,9 @@
 describe Berater::Inhibitor do
+  subject { described_class.new }
+
   describe '.new' do
     it 'initializes without any arguments or options' do
-      expect(described_class.new).to be_a described_class
+      is_expected.to be_a described_class
     end
 
     it 'initializes with any arguments and options' do
@@ -9,15 +11,18 @@ describe Berater::Inhibitor do
     end
 
     it 'has default values' do
-      expect(described_class.new.key).to be :inhibitor
-      expect(described_class.new.redis).to be Berater.redis
+      expect(subject.key).to be :inhibitor
+      expect(subject.redis).to be Berater.redis
     end
   end
 
   describe '#limit' do
-    subject { described_class.new }
-
     it_behaves_like 'it is overloaded'
   end
 
+  describe '#to_s' do
+    it do
+      expect(subject.to_s).to include described_class.to_s
+    end
+  end
 end

data/spec/limiter_spec.rb

@@ -44,6 +44,10 @@ describe Berater::Limiter do
         expect {
           subject.limit(cost: -1)
         }.to raise_error(ArgumentError)
+
+        expect {
+          subject.limit(cost: Float::INFINITY)
+        }.to raise_error(ArgumentError)
       end
     end
   end
@@ -61,12 +65,6 @@ describe Berater::Limiter do
       )
     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)
@@ -104,4 +102,56 @@ describe Berater::Limiter do
     end
   end
 
+  describe '#cache_key' do
+    subject { klass.new(:key).send(:cache_key) }
+
+    context 'with Unlimiter' do
+      let(:klass) { Berater::Unlimiter }
+
+      it do
+        is_expected.to eq 'Berater:Unlimiter:key'
+      end
+    end
+
+    context 'with custom limiter' do
+      MyLimiter = Class.new(Berater::Unlimiter)
+
+      let(:klass) { MyLimiter }
+
+      it 'adds Berater prefix' do
+        is_expected.to eq 'Berater:MyLimiter:key'
+      end
+    end
+  end
+
+  describe '.cache_key' do
+    subject { klass.send(:cache_key, :key) }
+
+    context 'with Unlimiter' do
+      let(:klass) { Berater::Unlimiter }
+
+      it do
+        is_expected.to eq 'Berater:Unlimiter:key'
+      end
+    end
+
+    context 'with custom limiter' do
+      MyLimiter = Class.new(Berater::Unlimiter)
+
+      let(:klass) { MyLimiter }
+
+      it 'adds Berater prefix' do
+        is_expected.to eq 'Berater:MyLimiter:key'
+      end
+    end
+  end
+
+  describe '.inherited' do
+    it 'creates convenience methods' do
+      expect(Berater.method(:Unlimiter)).to be_a Method
+      expect(Berater::Unlimiter()).to be_a Berater::Unlimiter
+      expect {|b| Berater::Unlimiter(&b) }.to yield_control
+    end
+  end
+
 end

data/spec/rate_limiter_spec.rb

@@ -37,6 +37,7 @@ describe Berater::RateLimiter do
       it { expect_bad_capacity(-1) }
       it { expect_bad_capacity('1') }
       it { expect_bad_capacity(:one) }
+      it { expect_bad_capacity(Float::INFINITY) }
     end
   end
 
@@ -47,7 +48,7 @@ describe Berater::RateLimiter do
 
     it 'saves the interval in original and millisecond format' do
       expect(subject.interval).to be :second
-      expect(subject.instance_variable_get(:@interval_msec)).to be 10**3
+      expect(subject.instance_variable_get(:@interval)).to be 10**3
     end
 
     it 'must be > 0' do

data/spec/riddle_spec.rb

@@ -47,7 +47,7 @@ class ConcurrenyRiddler
   ensure
     # decrement counter
     if lock
-      key = limiter.send(:cache_key, :key)
+      key = limiter.send(:cache_key)
       count, ts = limiter.redis.get(key).split ';'
       limiter.redis.set(key, "#{count.to_f - 1};#{ts}")
     end

data/spec/static_limiter_spec.rb

@@ -0,0 +1,79 @@
+describe Berater::StaticLimiter do
+  it_behaves_like 'a limiter', described_class.new(:key, 3)
+  it_behaves_like 'a limiter', described_class.new(:key, 3.5)
+
+  describe '#limit' do
+    let(:limiter) { described_class.new(:key, 3) }
+
+    it 'limits excessive calls' do
+      3.times { limiter.limit }
+
+      expect(limiter).to be_overloaded
+    end
+
+    context 'when capacity is a Float' do
+      let(:limiter) { described_class.new(:key, 1.5) }
+
+      it 'still works' do
+        limiter.limit
+        expect(limiter).not_to be_overloaded
+
+        expect { limiter.limit }.to be_overloaded
+
+        limiter.limit(cost: 0.5)
+      end
+    end
+
+    it 'accepts a dynamic capacity' do
+      limiter = described_class.new(:key, 1)
+
+      expect { limiter.limit(capacity: 0) }.to be_overloaded
+      5.times { limiter.limit(capacity: 10) }
+      expect { limiter }.to be_overloaded
+    end
+
+    context 'works with cost parameter' do
+      let(:limiter) { described_class.new(:key, 3) }
+
+      it { expect { limiter.limit(cost: 4) }.to be_overloaded }
+
+      it 'works within limit' do
+        limiter.limit(cost: 3)
+        expect { limiter.limit }.to be_overloaded
+      end
+
+      context 'when cost is a Float' do
+        it 'still works' do
+          2.times { limiter.limit(cost: 1.5) }
+          expect(limiter).to be_overloaded
+        end
+
+        it 'calculates contention correctly' do
+          lock = limiter.limit(cost: 1.5)
+          expect(lock.contention).to be 1.5
+        end
+      end
+    end
+  end
+
+  describe '#utilization' do
+    let(:limiter) { described_class.new(:key, 10) }
+
+    it do
+      expect(limiter.utilization).to be 0.0
+
+      2.times { limiter.limit }
+      expect(limiter.utilization).to be 0.2
+
+      8.times { limiter.limit }
+      expect(limiter.utilization).to be 1.0
+    end
+  end
+
+  describe '#to_s' do
+    let(:limiter) { described_class.new(:key, 3) }
+
+    it { expect(limiter.to_s).to include '3' }
+  end
+
+end

data/spec/test_mode_spec.rb

@@ -1,8 +1,4 @@
 describe Berater::TestMode do
-  after do
-    Berater.test_mode = nil
-  end
-
   context 'after test_mode.rb has been loaded' do
     it 'monkey patches Berater' do
       expect(Berater).to respond_to(:test_mode)
@@ -13,8 +9,8 @@ describe Berater::TestMode do
     end
 
     it 'prepends Limiter subclasses' do
-      expect(Berater::Unlimiter.ancestors).to include(described_class)
-      expect(Berater::Inhibitor.ancestors).to include(described_class)
+      expect(Berater::Unlimiter.ancestors).to include(Berater::Limiter::TestMode)
+      expect(Berater::Inhibitor.ancestors).to include(Berater::Limiter::TestMode)
     end
 
     it 'preserves the original functionality via super' do
@@ -55,6 +51,16 @@ describe Berater::TestMode do
     end
   end
 
+  describe '.reset' do
+    before { Berater.test_mode = :pass }
+
+    it 'resets test_mode' do
+      expect(Berater.test_mode).to be :pass
+      Berater.reset
+      expect(Berater.test_mode).to be nil
+    end
+  end
+
   shared_examples 'it supports test_mode' do
     before do
       # without hitting Redis

data/spec/unlimiter_spec.rb

@@ -1,9 +1,11 @@
 describe Berater::Unlimiter do
+  subject { described_class.new }
+
   it_behaves_like 'a limiter', described_class.new
 
   describe '.new' do
     it 'initializes without any arguments or options' do
-      expect(described_class.new).to be_a described_class
+      is_expected.to be_a described_class
     end
 
     it 'initializes with any arguments and options' do
@@ -11,14 +13,12 @@ describe Berater::Unlimiter do
     end
 
     it 'has default values' do
-      expect(described_class.new.key).to be :unlimiter
-      expect(described_class.new.redis).to be Berater.redis
+      expect(subject.key).to be :unlimiter
+      expect(subject.redis).to be Berater.redis
     end
   end
 
   describe '#limit' do
-    subject { described_class.new }
-
     it_behaves_like 'it is not overloaded'
 
     it 'is never overloaded' do
@@ -27,4 +27,10 @@ describe Berater::Unlimiter do
       end
     end
   end
+
+  describe '#to_s' do
+    it do
+      expect(subject.to_s).to include described_class.to_s
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: berater
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-15 00:00:00.000000000 Z
+date: 2021-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -138,6 +138,7 @@ files:
 - lib/berater/rate_limiter.rb
 - lib/berater/rspec.rb
 - lib/berater/rspec/matchers.rb
+- lib/berater/static_limiter.rb
 - lib/berater/test_mode.rb
 - lib/berater/unlimiter.rb
 - lib/berater/utils.rb
@@ -152,6 +153,7 @@ files:
 - spec/matchers_spec.rb
 - spec/rate_limiter_spec.rb
 - spec/riddle_spec.rb
+- spec/static_limiter_spec.rb
 - spec/test_mode_spec.rb
 - spec/unlimiter_spec.rb
 - spec/utils_spec.rb
@@ -190,5 +192,6 @@ test_files:
 - spec/utils_spec.rb
 - spec/berater_spec.rb
 - spec/limiter_spec.rb
+- spec/static_limiter_spec.rb
 - spec/inhibitor_spec.rb
 - spec/unlimiter_spec.rb