berater 0.2.0 → 0.6.1

data/spec/riddle_spec.rb

@@ -0,0 +1,102 @@
+# Can you build a rate limiter from a concurrency limiter?  Yes!
+
+class RateRiddler
+  def self.limit(capacity, interval)
+    lock = Berater::ConcurrencyLimiter.new(:key, capacity, timeout: interval).limit
+    yield if block_given?
+    # allow lock to time out rather than be released
+  end
+end
+
+
+describe 'a ConcurrencyLimiter-derived rate limiter' do
+  def limit(&block)
+    RateRiddler.limit(1, :second, &block)
+  end
+
+  it 'works' do
+    expect(limit { 123 }).to eq 123
+  end
+
+  it 'respects limits' do
+    limit
+    expect { limit }.to be_overloaded
+  end
+
+  it 'resets over time' do
+    limit
+    expect { limit }.to be_overloaded
+
+    Timecop.freeze(1)
+
+    limit
+    expect { limit }.to be_overloaded
+  end
+end
+
+
+# Can you build a concurrency limiter from a rate limiter?  Almost...
+
+class ConcurrenyRiddler
+  def self.limit(capacity, timeout: nil)
+    timeout ||= 1_000 # fake infinity
+
+    limiter = Berater::RateLimiter.new(:key, capacity, timeout)
+    limiter.limit
+    yield if block_given?
+  ensure
+    # decrement counter
+    limiter.redis.decr(limiter.send(:cache_key, :key))
+  end
+end
+
+
+describe 'a RateLimiter-derived concurrency limiter' do
+  def limit(capacity = 1, timeout: nil, &block)
+    ConcurrenyRiddler.limit(capacity, timeout: timeout, &block)
+  end
+
+  it 'works' do
+    expect(limit { 123 }).to eq 123
+  end
+
+  it 'respects limits' do
+    limit do
+      # a second, simultaneous request isn't allowed
+      expect { limit }.to be_overloaded
+    end
+
+    # but now it'll work
+    limit
+  end
+
+  it 'resets over time' do
+    limit(timeout: 1) do
+      expect { limit }.to be_overloaded
+
+      # ...wait for it
+      Timecop.freeze(10)
+
+      limit(timeout: 1)
+    end
+  end
+
+  it "has no memory of the order, so timeouts don't work quite right" do
+    limit(2, timeout: 1) do
+      Timecop.freeze(0.5)
+
+      limit(2, timeout: 1) do
+        # this is where the masquerading breaks.  the first lock is still
+        # being held and within it's timeout limit, however the RaterLimiter
+        # decremented the count internally since enough time has passed.
+        # This next call *should* fail, but doesn't.
+
+        expect {
+          expect { limit(2, timeout: 1) }.to be_overloaded
+        }.to fail
+
+        # ...close, but not quite!
+      end
+    end
+  end
+end

data/spec/test_mode_spec.rb

