berater 0.1.0 → 0.2.0

data/spec/inhibitor_spec.rb

@@ -1,36 +1,24 @@
 describe Berater::Inhibitor do
-  before { Berater.mode = :inhibited }
-
   describe '.new' do
     it 'initializes without any arguments or options' do
       expect(described_class.new).to be_a described_class
     end
 
     it 'initializes with any arguments and options' do
-      expect(described_class.new(:abc, x: 123)).to be_a described_class
+      expect(described_class.new(:abc, :def, x: 123)).to be_a described_class
     end
 
     it 'has default values' do
-      expect(described_class.new.key).to eq described_class.to_s
+      expect(described_class.new.key).to be :inhibitor
       expect(described_class.new.redis).to be Berater.redis
     end
   end
 
-  describe '.limit' do
-    it 'always limits' do
-      expect { described_class.limit }.to be_inhibited
-    end
-
-    it 'works with any arguments or options' do
-      expect { described_class.limit(:abc, x: 123) }.to be_inhibited
-    end
-  end
-
   describe '#limit' do
     let(:limiter) { described_class.new }
 
     it 'always limits' do
-      expect { described_class.limit }.to be_inhibited
+      expect { limiter.limit }.to be_inhibited
     end
   end
 

data/spec/matcher_spec.rb

@@ -1,6 +1,6 @@
 describe 'be_overloaded' do
   context 'Berater::Unlimiter' do
-    let(:limiter) { Berater.new(:unlimited) }
+    let(:limiter) { Berater.new(:key, :unlimited) }
 
     it { expect(limiter).not_to be_overloaded }
     it { expect(limiter).not_to be_inhibited }
@@ -19,7 +19,7 @@ describe 'be_overloaded' do
   end
 
   context 'Berater::Inhibitor' do
-    let(:limiter) { Berater.new(:inhibited) }
+    let(:limiter) { Berater.new(:key, :inhibited) }
 
     it { expect(limiter).to be_overloaded }
     it { expect(limiter).to be_inhibited }
@@ -32,7 +32,7 @@ describe 'be_overloaded' do
   end
 
   context 'Berater::RateLimiter' do
-    let(:limiter) { Berater.new(:rate, 1, :second) }
+    let(:limiter) { Berater.new(:key, :rate, 1, :second) }
 
     it { expect(limiter).not_to be_overloaded }
     it { expect(limiter).not_to be_inhibited }
@@ -67,7 +67,7 @@ describe 'be_overloaded' do
   end
 
   context 'Berater::ConcurrencyLimiter' do
-    let(:limiter) { Berater.new(:concurrency, 1) }
+    let(:limiter) { Berater.new(:key, :concurrency, 1) }
 
     it { expect(limiter).not_to be_overloaded }
     it { expect(limiter).not_to be_inhibited }

data/spec/rate_limiter_spec.rb

@@ -1,23 +1,22 @@
 describe Berater::RateLimiter do
-  before { Berater.mode = :rate }
 
   describe '.new' do
-    let(:limiter) { described_class.new(1, :second) }
+    let(:limiter) { described_class.new(:key, 1, :second) }
 
     it 'initializes' do
+      expect(limiter.key).to be :key
       expect(limiter.count).to eq 1
       expect(limiter.interval).to eq 1
     end
 
     it 'has default values' do
-      expect(limiter.key).to eq described_class.to_s
       expect(limiter.redis).to be Berater.redis
     end
   end
 
   describe '#count' do
     def expect_count(count)
-      limiter = described_class.new(count, :second)
+      limiter = described_class.new(:key, count, :second)
       expect(limiter.count).to eq count
     end
 
@@ -28,7 +27,7 @@ describe Berater::RateLimiter do
     context 'with erroneous values' do
       def expect_bad_count(count)
         expect do
-          described_class.new(count, :second)
+          described_class.new(:key, count, :second)
         end.to raise_error ArgumentError
       end
 
@@ -41,7 +40,7 @@ describe Berater::RateLimiter do
 
   describe '#interval' do
     def expect_interval(interval, expected)
-      limiter = described_class.new(1, interval)
+      limiter = described_class.new(:key, 1, interval)
       expect(limiter.interval).to eq expected
     end
 
@@ -73,7 +72,7 @@ describe Berater::RateLimiter do
     context 'with erroneous values' do
       def expect_bad_interval(interval)
         expect do
-          described_class.new(1, interval)
+          described_class.new(:key, 1, interval)
         end.to raise_error(ArgumentError)
       end
 
@@ -84,82 +83,60 @@ describe Berater::RateLimiter do
   end
 
   describe '#limit' do
-    let(:limiter) { described_class.new(3, :second) }
+    let(:limiter) { described_class.new(:key, 3, :second) }
 
     it 'works' do
-      expect(limiter.limit).to eq 1
-    end
-
-    it 'counts' do
-      expect(limiter.limit).to eq 1
-      expect(limiter.limit).to eq 2
-      expect(limiter.limit).to eq 3
-    end
-
-    it 'yields' do
       expect {|b| limiter.limit(&b) }.to yield_control
       expect(limiter.limit { 123 }).to eq 123
     end
 
+    it 'works without a block' do
+      expect(limiter.limit).to be_a Berater::Lock
+    end
+
     it 'limits excessive calls' do
       3.times { limiter.limit }
 
-      expect { limiter.limit }.to be_overrated
+      expect(limiter).to be_overrated
     end
 
     it 'limit resets over time' do
-      expect(limiter.limit).to eq 1
-      expect(limiter.limit).to eq 2
-      expect(limiter.limit).to eq 3
+      3.times { limiter.limit }
       expect(limiter).to be_overrated
 
       # travel forward a second
       Timecop.freeze(1)
 
-      expect(limiter.limit).to eq 1
-      expect(limiter.limit).to eq 2
-      expect(limiter.limit).to eq 3
+      3.times { limiter.limit }
       expect(limiter).to be_overrated
     end
   end
 
   context 'with same key, different limiters' do
-    let(:limiter_one) { described_class.new(1, :second) }
-    let(:limiter_two) { described_class.new(1, :second) }
-
-    it 'works as expected' do
-      expect(limiter_one.limit).to eq 1
-
-      expect { limiter_one }.to be_overrated
-      expect { limiter_two }.to be_overrated
-    end
-  end
-
-  context 'with different keys, same limiter' do
-    let(:limiter) { described_class.new(1, :second) }
+    let(:limiter_one) { described_class.new(:key, 1, :second) }
+    let(:limiter_two) { described_class.new(:key, 1, :second) }
 
     it 'works as expected' do
-      expect { limiter.limit(key: :one) }.not_to be_overrated
-      expect { limiter.limit(key: :one) }.to be_overrated
+      expect(limiter_one.limit).not_to be_overrated
 
-      expect { limiter.limit(key: :two) }.not_to be_overrated
-      expect { limiter.limit(key: :two) }.to be_overrated
+      expect(limiter_one).to be_overrated
+      expect(limiter_two).to be_overrated
     end
   end
 
   context 'with different keys, different limiters' do
-    let(:limiter_one) { described_class.new(1, :second, key: :one) }
-    let(:limiter_two) { described_class.new(2, :second, key: :two) }
+    let(:limiter_one) { described_class.new(:one, 1, :second) }
+    let(:limiter_two) { described_class.new(:two, 2, :second) }
 
     it 'works as expected' do
-      expect(limiter_one.limit).to eq 1
-      expect(limiter_two.limit).to eq 1
+      expect(limiter_one.limit).not_to be_overrated
+      expect(limiter_two.limit).not_to be_overrated
 
-      expect { limiter_one.limit }.to be_overrated
-      expect(limiter_two.limit).to eq 2
+      expect(limiter_one).to be_overrated
+      expect(limiter_two.limit).not_to be_overrated
 
-      expect { limiter_one.limit }.to be_overrated
-      expect { limiter_two.limit }.to be_overrated
+      expect(limiter_one).to be_overrated
+      expect(limiter_two).to be_overrated
     end
   end
 

data/spec/rate_lock_spec.rb

@@ -0,0 +1,20 @@
+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

data/spec/unlimiter_spec.rb

@@ -1,50 +1,28 @@
 describe Berater::Unlimiter do
-  before { Berater.mode = :unlimited }
-
   describe '.new' do
     it 'initializes without any arguments or options' do
       expect(described_class.new).to be_a described_class
     end
 
     it 'initializes with any arguments and options' do
-      expect(described_class.new(:abc, x: 123)).to be_a described_class
+      expect(described_class.new(:abc, :def, x: 123)).to be_a described_class
     end
 
     it 'has default values' do
-      expect(described_class.new.key).to eq described_class.to_s
+      expect(described_class.new.key).to be :unlimiter
       expect(described_class.new.redis).to be Berater.redis
     end
   end
 
-  describe '.limit' do
-    it 'works' do
-      expect(described_class.limit).to be_nil
-    end
-
-    it 'yields' do
-      expect {|b| described_class.limit(&b) }.to yield_control
-    end
-
-    it 'is never overloaded' do
-      10.times do
-        expect { described_class.limit }.not_to be_overloaded
-      end
-    end
-
-    it 'works with any arguments or options' do
-      expect(described_class.limit(:abc, x: 123)).to be_nil
-    end
-  end
-
   describe '#limit' do
     let(:limiter) { described_class.new }
 
     it 'works' do
-      expect(limiter.limit).to be_nil
+      expect {|b| limiter.limit(&b) }.to yield_control
     end
 
-    it 'yields' do
-      expect {|b| limiter.limit(&b) }.to yield_control
+    it 'works without a block' do
+      expect(limiter.limit).to be_a Berater::Lock
     end
 
     it 'is never overloaded' do
@@ -52,10 +30,8 @@ describe Berater::Unlimiter do
         expect { limiter.limit }.not_to be_overloaded
       end
     end
-
-    it 'works with any arguments or options' do
-      expect(limiter.limit(x: 123)).to be_nil
-    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.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-04 00:00:00.000000000 Z
+date: 2021-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -118,6 +118,7 @@ files:
 - lib/berater/base_limiter.rb
 - lib/berater/concurrency_limiter.rb
 - lib/berater/inhibitor.rb
+- lib/berater/lock.rb
 - lib/berater/rate_limiter.rb
 - lib/berater/unlimiter.rb
 - lib/berater/version.rb
@@ -127,6 +128,7 @@ files:
 - spec/inhibitor_spec.rb
 - spec/matcher_spec.rb
 - spec/rate_limiter_spec.rb
+- spec/rate_lock_spec.rb
 - spec/unlimiter_spec.rb
 homepage: https://github.com/dpep/berater_rb
 licenses:
@@ -154,6 +156,7 @@ summary: Berater
 test_files:
 - spec/rate_limiter_spec.rb
 - spec/matcher_spec.rb
+- spec/rate_lock_spec.rb
 - spec/concurrency_limiter_spec.rb
 - spec/concurrency_lock_spec.rb
 - spec/berater_spec.rb