berater 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dec8c5d6d428f795d1489dace166451e2a3a42592d00d71155ed5cd0d5aaa909
-  data.tar.gz: 6956b6c2804b6d616074e239439d4f2a8e551e900db7801226948b9eb764d0fc
+  metadata.gz: d007dbb664fa57c921047a28dd1e5a591cf5c51fba4931dbc367ab552e4b8a8d
+  data.tar.gz: c710d31a2d8cfdc50af4c2fae87cabad177096d13da52a7f9c48b61aa31b6038
 SHA512:
-  metadata.gz: 327cd2f3a7430c2b81bd1988abd636bfc7d97048c762d3807555e9c1196153570dbe3045fae813852a907ec00b89b8d2c36e9269ed0562419c8d98dd6c1d2b26
-  data.tar.gz: ea1cb39e9201091e4a1357e888ac36f630c326a271e3cfcafa13298b8f54424f776f4dd488e046e2178905d0df9fb5c3b1f0d454e331823cafe5dd338fe9ea6c
+  metadata.gz: 0d9c211bb65e7341b98e637d3f0ce0e31f0a879437c1c309fb01e1efab5e5c6b2d5044158931ab16a67cbbdebd00ddb5f10afc97430230b153d8cc236f7517ab
+  data.tar.gz: 5d8b38bfd7683df641fd6891cd1a493079453ea6c61b2880581eeb2d963fb171365fb3448443e2548b34297d8dcfa352e67cff5688cd24d25422efb5e55d4afd

data/lib/berater.rb

@@ -15,7 +15,23 @@ module Berater
     yield self
   end
 
-  def new(key, mode, *args, **opts)
+  def new(key, mode = nil, *args, **opts, &block)
+    if mode.nil?
+      unless args.empty?
+        raise ArgumentError, '0 arguments expected with block'
+      end
+
+      unless block_given?
+        raise ArgumentError, 'expected either mode or block'
+      end
+
+      mode, *args = DSL.eval(&block)
+    else
+      if block_given?
+        raise ArgumentError, 'expected either mode or block, not both'
+      end
+    end
+
     klass = MODES[mode.to_sym]
 
     unless klass
@@ -42,8 +58,8 @@ def Berater(key, mode, *args, **opts, &block)
   Berater.new(key, mode, *args, **opts).limit(&block)
 end
 
-# load and register limiters
-require 'berater/base_limiter'
+# load limiters
+require 'berater/limiter'
 require 'berater/concurrency_limiter'
 require 'berater/inhibitor'
 require 'berater/rate_limiter'
@@ -53,3 +69,5 @@ Berater.register(:concurrency, Berater::ConcurrencyLimiter)
 Berater.register(:inhibited, Berater::Inhibitor)
 Berater.register(:rate, Berater::RateLimiter)
 Berater.register(:unlimited, Berater::Unlimiter)
+
+require 'berater/dsl'

data/lib/berater/concurrency_limiter.rb

@@ -1,5 +1,5 @@
 module Berater
-  class ConcurrencyLimiter < BaseLimiter
+  class ConcurrencyLimiter < Limiter
 
     class Incapacitated < Overloaded; end
 
@@ -85,5 +85,9 @@ module Berater
       res == true || res == 1 # depending on which version of Redis
     end
 
+    def to_s
+      "#<#{self.class}(#{key}: #{capacity} at a time)>"
+    end
+
   end
 end

data/lib/berater/dsl.rb

@@ -0,0 +1,57 @@
+module Berater
+  module DSL
+    extend self
+
+    def eval &block
+      @keywords ||= Class.new do
+        # create a class where DSL keywords are methods
+        KEYWORDS.each do |keyword|
+          define_singleton_method(keyword) { keyword }
+        end
+      end
+
+      install
+      @keywords.class_eval &block
+    ensure
+      uninstall
+    end
+
+    private
+
+    def each &block
+      Berater::MODES.map do |mode, limiter|
+        next unless limiter.const_defined?(:DSL, false)
+        limiter.const_get(:DSL)
+      end.compact.each(&block)
+    end
+
+    KEYWORDS = [
+      :second, :minute, :hour,
+      :unlimited, :inhibited,
+    ].freeze
+
+    def install
+      Integer.class_eval do
+        def per(unit)
+          [ :rate, self, unit ]
+        end
+        alias every per
+
+        def at_once
+          [ :concurrency, self ]
+        end
+        alias concurrently at_once
+        alias at_a_time at_once
+      end
+    end
+
+    def uninstall
+      Integer.remove_method :per
+      Integer.remove_method :every
+
+      Integer.remove_method :at_once
+      Integer.remove_method :concurrently
+      Integer.remove_method :at_a_time
+    end
+  end
+end