@@ -0,0 +1,225 @@
+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)
+    end
+
+    it 'defaults to off' do
+      expect(Berater.test_mode).to be nil
+    end
+
+    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
+      expect { Berater::Limiter.new }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '.test_mode' do
+    it 'can be turned on' do
+      Berater.test_mode = :pass
+      expect(Berater.test_mode).to be :pass
+
+      Berater.test_mode = :fail
+      expect(Berater.test_mode).to be :fail
+    end
+
+    it 'can be turned off' do
+      Berater.test_mode = nil
+      expect(Berater.test_mode).to be nil
+    end
+
+    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
+    before do
+      Berater.redis = nil
+      expect_any_instance_of(Berater::LuaScript).not_to receive(:eval)
+    end
+
+    it_behaves_like 'it is not overloaded'
+
+    it 'always works' do
+      10.times { subject.limit }
+    end
+  end
+
+  shared_examples 'it never works, without redis' do
+    before do
+      Berater.redis = nil
+      expect_any_instance_of(Berater::LuaScript).not_to receive(:eval)
+    end
+
+    it_behaves_like 'it is overloaded'
+  end
+
+  describe 'Unlimiter' do
+    subject { Berater::Unlimiter.new }
+
+    context 'when test_mode = nil' do
+      before { Berater.test_mode = nil }
+
+      it { is_expected.to be_a Berater::Unlimiter }
+      it_behaves_like 'it always works, without redis'
+    end
+
+    context 'when test_mode = :pass' do
+      before { Berater.test_mode = :pass }
+
+      it { is_expected.to be_a Berater::Unlimiter }
+      it_behaves_like 'it always works, without redis'
+    end
+
+    context 'when test_mode = :fail' do
+      before { Berater.test_mode = :fail }
+
+      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
+
+  describe 'Inhibitor' do
+    subject { Berater::Inhibitor.new }
+
+    context 'when test_mode = nil' do
+      before { Berater.test_mode = nil }
+
+      it { is_expected.to be_a Berater::Inhibitor }
+      it_behaves_like 'it never works, without redis'
+    end
+
+    context 'when test_mode = :pass' do
+      before { Berater.test_mode = :pass }
+
+      it { is_expected.to be_a Berater::Inhibitor }
+      it_behaves_like 'it always works, without redis'
+    end
+
+    context 'when test_mode = :fail' do
+      before { Berater.test_mode = :fail }
+
+      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
+
+  describe 'RateLimiter' do
+    subject { Berater::RateLimiter.new(:key, 1, :second) }
+
+    shared_examples 'a RateLimiter' do
+      it { is_expected.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_behaves_like 'it is not overloaded'
+
+      it 'works per usual' do
+        expect(Berater::RateLimiter::LUA_SCRIPT).to receive(:eval).twice.and_call_original
+        expect(subject.limit).to be_a Berater::Lock
+        expect { subject.limit }.to be_overloaded
+      end
+    end
+
+    context 'when test_mode = :pass' do
+      before { Berater.test_mode = :pass }
+
+      it_behaves_like 'a RateLimiter'
+      it_behaves_like 'it always works, without redis'
+    end
+
+    context 'when test_mode = :fail' do
+      before { Berater.test_mode = :fail }
+
+      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
+
+  describe 'ConcurrencyLimiter' do
+    subject { Berater::ConcurrencyLimiter.new(:key, 1) }
+
+    context 'when test_mode = nil' do
+      before { Berater.test_mode = nil }
+
+      it { is_expected.to be_a Berater::ConcurrencyLimiter }
+
+      it_behaves_like 'it is not overloaded'
+
+      it 'works per usual' do
+        expect(Berater::ConcurrencyLimiter::LUA_SCRIPT).to receive(:eval).twice.and_call_original
+        expect(subject.limit).to be_a Berater::Lock
+        expect { subject.limit }.to be_overloaded
+      end
+    end
+
+    context 'when test_mode = :pass' do
+      before { Berater.test_mode = :pass }
+
+      it { is_expected.to be_a Berater::ConcurrencyLimiter }
+
+      it_behaves_like 'it always works, without redis'
+    end
+
+    context 'when test_mode = :fail' do
+      before { Berater.test_mode = :fail }
+
+      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
+
+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
@@ -15,23 +17,14 @@ describe Berater::Unlimiter do
   end
 
   describe '#limit' do
-    let(:limiter) { described_class.new }
-
-    it 'works' do
-      expect {|b| limiter.limit(&b) }.to yield_control
-    end
+    subject { described_class.new }
 
-    it 'works without a block' do
-      expect(limiter.limit).to be_a Berater::Lock
-    end
+    it_behaves_like 'it is not overloaded'
 
     it 'is never overloaded' do
       10.times do
-        expect { limiter.limit }.not_to be_overloaded
+        expect { subject.limit }.not_to be_overloaded
       end
     end
   end
-
-  it_behaves_like 'a lock', described_class.new
-
 end

data/spec/utils_spec.rb

@@ -0,0 +1,78 @@
+describe Berater::Utils do
+  using Berater::Utils
+
+  describe '.to_msec' do
+    def f(val)
+      (val * 10**3).to_i
+    end
+
+    it 'works with integers' do
+      expect(0.to_msec).to be f(0)
+      expect(3.to_msec).to be f(3)
+    end
+
+    it 'works with floats' do
+      expect(0.1.to_msec).to be f(0.1)
+      expect(3.0.to_msec).to be f(3)
+    end
+
+    it 'truncates excessive precision' do
+      expect(0.123456.to_msec).to be 123
+      expect(123456.654321.to_msec).to be 123456654
+    end
+
+    it 'works with symbols that are keywords' do
+      expect(:sec.to_msec).to be f(1)
+      expect(:second.to_msec).to be f(1)
+      expect(:seconds.to_msec).to be f(1)
+
+      expect(:min.to_msec).to be f(60)
+      expect(:minute.to_msec).to be f(60)
+      expect(:minutes.to_msec).to be f(60)
+
+      expect(:hour.to_msec).to be f(60 * 60)
+      expect(:hours.to_msec).to be f(60 * 60)
+    end
+
+    it 'works with strings that are keywords' do
+      expect('sec'.to_msec).to be f(1)
+      expect('second'.to_msec).to be f(1)
+      expect('seconds'.to_msec).to be f(1)
+
+      expect('min'.to_msec).to be f(60)
+      expect('minute'.to_msec).to be f(60)
+      expect('minutes'.to_msec).to be f(60)
+
+      expect('hour'.to_msec).to be f(60 * 60)
+      expect('hours'.to_msec).to be f(60 * 60)
+    end
+
+    it 'works with strings that are numeric' do
+      expect('0'.to_msec).to be f(0)
+      expect('3'.to_msec).to be f(3)
+
+      expect('0.1'.to_msec).to be f(0.1)
+      expect('3.0'.to_msec).to be f(3)
+    end
+
+    context 'with erroneous values' do
+      def e(val)
+        expect { val.to_msec }.to raise_error(ArgumentError)
+      end
+
+      it 'rejects negative numbers' do
+        e(-1)
+        e(-1.2)
+        e('-1')
+      end
+
+      it 'rejects bogus symbols and strings' do
+        e('abc')
+        e('1a')
+        e(:abc)
+        e(Float::INFINITY)
+      end
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: berater
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-16 00:00:00.000000000 Z
+date: 2021-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -108,28 +122,39 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: rate limiter
+description: work...within limits
 email:
 executables: []
 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/lua_script.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/utils.rb
 - lib/berater/version.rb
 - spec/berater_spec.rb
 - spec/concurrency_limiter_spec.rb
-- spec/concurrency_lock_spec.rb
+- spec/dsl_refinement_spec.rb
+- spec/dsl_spec.rb
 - spec/inhibitor_spec.rb
-- spec/matcher_spec.rb
+- spec/limiter_spec.rb
+- spec/lua_script_spec.rb
+- spec/matchers_spec.rb
 - spec/rate_limiter_spec.rb
-- spec/rate_lock_spec.rb
+- spec/riddle_spec.rb
+- spec/test_mode_spec.rb
 - spec/unlimiter_spec.rb
+- spec/utils_spec.rb
 homepage: https://github.com/dpep/berater_rb
 licenses:
 - MIT
@@ -155,10 +180,15 @@ 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/dsl_refinement_spec.rb
+- spec/test_mode_spec.rb
+- spec/dsl_spec.rb
+- spec/lua_script_spec.rb
 - spec/concurrency_limiter_spec.rb
-- spec/concurrency_lock_spec.rb
+- spec/riddle_spec.rb
+- spec/utils_spec.rb
 - spec/berater_spec.rb
+- spec/limiter_spec.rb
 - spec/inhibitor_spec.rb
 - spec/unlimiter_spec.rb