berater 0.5.0 → 0.7.1

data/spec/riddle_spec.rb

@@ -42,11 +42,15 @@ class ConcurrenyRiddler
     timeout ||= 1_000 # fake infinity
 
     limiter = Berater::RateLimiter.new(:key, capacity, timeout)
-    limiter.limit
+    lock = limiter.limit
     yield if block_given?
   ensure
     # decrement counter
-    limiter.redis.decr(limiter.send(:cache_key, :key))
+    if lock
+      key = limiter.send(:cache_key, :key)
+      count, ts = limiter.redis.get(key).split ';'
+      limiter.redis.set(key, "#{count.to_f - 1};#{ts}")
+    end
   end
 end
 

data/spec/test_mode_spec.rb

@@ -1,35 +1,24 @@
-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
-      expect { Berater::Limiter.new }.to raise_error(NotImplementedError)
+      expect { Berater::Limiter.new }.to raise_error(NoMethodError)
     end
   end
 
@@ -50,31 +39,43 @@ describe Berater::TestMode, order: :defined do
     it 'validates input' do
       expect { Berater.test_mode = :foo }.to raise_error(ArgumentError)
     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 'works no matter when limiter was created' do
+      limiter = Berater::Unlimiter.new
+      expect(limiter).not_to be_overloaded
 
-    it_behaves_like 'it is not overloaded'
+      Berater.test_mode = :fail
+      expect(limiter).to be_overloaded
+    end
 
-    it 'always works' do
-      10.times { subject.limit }
+    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 never works, without redis' do
+  shared_examples 'it supports test_mode' do
     before do
+      # without hitting Redis
       Berater.redis = nil
       expect_any_instance_of(Berater::LuaScript).not_to receive(:eval)
     end
 
-    it_behaves_like 'it is overloaded'
+    context 'with test_mode = :pass' do
+      before { Berater.test_mode = :pass }
+
+      it_behaves_like 'it is not overloaded'
+
+      it 'always works' do
+        10.times { subject.limit }
+      end
+    end
+
+    context 'with test_mode = :fail' do
+      before { Berater.test_mode = :fail }
 
-    it 'never works' do
-      expect { subject }.to be_overloaded
+      it_behaves_like 'it is overloaded'
     end
   end
 
@@ -84,23 +85,10 @@ describe Berater::TestMode, order: :defined do
     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'
+      it_behaves_like 'it is not overloaded'
     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'
-    end
+    it_behaves_like 'it supports test_mode'
   end
 
   describe 'Inhibitor' do
@@ -109,42 +97,18 @@ describe Berater::TestMode, order: :defined do
     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'
+      it_behaves_like 'it is overloaded'
     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'
-    end
+    it_behaves_like 'it supports test_mode'
   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
@@ -154,38 +118,15 @@ describe Berater::TestMode, order: :defined do
       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'
-    end
+    it_behaves_like 'it supports test_mode'
   end
 
   describe 'ConcurrencyLimiter' do
     subject { Berater::ConcurrencyLimiter.new(:key, 1) }
 
-    shared_examples 'a ConcurrencyLimiter' do
-      it { expect(subject).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_behaves_like 'it is not overloaded'
 
       it 'works per usual' do
@@ -195,19 +136,7 @@ describe Berater::TestMode, order: :defined do
       end
     end
 
-    context 'when test_mode = :pass' do
-      before { Berater.test_mode = :pass }
-
-      it_behaves_like 'a ConcurrencyLimiter'
-      it_behaves_like 'it always works, without redis'
-    end
-
-    context 'when test_mode = :fail' do
-      before { Berater.test_mode = :fail }
-
-      it_behaves_like 'a ConcurrencyLimiter'
-      it_behaves_like 'it never works, without redis'
-    end
+    it_behaves_like 'it supports test_mode'
   end
 
 end

data/spec/utils_spec.rb

@@ -1,63 +1,63 @@
 describe Berater::Utils do
   using Berater::Utils
 
-  describe '.to_usec' do
+  describe '.to_msec' do
     def f(val)
-      (val * 10**6).to_i
+      (val * 10**3).to_i
     end
 
     it 'works with integers' do
-      expect(0.to_usec).to be f(0)
-      expect(3.to_usec).to be f(3)
+      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_usec).to be f(0.1)
-      expect(3.0.to_usec).to be f(3)
+      expect(0.1.to_msec).to be f(0.1)
+      expect(3.0.to_msec).to be f(3)
     end
 
-    it 'has great precision' do
-      expect(0.123456.to_usec).to be 123456
-      expect(123456.654321.to_usec).to be 123456654321
+    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_usec).to be f(1)
-      expect(:second.to_usec).to be f(1)
-      expect(:seconds.to_usec).to be f(1)
+      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_usec).to be f(60)
-      expect(:minute.to_usec).to be f(60)
-      expect(:minutes.to_usec).to be f(60)
+      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_usec).to be f(60 * 60)
-      expect(:hours.to_usec).to be f(60 * 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_usec).to be f(1)
-      expect('second'.to_usec).to be f(1)
-      expect('seconds'.to_usec).to be f(1)
+      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_usec).to be f(60)
-      expect('minute'.to_usec).to be f(60)
-      expect('minutes'.to_usec).to be f(60)
+      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_usec).to be f(60 * 60)
-      expect('hours'.to_usec).to be f(60 * 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_usec).to be f(0)
-      expect('3'.to_usec).to be f(3)
+      expect('0'.to_msec).to be f(0)
+      expect('3'.to_msec).to be f(3)
 
-      expect('0.1'.to_usec).to be f(0.1)
-      expect('3.0'.to_usec).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_usec }.to raise_error(ArgumentError)
+        expect { val.to_msec }.to raise_error(ArgumentError)
       end
 
       it 'rejects negative numbers' do

metadata

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