data/lib/berater/inhibitor.rb

@@ -1,5 +1,5 @@
 module Berater
-  class Inhibitor < BaseLimiter
+  class Inhibitor < Limiter
 
     class Inhibited < Overloaded; end
 

data/lib/berater/{base_limiter.rb → limiter.rb}

@@ -1,5 +1,5 @@
 module Berater
-  class BaseLimiter
+  class Limiter
 
     attr_reader :key, :options
 
@@ -11,6 +11,10 @@ module Berater
       raise NotImplementedError
     end
 
+    def to_s
+      "#<#{self.class}>"
+    end
+
     protected
 
     def initialize(key, **opts)

data/lib/berater/lock.rb

@@ -17,7 +17,7 @@ module Berater
     end
 
     def expired?
-      timeout > 0 && @locked_at + timeout < Time.now
+      timeout ? @locked_at + timeout < Time.now : false
     end
 
     def release
@@ -28,8 +28,8 @@ module Berater
       @release_fn ? @release_fn.call : true
     end
 
-    private def timeout
-      limiter.respond_to?(:timeout) ? limiter.timeout : 0
+    def timeout
+      limiter.respond_to?(:timeout) ? limiter.timeout : nil
     end
 
   end

data/lib/berater/rate_limiter.rb

@@ -1,5 +1,5 @@
 module Berater
-  class RateLimiter < BaseLimiter
+  class RateLimiter < Limiter
 
     class Overrated < Overloaded; end
 
@@ -28,6 +28,7 @@ module Berater
       case @interval
       when Integer
         raise ArgumentError, "interval must be >= 0" unless @interval >= 0
+        @interval_sec = @interval
       when String
         @interval = @interval.to_sym
       when Symbol
@@ -38,28 +39,29 @@ module Berater
       if @interval.is_a? Symbol
         case @interval
         when :sec, :second, :seconds
-          @interval = 1
+          @interval = :second
+          @interval_sec = 1
         when :min, :minute, :minutes
-          @interval = 60
+          @interval = :minute
+          @interval_sec = 60
         when :hour, :hours
-          @interval = 60 * 60
+          @interval = :hour
+          @interval_sec = 60 * 60
         else
           raise ArgumentError, "unexpected interval value: #{interval}"
         end
       end
-
-      @interval
     end
 
     def limit
       ts = Time.now.to_i
 
       # bucket into time slot
-      rkey = "%s:%d" % [ cache_key(key), ts - ts % @interval ]
+      rkey = "%s:%d" % [ cache_key(key), ts - ts % @interval_sec ]
 
       count, _ = redis.multi do
         redis.incr rkey
-        redis.expire rkey, @interval * 2
+        redis.expire rkey, @interval_sec * 2
       end
 
       raise Overrated if count > @count
@@ -77,6 +79,20 @@ module Berater
       end
     end
 
+    def to_s
+      msg = if @interval.is_a? Integer
+        if @interval == 1
+          "every second"
+        else
+          "every #{@interval} seconds"
+        end
+      else
+        "per #{@interval}"
+      end
+
+      "#<#{self.class}(#{key}: #{count} #{msg})>"
+    end
+
   end
 end
 

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,13 +1,12 @@
 module Berater
-  class Unlimiter < BaseLimiter
+  class Unlimiter < Limiter
 
     def initialize(key = :unlimiter, *args, **opts)
       super(key, **opts)
     end
 
     def limit
-      count = redis.incr(cache_key('count'))
-      lock = Lock.new(self, count, count)
+      lock = Lock.new(self, 0, 0)
 
       if block_given?
         begin

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/spec/berater_spec.rb

@@ -120,6 +120,52 @@ describe Berater do
         expect {|b| Berater(:key, :concurrency, 1, &b) }.to yield_control
       end
     end
+
+    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 'instatiates an Inhibiter' do
+        limiter = Berater.new(:key) { inhibited }
+        expect(limiter).to be_a Berater::Inhibitor
+        expect(limiter.key).to be :key
+      end
+
+      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 '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
+
+      it 'requires either mode or dsl block' do
+        expect {
+          Berater.new(:key)
+        }.to raise_error(ArgumentError)
+      end
+    end
   end
 
 end

data/spec/concurrency_limiter_spec.rb

@@ -1,4 +1,7 @@
 describe Berater::ConcurrencyLimiter do
+  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(:key, 1) }
 
@@ -61,7 +64,7 @@ describe Berater::ConcurrencyLimiter do
   end
 
   describe '#limit' do
