zk 1.9.3 → 1.10.0

data/spec/zk/locker/exclusive_locker_spec.rb

@@ -9,13 +9,13 @@ shared_examples_for 'ZK::Locker::ExclusiveLocker' do
 
     it %[should raise LockAssertionFailedError if there is an exclusive lock with a number lower than ours] do
       # this should *really* never happen
-      
+
       rlp = locker.root_lock_path
 
       zk.mkdir_p(rlp)
 
       bogus_path = zk.create("#{rlp}/#{ZK::Locker::EXCLUSIVE_LOCK_PREFIX}", :sequential => true, :ephemeral => true)
-      logger.debug { "bogus_path: #{bogus_path.inspect}" } 
+      logger.debug { "bogus_path: #{bogus_path.inspect}" }
 
       th = Thread.new do
         locker.lock(true)
@@ -24,40 +24,40 @@ shared_examples_for 'ZK::Locker::ExclusiveLocker' do
       th.run
 
       logger.debug { "calling wait_until_blocked" }
-      proc { locker.wait_until_blocked(5) }.should_not raise_error
+      expect { locker.wait_until_blocked(5) }.not_to raise_error
       logger.debug { "wait_until_blocked returned" }
-      locker.should be_waiting
+      expect(locker).to be_waiting
 
       wait_until { zk.exists?(locker.lock_path) }
 
-      zk.exists?(locker.lock_path).should be_true
+      expect(zk.exists?(locker.lock_path)).to be(true)
 
       zk.delete(bogus_path)
 
-      th.join(5).should == th
+      expect(th.join(5)).to eq(th)
 
-      locker.lock_path.should_not == bogus_path
+      expect(locker.lock_path).not_to eq(bogus_path)
 
       zk.create(bogus_path, :ephemeral => true)
 
