berater 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22b4ddfe5c7a48fbb3314743adf40d6c4c04e1c70198c210f34226065bd47f39
-  data.tar.gz: d4e917aba67a6aebf1e19f1bba80fce705b8e8e7a9f2e4f07045f8fdac36044d
+  metadata.gz: c8ca6fba7e38a014eed325df41dda7372b41ff62d9e78b61565f4d915d8b4677
+  data.tar.gz: 1fae864b93de87ea3dc70531f3f8697e80af526aea53d8ddfe2076eac9bbd61d
 SHA512:
-  metadata.gz: cd3724e47146912f01e01614341414447ea8cf86ebefbb75a2baf6079c46bc782a2c006df9ddfdf4b402d3f3ab7c55f2e02b9764e60e52994c0d6dd7eda9b804
-  data.tar.gz: 9b9c77973b16f11399d87924b1c279cb4274c91cdffe8e89a1e1b5d8881e9cefe9f75bf91e86e0160cacf748c137633f33250892ffc047fabe65c6eb4dc9b3aa
+  metadata.gz: 1b4b37134edece0657ea9be15119fe25b2208d554b9dbf56edd04f8e5acff77569022be025ec428b81ab1971171ae468e389a9568d7ad0163b0966e622a09f2e
+  data.tar.gz: bd927303eb1475e79a26161a184205008926f95c59a06eee43f453d5e464d15c205a91bffd36228ae28bc5d27f0fa32faebc7c5870ec5d1779bd6c57ecdc0fe2

data/lib/berater/concurrency_limiter.rb

@@ -55,7 +55,7 @@ module Berater
       end
 
       def expired?
-        @locked_at + limiter.timeout < Time.now
+        limiter.timeout > 0 && @locked_at + limiter.timeout < Time.now
       end
     end
 
@@ -95,7 +95,7 @@ module Berater
 
           count = count + 1
         end
-      else
+      elseif capacity > 0 then
         count = 1
         lock = "1"
 
@@ -138,7 +138,7 @@ module Berater
         begin
           yield lock
         ensure
-          release(lock)
+          lock.release
         end
       else
         lock

data/lib/berater/version.rb

@@ -1,3 +1,3 @@
 module Berater
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/spec/concurrency_limiter_spec.rb

@@ -69,29 +69,42 @@ describe Berater::ConcurrencyLimiter do
       expect {|b| limiter.limit(&b) }.to yield_control
     end
 
-    it 'works many times if workers complete and return locks' do
+    it 'works many times if workers release locks' do
       30.times do
         expect {|b| limiter.limit(&b) }.to yield_control
       end
+
+      30.times do
+        lock = limiter.limit
+        lock.release
+      end
     end
 
     it 'limits excessive calls' do
       expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
       expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
 
-      expect { limiter }.to be_incapacitated
+      expect(limiter).to be_incapacitated
     end
 
     it 'times out locks' do
       expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
       expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
-      expect { limiter }.to be_incapacitated
+      expect(limiter).to be_incapacitated
 
       Timecop.travel(1)
 
       expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
       expect(limiter.limit).to be_a Berater::ConcurrencyLimiter::Lock
-      expect { limiter }.to be_incapacitated
+      expect(limiter).to be_incapacitated
+    end
+
+    context 'with capacity 0' do
+      let(:limiter) { described_class.new(0) }
+
+      it 'always fails' do
+        expect(limiter).to be_incapacitated
+      end
     end
   end
 
@@ -104,8 +117,8 @@ describe Berater::ConcurrencyLimiter do
     it 'works as expected' do
       expect(limiter_one.limit).to be_a Berater::ConcurrencyLimiter::Lock
 
-      expect { limiter_one }.to be_incapacitated
-      expect { limiter_two }.to be_incapacitated
+      expect(limiter_one).to be_incapacitated
+      expect(limiter_two).to be_incapacitated
     end
   end
 
@@ -145,22 +158,22 @@ describe Berater::ConcurrencyLimiter do
       one_lock = limiter_one.limit
       expect(one_lock).to be_a Berater::ConcurrencyLimiter::Lock
 
-      expect { limiter_one }.to be_incapacitated
-      expect { limiter_two }.not_to be_incapacitated
+      expect(limiter_one).to be_incapacitated
+      expect(limiter_two).not_to be_incapacitated
 
       two_lock = limiter_two.limit
       expect(two_lock).to be_a Berater::ConcurrencyLimiter::Lock
 
-      expect { limiter_one }.to be_incapacitated
-      expect { limiter_two }.to be_incapacitated
+      expect(limiter_one).to be_incapacitated
+      expect(limiter_two).to be_incapacitated
 
       one_lock.release
-      expect { limiter_one }.to be_incapacitated
-      expect { limiter_two }.not_to be_incapacitated
+      expect(limiter_one).to be_incapacitated
+      expect(limiter_two).not_to be_incapacitated
 
       two_lock.release