-    let(:limiter) { described_class.new(:key, 2, timeout: 1) }
+    let(:limiter) { described_class.new(:key, 2) }
 
     it 'works' do
       expect {|b| limiter.limit(&b) }.to yield_control
@@ -85,18 +88,6 @@ describe Berater::ConcurrencyLimiter do
       expect(limiter).to be_incapacitated
     end
 
-    it 'times out locks' do
-      expect(limiter.limit).to be_a Berater::Lock
-      expect(limiter.limit).to be_a Berater::Lock
-      expect(limiter).to be_incapacitated
-
-      Timecop.travel(1)
-
-      expect(limiter.limit).to be_a Berater::Lock
-      expect(limiter.limit).to be_a Berater::Lock
-      expect(limiter).to be_incapacitated
-    end
-
     context 'with capacity 0' do
       let(:limiter) { described_class.new(:key, 0) }
 
@@ -171,4 +162,17 @@ describe Berater::ConcurrencyLimiter do
     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
+
 end

data/spec/rate_limiter_spec.rb

@@ -1,4 +1,5 @@
 describe Berater::RateLimiter do
+  it_behaves_like 'a limiter', Berater.new(:key, :rate, 3, :second)
 
   describe '.new' do
     let(:limiter) { described_class.new(:key, 1, :second) }
@@ -6,7 +7,7 @@ describe Berater::RateLimiter do
     it 'initializes' do
       expect(limiter.key).to be :key
       expect(limiter.count).to eq 1
-      expect(limiter.interval).to eq 1
+      expect(limiter.interval).to eq :second
     end
 
     it 'has default values' do
@@ -51,22 +52,22 @@ describe Berater::RateLimiter do
     end
 
     context 'with symbols' do
-      it { expect_interval(:sec, 1) }
-      it { expect_interval(:second, 1) }
-      it { expect_interval(:seconds, 1) }
+      it { expect_interval(:sec, :second) }
+      it { expect_interval(:second, :second) }
+      it { expect_interval(:seconds, :second) }
 
-      it { expect_interval(:min, 60) }
-      it { expect_interval(:minute, 60) }
-      it { expect_interval(:minutes, 60) }
+      it { expect_interval(:min, :minute) }
+      it { expect_interval(:minute, :minute) }
+      it { expect_interval(:minutes, :minute) }
 
-      it { expect_interval(:hour, 3600) }
-      it { expect_interval(:hours, 3600) }
+      it { expect_interval(:hour, :hour) }
+      it { expect_interval(:hours, :hour) }
     end
 
     context 'with strings' do
-      it { expect_interval('sec', 1) }
-      it { expect_interval('minute', 60) }
-      it { expect_interval('hours', 3600) }
+      it { expect_interval('sec', :second) }
+      it { expect_interval('minute', :minute) }
+      it { expect_interval('hours', :hour) }
     end
 
     context 'with erroneous values' do
@@ -80,6 +81,17 @@ describe Berater::RateLimiter do
       it { expect_bad_interval(:secondz) }
       it { expect_bad_interval('huor') }
     end
+
+    context 'interprets values' do
+      def expect_sec(interval, expected)
+        limiter = described_class.new(:key, 1, interval)
+        expect(limiter.instance_variable_get(:@interval_sec)).to eq expected
+      end
+
+      it { expect_sec(:second, 1) }
+      it { expect_sec(:minute, 60) }
+      it { expect_sec(:hour, 3600) }
+    end
   end
 
   describe '#limit' do
@@ -140,4 +152,40 @@ describe Berater::RateLimiter do
     end
   end
 
+  describe '#to_s' do
+    def check(count, interval, expected)
+      expect(
+        described_class.new(:key, count, interval).to_s
+      ).to match(expected)
+    end
+
+    it 'works with symbols' do
+      check(1, :second, /1 per second/)
+      check(1, :minute, /1 per minute/)
+      check(1, :hour, /1 per hour/)
+    end
+
+    it 'works with strings' do
+      check(1, 'second', /1 per second/)
+      check(1, 'minute', /1 per minute/)
+      check(1, 'hour', /1 per hour/)
+    end
+
+    it 'normalizes' do
+      check(1, :sec, /1 per second/)
+      check(1, :seconds, /1 per second/)
+
+      check(1, :min, /1 per minute/)
+      check(1, :minutes, /1 per minute/)
+
+      check(1, :hours, /1 per hour/)
+    end
+
+    it 'works with integers' do
+      check(1, 1, /1 every second/)
+      check(1, 2, /1 every 2 seconds/)
+      check(2, 3, /2 every 3 seconds/)
+    end
+  end
+
 end

data/spec/test_mode_spec.rb

@@ -0,0 +1,183 @@
+require 'berater/test_mode'
+
+describe 'Berater.test_mode' do
+  after { Berater.test_mode = nil }
+
+  describe 'Unlimiter' do
+    let(:limiter) { Berater::Unlimiter.new }
+
+    context 'when test_mode = nil' do
+      before { Berater.test_mode = nil }
+
+      it { expect(limiter).to be_a Berater::Unlimiter }
+
+      it 'works per usual' do
+        expect {|block| limiter.limit(&block) }.to yield_control
+        10.times { expect(limiter.limit).to be_a Berater::Lock }
+      end
+    end
+
+    context 'when test_mode = :pass' do
+      before { Berater.test_mode = :pass }
+
+      it { expect(limiter).to be_a Berater::Unlimiter }
+
+      it 'always works' do
+        expect {|block| limiter.limit(&block) }.to yield_control
+        10.times { expect(limiter.limit).to be_a Berater::Lock }
+      end
+    end
+
+    context 'when test_mode = :fail' do
+      before { Berater.test_mode = :fail }
+
+      it { expect(limiter).to be_a Berater::Unlimiter }
+
+      it 'never works' do
+        expect { limiter }.to be_overloaded
+      end
+    end
+  end
+
+  describe 'Inhibitor' do
+    let(:limiter) { Berater::Inhibitor.new }
+
+    context 'when test_mode = nil' do
+      before { Berater.test_mode = nil }
+
+      it { expect(limiter).to be_a Berater::Inhibitor }
+
+      it 'works per usual' do
+        expect { limiter }.to be_overloaded
+      end
+    end
+
+    context 'when test_mode = :pass' do
+      before { Berater.test_mode = :pass }
+
+      it { expect(limiter).to be_a Berater::Inhibitor }
+
+      it 'always works' do
+        expect {|block| limiter.limit(&block) }.to yield_control
+        10.times { expect(limiter.limit).to be_a Berater::Lock }
+      end
+    end
+
+    context 'when test_mode = :fail' do
+      before { Berater.test_mode = :fail }
+
+      it { expect(limiter).to be_a Berater::Inhibitor }
+
+      it 'never works' do
+        expect { limiter }.to be_overloaded
+      end
+    end
+  end
+
+  describe 'RateLimiter' do
+    let(:limiter) { Berater::RateLimiter.new(:key, 1, :second) }
+
+    shared_examples 'a RateLimiter' do
+      it { expect(limiter).to be_a Berater::RateLimiter }
+
+      it 'checks arguments' do
+        expect {
+          Berater::RateLimiter.new(:key, 1)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when test_mode = nil' do
+      before { Berater.test_mode = nil }
+
+      it_behaves_like 'a RateLimiter'
+
+      it 'works per usual' do
+        expect(limiter.redis).to receive(:multi).twice.and_call_original
+        expect(limiter.limit).to be_a Berater::Lock
+        expect { limiter.limit }.to be_overloaded
+      end
+
+      it 'yields per usual' do
+        expect {|block| limiter.limit(&block) }.to yield_control
+      end
+    end
+
+    context 'when test_mode = :pass' do
+      before { Berater.test_mode = :pass }
+
+      it_behaves_like 'a RateLimiter'
+
+      it 'always works and without calling redis' do
+        expect(limiter.redis).not_to receive(:multi)
+        expect {|block| limiter.limit(&block) }.to yield_control
+        10.times { expect(limiter.limit).to be_a Berater::Lock }
+      end
+    end
+
+    context 'when test_mode = :fail' do
+      before { Berater.test_mode = :fail }
+
+      it_behaves_like 'a RateLimiter'
+
+      it 'never works and without calling redis' do
+        expect(limiter.redis).not_to receive(:multi)
+        expect { limiter }.to be_overloaded
+      end
+    end
+  end
+
+  describe 'ConcurrencyLimiter' do
+    let(:limiter) { Berater::ConcurrencyLimiter.new(:key, 1) }
+
+    shared_examples 'a ConcurrencyLimiter' do
+      it { expect(limiter).to be_a Berater::ConcurrencyLimiter }
+
+      it 'checks arguments' do
+        expect {
+          Berater::ConcurrencyLimiter.new(:key, 1.0)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when test_mode = nil' do
+      before { Berater.test_mode = nil }
+
+      it_behaves_like 'a ConcurrencyLimiter'
+
+      it 'works per usual' do
+        expect(limiter.redis).to receive(:eval).twice.and_call_original
+        expect(limiter.limit).to be_a Berater::Lock
+        expect { limiter.limit }.to be_overloaded
+      end
+
+      it 'yields per usual' do
+        expect {|block| limiter.limit(&block) }.to yield_control
+      end
+    end
+
+    context 'when test_mode = :pass' do
+      before { Berater.test_mode = :pass }
+
+      it_behaves_like 'a ConcurrencyLimiter'
+
+      it 'always works and without calling redis' do
+        expect(limiter.redis).not_to receive(:eval)
+        expect {|block| limiter.limit(&block) }.to yield_control
+        10.times { expect(limiter.limit).to be_a Berater::Lock }
+      end
+    end
+
+    context 'when test_mode = :fail' do
+      before { Berater.test_mode = :fail }
+
+      it_behaves_like 'a ConcurrencyLimiter'
+
+      it 'never works and without calling redis' do
+        expect(limiter.redis).not_to receive(:eval)
+        expect { limiter }.to be_overloaded
+      end
+    end
+  end
+
+end

data/spec/unlimiter_spec.rb

@@ -1,4 +1,6 @@
 describe Berater::Unlimiter do
+  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
@@ -31,7 +33,4 @@ describe Berater::Unlimiter do
       end
     end
   end
-
-  it_behaves_like 'a lock', described_class.new
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: berater
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-16 00:00:00.000000000 Z
+date: 2021-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -115,20 +115,23 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/berater.rb
-- lib/berater/base_limiter.rb
 - lib/berater/concurrency_limiter.rb
+- lib/berater/dsl.rb
 - lib/berater/inhibitor.rb
+- lib/berater/limiter.rb
 - lib/berater/lock.rb
 - lib/berater/rate_limiter.rb
+- lib/berater/rspec.rb
+- lib/berater/rspec/matchers.rb
+- lib/berater/test_mode.rb
 - lib/berater/unlimiter.rb
 - lib/berater/version.rb
 - spec/berater_spec.rb
 - spec/concurrency_limiter_spec.rb
-- spec/concurrency_lock_spec.rb
 - spec/inhibitor_spec.rb
-- spec/matcher_spec.rb
+- spec/matchers_spec.rb
 - spec/rate_limiter_spec.rb
-- spec/rate_lock_spec.rb
+- spec/test_mode_spec.rb
 - spec/unlimiter_spec.rb
 homepage: https://github.com/dpep/berater_rb
 licenses:
@@ -155,10 +158,9 @@ specification_version: 4
 summary: Berater
 test_files:
 - spec/rate_limiter_spec.rb
-- spec/matcher_spec.rb
-- spec/rate_lock_spec.rb
+- spec/matchers_spec.rb
+- spec/test_mode_spec.rb
 - spec/concurrency_limiter_spec.rb
-- spec/concurrency_lock_spec.rb
 - spec/berater_spec.rb
 - spec/inhibitor_spec.rb
 - spec/unlimiter_spec.rb

data/spec/concurrency_lock_spec.rb

@@ -1,39 +0,0 @@
-describe Berater::Lock do
-  it_behaves_like 'a lock', Berater.new(:key, :concurrency, 3)
-
-  let(:limiter) { Berater.new(:key, :concurrency, 3) }
-
-  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.locked?).to be true
-        expect(lock.expired?).to be false
-
-        Timecop.travel(1_000)
-
-        expect(lock.locked?).to be true
-        expect(lock.expired?).to be false
-      end
-    end
-
-    context 'when timeout is set and exceeded' do
-      before { Timecop.travel(1) }
-
-      let(:limiter) { Berater.new(:key, :concurrency, 3, timeout: 1) }
-
-      it 'expires' do
-        expect(lock.expired?).to be true
-        expect(lock.locked?).to be false
-      end
-
-      it 'fails to release' do
-        expect { lock.release }.to raise_error(RuntimeError, /expired/)
-      end
-    end
-  end
-
-end

data/spec/rate_lock_spec.rb

@@ -1,20 +0,0 @@
-describe Berater::Lock do
-  it_behaves_like 'a lock', Berater.new(:key, :rate, 3, :second)
-
-  let(:limiter) { Berater.new(:key, :rate, 3, :second) }
-
-  describe '#expired?' do
-    let!(:lock) { limiter.limit }
-
-    it 'never expires' do
-      expect(lock.locked?).to be true
-      expect(lock.expired?).to be false
-
-      Timecop.travel(1_000)
-
-      expect(lock.locked?).to be true
-      expect(lock.expired?).to be false
-    end
-  end
-
-end