-      lambda { locker.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+      expect { locker.assert! }.to raise_error(ZK::Exceptions::LockAssertionFailedError)
     end
   end
 
   describe :acquirable? do
     it %[should work if the lock root doesn't exist] do
       zk.rm_rf(ZK::Locker.default_root_lock_node)
-      locker.should be_acquirable
+      expect(locker).to be_acquirable
     end
 
     it %[should check local state of lockedness] do
-      locker.lock.should be_true
-      locker.should be_acquirable
+      expect(locker.lock).to be(true)
+      expect(locker).to be_acquirable
     end
 
     it %[should check if any participants would prevent us from acquiring the lock] do
-      locker.lock.should be_true
-      locker2.should_not be_acquirable
+      expect(locker.lock).to be(true)
+      expect(locker2).not_to be_acquirable
     end
   end
 
@@ -69,16 +69,16 @@ shared_examples_for 'ZK::Locker::ExclusiveLocker' do
       end
 
       it %[should acquire the first lock] do
-        @rval.should be_true
+        expect(@rval).to be(true)
       end
 
       it %[should not acquire the second lock] do
-        @rval2.should be_false
+        expect(@rval2).to be(false)
       end
 
       it %[should acquire the second lock after the first lock is released] do
-        locker.unlock.should be_true
-        locker2.lock.should be_true
+        expect(locker.unlock).to be(true)
+        expect(locker2.lock).to be(true)
       end
     end
 
@@ -95,7 +95,7 @@ shared_examples_for 'ZK::Locker::ExclusiveLocker' do
       it %[should block waiting for the lock with old style lock semantics] do
         ary = []
 
-        locker.lock.should be_false
+        expect(locker.lock).to be(false)
 
         th = Thread.new do
           locker.lock(true)
@@ -103,22 +103,22 @@ shared_examples_for 'ZK::Locker::ExclusiveLocker' do
         end
 
         locker.wait_until_blocked(5)
-      
-        ary.should be_empty
-        locker.should_not be_locked
+
+        expect(ary).to be_empty
+        expect(locker).not_to be_locked
 
         zk.delete(@read_lock_path)
 
-        th.join(2).should == th
+        expect(th.join(2)).to eq(th)
 
-        ary.length.should == 1
-        locker.should be_locked
+        expect(ary.length).to eq(1)
+        expect(locker).to be_locked
       end
 
       it %[should block waiting for the lock with new style lock semantics] do
         ary = []
 
-        locker.lock.should be_false
+        expect(locker.lock).to be(false)
 
         th = Thread.new do
           locker.lock(:wait => true)
@@ -126,24 +126,24 @@ shared_examples_for 'ZK::Locker::ExclusiveLocker' do
         end
 
         locker.wait_until_blocked(5)
-      
-        ary.should be_empty
-        locker.should_not be_locked
+
+        expect(ary).to be_empty
+        expect(locker).not_to be_locked
 
         zk.delete(@read_lock_path)
 
-        th.join(2).should == th
+        expect(th.join(2)).to eq(th)
 
-        ary.length.should == 1
-        locker.should be_locked
+        expect(ary.length).to eq(1)
+        expect(locker).to be_locked
       end
 
       it %[should time out waiting for the lock] do
         ary = []
 
-        zk.children(lock_path_base).length.should == 1
+        expect(zk.children(lock_path_base).length).to eq(1)
 
-        locker.lock.should be_false
+        expect(locker.lock).to be(false)
 
         th = Thread.new do
           begin
@@ -155,17 +155,17 @@ shared_examples_for 'ZK::Locker::ExclusiveLocker' do
         end
 
         locker.wait_until_blocked(5)
-      
-        ary.should be_empty
-        locker.should_not be_locked
 
-        th.join(2).should == th
+        expect(ary).to be_empty
+        expect(locker).not_to be_locked
+
+        expect(th.join(2)).to eq(th)
 
-        zk.children(lock_path_base).length.should == 1
+        expect(zk.children(lock_path_base).length).to eq(1)
 
-        ary.should be_empty
-        @exc.should_not be_nil
-        @exc.should be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
+        expect(ary).to be_empty
+        expect(@exc).not_to be_nil
+        expect(@exc).to be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
       end
     end # blocking
   end # lock

data/spec/zk/locker/locker_basic_spec.rb

@@ -20,47 +20,47 @@ describe 'ZK::Client#locker' do
     @zk.close!
     @zk2.close!
     @zk3.close!
-    wait_until { @connections.all? { |c| c.closed? } } 
+    wait_until { @connections.all? { |c| c.closed? } }
   end
 
   it "should be able to acquire the lock if no one else is locking it" do
-    @zk.locker(@path_to_lock).lock.should be_true
+    expect(@zk.locker(@path_to_lock).lock).to be(true)
   end
 
   it "should not be able to acquire the lock if someone else is locking it" do
-    @zk.locker(@path_to_lock).lock.should be_true
-    @zk2.locker(@path_to_lock).lock.should be_false
+    expect(@zk.locker(@path_to_lock).lock).to be(true)
+    expect(@zk2.locker(@path_to_lock).lock).to be(false)
   end
 
   it "should assert properly if lock is acquired" do
-    @zk.locker(@path_to_lock).assert.should be_false
+    expect(@zk.locker(@path_to_lock).assert).to be(false)
     l = @zk2.locker(@path_to_lock)
-    l.lock.should be_true
-    l.assert.should be_true
+    expect(l.lock).to be(true)
+    expect(l.assert).to be(true)
   end
 
   it "should be able to acquire the lock after the first one releases it" do
     lock1 = @zk.locker(@path_to_lock)
     lock2 = @zk2.locker(@path_to_lock)
-    
-    lock1.lock.should be_true
-    lock2.lock.should be_false
+
+    expect(lock1.lock).to be(true)
+    expect(lock2.lock).to be(false)
     lock1.unlock
-    lock2.lock.should be_true
+    expect(lock2.lock).to be(true)
   end
 
   it "should be able to acquire the lock if the first locker goes away" do
     lock1 = @zk.locker(@path_to_lock)
     lock2 = @zk2.locker(@path_to_lock)
 
-    lock1.lock.should be_true
-    lock2.lock.should be_false
+    expect(lock1.lock).to be(true)
+    expect(lock2.lock).to be(false)
     @zk.close!
-    lock2.lock.should be_true
+    expect(lock2.lock).to be(true)
   end
 
   it "should be able to handle multi part path locks" do
-    @zk.locker("my/multi/part/path").lock.should be_true
+    expect(@zk.locker("my/multi/part/path").lock).to be(true)
   end
 
   describe :with_lock do
@@ -70,23 +70,23 @@ describe 'ZK::Client#locker' do
     describe 'Client::Conveniences' do
       it %[should yield the lock instance to the block] do
         @zk.with_lock(@path_to_lock) do |lock|
-          lock.should_not be_nil
-          lock.should be_kind_of(ZK::Locker::LockerBase)
-          lambda { lock.assert! }.should_not raise_error
+          expect(lock).not_to be_nil
+          expect(lock).to be_kind_of(ZK::Locker::LockerBase)
+          expect { lock.assert! }.not_to raise_error
         end
       end
 
       it %[should yield a shared lock when :mode => shared given] do
         @zk.with_lock(@path_to_lock, :mode => :shared) do |lock|
-          lock.should_not be_nil
-          lock.should be_kind_of(ZK::Locker::SharedLocker)
-          lambda { lock.assert! }.should_not raise_error
+          expect(lock).not_to be_nil
+          expect(lock).to be_kind_of(ZK::Locker::SharedLocker)
+          expect { lock.assert! }.not_to raise_error
         end
       end
 
       it %[should take a timeout] do
         first_lock = @zk.locker(@path_to_lock)
-        first_lock.lock.should be_true
+        expect(first_lock.lock).to be(true)
 
         thread = Thread.new do
           begin
@@ -98,8 +98,8 @@ describe 'ZK::Client#locker' do
           end
         end
 
-        thread.join(2).should == thread
-        @exc.should be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
+        expect(thread.join(2)).to eq(thread)
+        expect(@exc).to be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
       end
     end
 
@@ -107,26 +107,26 @@ describe 'ZK::Client#locker' do
       it "should blocking lock" do
         array = []
         first_lock = @zk.locker("mylock")
-        first_lock.lock.should be_true
+        expect(first_lock.lock).to be(true)
         array << :first_lock
 
         thread = Thread.new do
           @zk.locker("mylock").with_lock do
             array << :second_lock
           end
-          array.length.should == 2
+          expect(array.length).to eq(2)
         end
 
-        array.length.should == 1
+        expect(array.length).to eq(1)
         first_lock.unlock
         thread.join(10)
-        array.length.should == 2
+        expect(array.length).to eq(2)
       end
 
       it %[should accept a :wait option] do
         array = []
         first_lock = @zk.locker("mylock")
-        first_lock.lock.should be_true
+        expect(first_lock.lock).to be(true)
 
         second_lock = @zk.locker("mylock")
 
@@ -140,10 +140,32 @@ describe 'ZK::Client#locker' do
           end
         end
 
-        array.should be_empty
-        thread.join(2).should == thread
-        @exc.should_not be_nil
-        @exc.should be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
+        expect(array).to be_empty
+        expect(thread.join(2)).to eq(thread)
+        expect(@exc).not_to be_nil
+        expect(@exc).to be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
+      end
+
+      it "should interrupt a blocked lock" do
+        first_lock = @zk.locker("mylock")
+        expect(first_lock.lock).to be(true)
+
+        second_lock = @zk.locker("mylock")
+        thread = Thread.new do
+          begin
+            second_lock.with_lock do
+              raise "NO NO NO!! should not have called the block!!"
+            end
+          rescue Exception => e
+            @exc = e
+          end
+        end
+
+        Thread.pass until second_lock.waiting?
+
+        second_lock.interrupt!
+        thread.join(2)
+        expect(@exc).to be_kind_of(ZK::Exceptions::WakeUpException)
       end
     end
   end # with_lock

data/spec/zk/locker/semaphore_spec.rb

@@ -10,25 +10,32 @@ shared_examples_for 'ZK::Locker::Semaphore' do
     it_should_behave_like 'LockerBase#assert!'
   end
 
+  context %[invalid semaphore_size] do
+    let(:semaphore_size) { :boom }
+    it 'should raise' do
+      expect{ locker }.to raise_error(ZK::Exceptions::BadArguments)
+    end
+  end
+
   describe :acquirable? do
     describe %[with default options] do
       it %[should work if the lock root doesn't exist] do
         zk.rm_rf(ZK::Locker::Semaphore.default_root_node)
-        locker.should be_acquirable
+        expect(locker).to be_acquirable
       end
 
       it %[should check local state of lockedness] do
-        locker.lock.should be_true
-        locker.should be_acquirable
+        expect(locker.lock).to be(true)
+        expect(locker).to be_acquirable
       end
 
       it %[should check if any participants would prevent us from acquiring the lock] do
-        locker3.lock.should be_true
-        locker.should be_acquirable # total locks given less than semaphore_size
-        locker2.lock.should be_true
-        locker.should_not be_acquirable # total locks given equal to semaphore size
+        expect(locker3.lock).to be(true)
+        expect(locker).to be_acquirable # total locks given less than semaphore_size
+        expect(locker2.lock).to be(true)
+        expect(locker).not_to be_acquirable # total locks given equal to semaphore size
         locker3.unlock
-        locker.should be_acquirable # total locks given less than semaphore_size
+        expect(locker).to be_acquirable # total locks given less than semaphore_size
       end
     end
   end
@@ -41,13 +48,13 @@ shared_examples_for 'ZK::Locker::Semaphore' do
       end
 
       it %[should acquire the first lock] do
-        @rval.should be_true
-        locker.should be_locked
+        expect(@rval).to be(true)
+        expect(locker).to be_locked
       end
 
       it %[should acquire the second lock] do
-        @rval2.should be_true
-        locker2.should be_locked
+        expect(@rval2).to be(true)
+        expect(locker2).to be_locked
       end
     end
 
@@ -61,15 +68,15 @@ shared_examples_for 'ZK::Locker::Semaphore' do
       end
 
       it %[should return false] do
-        @rval.should be_false
+        expect(@rval).to be(false)
       end
 
       it %[should not be locked] do
-        locker.should_not be_locked
+        expect(locker).not_to be_locked
       end
 
       it %[should not have a lock_path] do
-        locker.lock_path.should be_nil
+        expect(locker.lock_path).to be_nil
       end
     end
 
@@ -87,7 +94,7 @@ shared_examples_for 'ZK::Locker::Semaphore' do
         it %[should acquire the lock after the write lock is released] do
           ary = []
 
-          locker.lock.should be_false
+          expect(locker.lock).to be(false)
 
           th = Thread.new do
             locker.lock(:wait => true)
@@ -95,18 +102,18 @@ shared_examples_for 'ZK::Locker::Semaphore' do
           end
 
           locker.wait_until_blocked(5)
-          locker.should be_waiting
-          locker.should_not be_locked
-          ary.should be_empty
+          expect(locker).to be_waiting
+          expect(locker).not_to be_locked
+          expect(ary).to be_empty
 
           zk.delete(@existing_locks.shuffle.first)
 
-          th.join(2).should == th
+          expect(th.join(2)).to eq(th)
 
-          ary.should_not be_empty
-          ary.length.should == 1
+          expect(ary).not_to be_empty
+          expect(ary.length).to eq(1)
 
-          locker.should be_locked
+          expect(locker).to be_locked
         end
       end
 
@@ -116,9 +123,9 @@ shared_examples_for 'ZK::Locker::Semaphore' do
 
           write_lock_dir = File.dirname(@existing_locks.first)
 
-          zk.children(write_lock_dir).length.should == semaphore_size
+          expect(zk.children(write_lock_dir).length).to eq(semaphore_size)
 
-          locker.lock.should be_false
+          expect(locker.lock).to be(false)
 
           th = Thread.new do
             begin
@@ -130,16 +137,16 @@ shared_examples_for 'ZK::Locker::Semaphore' do
           end
 
           locker.wait_until_blocked(5)
-          locker.should be_waiting
-          locker.should_not be_locked
-          ary.should be_empty
+          expect(locker).to be_waiting
+          expect(locker).not_to be_locked
+          expect(ary).to be_empty
 
-          th.join(2).should == th
+          expect(th.join(2)).to eq(th)
 
-          zk.children(write_lock_dir).length.should == semaphore_size
+          expect(zk.children(write_lock_dir).length).to eq(semaphore_size)
 
-          ary.should be_empty
-          @exc.should be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
+          expect(ary).to be_empty
+          expect(@exc).to be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
         end
 
       end