-      expect { limiter_one }.not_to be_incapacitated
-      expect { limiter_two }.not_to be_incapacitated
+      expect(limiter_one).not_to be_incapacitated
+      expect(limiter_two).not_to be_incapacitated
     end
   end
 
@@ -169,20 +182,20 @@ describe Berater::ConcurrencyLimiter do
     let(:limiter_two) { described_class.new(1, key: :two) }
 
     it 'works as expected' do
-      expect { limiter_one }.not_to be_incapacitated
-      expect { limiter_two }.not_to be_incapacitated
+      expect(limiter_one).not_to be_incapacitated
+      expect(limiter_two).not_to be_incapacitated
 
       one_lock = limiter_one.limit
       expect(one_lock).to be_a Berater::ConcurrencyLimiter::Lock
 
-      expect { limiter_one }.to be_incapacitated
-      expect { limiter_two }.not_to be_incapacitated
+      expect(limiter_one).to be_incapacitated
+      expect(limiter_two).not_to be_incapacitated
 
       two_lock = limiter_two.limit
       expect(two_lock).to be_a Berater::ConcurrencyLimiter::Lock
 
-      expect { limiter_one }.to be_incapacitated
-      expect { limiter_two }.to be_incapacitated
+      expect(limiter_one).to be_incapacitated
+      expect(limiter_two).to be_incapacitated
     end
   end
 

data/spec/concurrency_lock_spec.rb

@@ -1,48 +1,90 @@
 describe Berater::ConcurrencyLimiter::Lock do
-  subject { Berater.limit(1, timeout: 1) }
-
   before { Berater.mode = :concurrency }
 
-  it { expect(subject.released?).to be false }
-  it { expect(subject.expired?).to be false }
+  let(:limiter) { Berater.new(:concurrency, 3) }
+
+  describe '#contention' do
+    it 'tracks contention' do
+      lock_1 = limiter.limit
+      expect(lock_1.contention).to eq 1
+
+      lock_2 = limiter.limit
+      expect(lock_2.contention).to eq 2
 
-  context 'after being released' do
-    before { subject.release }
+      limiter.limit do |lock_3|
+        expect(lock_3.contention).to eq 3
+      end
+    end
 
-    it { expect(subject.released?).to be true }
-    it { expect(subject.expired?).to be false }
+    it 'works in block mode' do
+      lock_1 = limiter.limit
 
-    it 'can not be released again' do
-      expect { subject.release }.to raise_error(RuntimeError, /already/)
+      limiter.limit do |lock_2|
+        expect(lock_1.contention).to eq 1
+        expect(lock_2.contention).to eq 2
+      end
     end
   end
 
-  context 'when enough time passes' do
-    before { subject; Timecop.freeze(2) }
+  describe '#release' do
+    it 'can not be released twice' do
+      lock = limiter.limit
+      expect(lock.release).to be true
+      expect { lock.release }.to raise_error(RuntimeError, /already/)
+    end
 
-    it 'expires' do
-      expect(subject.expired?).to be true
+    it 'does not work in block mode' do
+      expect do
+        limiter.limit do |lock|
+          lock.release
+        end
+      end.to raise_error(RuntimeError, /already/)
     end
+  end
+
+  describe '#released?' do
+    it 'works' do
+      lock = limiter.limit
+      expect(lock.released?).to be false
 
-    it 'fails to release' do
-      expect { subject.release }.to raise_error(RuntimeError, /expired/)
+      lock.release
+      expect(lock.released?).to be true
     end
 
-    it { expect(subject.released?).to be false }
+    it 'works in block mode' do
+      limiter.limit do |lock|
+        expect(lock.released?).to be false
+      end
+    end
   end
 
-  describe '#contention' do
-    let(:limiter) { Berater.new(:concurrency, 3) }
+  describe '#expired?' do
+    let!(:lock) { limiter.limit }
 
-    it 'tracks contention' do
-      lock_1 = limiter.limit
-      expect(lock_1.contention).to eq 1
+    context 'when timeout is not set' do
+      it { expect(limiter.timeout).to eq 0 }
 
-      lock_2 = limiter.limit
-      expect(lock_2.contention).to eq 2
+      it 'never expires' do
+        expect(lock.expired?).to be false
 
-      limiter.limit do |lock_3|
-        expect(lock_3.contention).to eq 3
+        Timecop.travel(1_000)
+
+        expect(lock.expired?).to be false
+      end
+    end
+
+    context 'when timeout is set and exceeded' do
+      before { Timecop.travel(1) }
+
+      let(:limiter) { Berater.new(:concurrency, 3, timeout: 1) }
+
+      it 'expires' do
+        expect(lock.expired?).to be true
+      end
+
+      it 'fails to release' do
+        expect(lock.released?).to be false
+        expect { lock.release }.to raise_error(RuntimeError, /expired/)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: berater
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-05 00:00:00.000000000 Z
+date: 2021-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis