zk 1.9.6 → 1.10.0

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

data/spec/zk/locker/shared_exclusive_integration_spec.rb

@@ -8,12 +8,12 @@ shared_examples_for :shared_exclusive_integration do
 
   describe 'shared lock acquired first' do
     it %[should block exclusive locks from acquiring until released] do
-      @sh_lock.lock.should be_true
-      @ex_lock.lock.should be_false
+      expect(@sh_lock.lock).to be(true)
+      expect(@ex_lock.lock).to be(false)
 
       mutex = Monitor.new
       cond = mutex.new_cond
-      
+
       th = Thread.new do
         logger.debug { "@ex_lock trying to acquire acquire lock" }
         @ex_lock.with_lock do
@@ -28,29 +28,29 @@ shared_examples_for :shared_exclusive_integration do
 
       mutex.synchronize do
         logger.debug { "unlocking the shared lock" }
-        @sh_lock.unlock.should be_true
+        expect(@sh_lock.unlock).to be(true)
         cond.wait_until { th[:got_lock] }   # make sure they actually received the lock (avoid race)
-        th[:got_lock].should be_true
+        expect(th[:got_lock]).to be(true)
         logger.debug { "ok, they got the lock" }
       end
 
-      th.join(5).should == th
+      expect(th.join(5)).to eq(th)
 
       logger.debug { "thread joined, exclusive lock should be releasd" }
 
-      @ex_lock.should_not be_locked
+      expect(@ex_lock).not_to be_locked
     end
   end
 
   describe 'multiple shared locks acquired first' do
     before do
-      zk3.should_not be_nil
-      @sh_lock2 = ZK::Locker.shared_locker(zk3, path) 
+      expect(zk3).not_to be_nil
+      @sh_lock2 = ZK::Locker.shared_locker(zk3, path)
     end
     it %[should not aquire a lock when highest-numbered released but others remain] do
-      @sh_lock.lock.should be_true
-      @sh_lock2.lock.should be_true
-      @ex_lock.lock.should be_false
+      expect(@sh_lock.lock).to be(true)
+      expect(@sh_lock2.lock).to be(true)
+      expect(@ex_lock.lock).to be(false)
 
       mutex = Monitor.new
       cond = mutex.new_cond
@@ -75,28 +75,28 @@ shared_examples_for :shared_exclusive_integration do
       mutex.synchronize do
         @ex_lock.wait_until_blocked(1)
         logger.debug { "unlocking the highest shared lock" }
-        @sh_lock2.unlock.should be_true
+        expect(@sh_lock2.unlock).to be(true)
         cond.wait_until { (!th[:got_lock].nil?) }   # make sure they actually received the lock (avoid race)
-        th[:got_lock].should be_false
+        expect(th[:got_lock]).to be(false)
         logger.debug { "they didn't get the lock." }
       end
 
-      th.join(5).should == th
+      expect(th.join(5)).to eq(th)
 
       logger.debug { "thread joined, exclusive lock should be releasd" }
-      @sh_lock.unlock.should be_true
-      @ex_lock.should_not be_locked
+      expect(@sh_lock.unlock).to be(true)
+      expect(@ex_lock).not_to be_locked
     end
   end
 
   describe 'exclusive lock acquired first' do
     it %[should block shared lock from acquiring until released] do
-      @ex_lock.lock.should be_true
-      @sh_lock.lock.should be_false
+      expect(@ex_lock.lock).to be(true)
+      expect(@sh_lock.lock).to be(false)
 
       mutex = Monitor.new
       cond = mutex.new_cond
-      
+
       th = Thread.new do
         logger.debug { "@ex_lock trying to acquire acquire lock" }
         @sh_lock.with_lock do
@@ -111,31 +111,31 @@ shared_examples_for :shared_exclusive_integration do
 
       mutex.synchronize do
         logger.debug { "unlocking the shared lock" }
-        @ex_lock.unlock.should be_true
+        expect(@ex_lock.unlock).to be(true)
         cond.wait_until { th[:got_lock] }   # make sure they actually received the lock (avoid race)
-        th[:got_lock].should be_true
+        expect(th[:got_lock]).to be(true)
         logger.debug { "ok, they got the lock" }
       end
 
-      th.join(5).should == th
+      expect(th.join(5)).to eq(th)
 
       logger.debug { "thread joined, exclusive lock should be releasd" }
 
-      @sh_lock.should_not be_locked
+      expect(@sh_lock).not_to be_locked
     end
   end
 
   describe 'shared-exclusive-shared' do
     before do
-      zk3.should_not be_nil
-      @sh_lock2 = ZK::Locker.shared_locker(zk3, path) 
+      expect(zk3).not_to be_nil
+      @sh_lock2 = ZK::Locker.shared_locker(zk3, path)
     end
 
     it %[should act something like a queue] do
       @array = []
 
-      @sh_lock.lock.should be_true
-      @sh_lock.should be_locked
+      expect(@sh_lock.lock).to be(true)
+      expect(@sh_lock).to be_locked
 
       ex_th = Thread.new do
         begin
@@ -150,15 +150,15 @@ shared_examples_for :shared_exclusive_integration do
       logger.debug { "about to wait for @ex_lock to be blocked" }
 
       @ex_lock.wait_until_blocked(5)
-      @ex_lock.should be_waiting
+      expect(@ex_lock).to be_waiting
 
       logger.debug { "@ex_lock is waiting" }
 
-      @ex_lock.should_not be_locked
+      expect(@ex_lock).not_to be_locked
 
       # this is the important one, does the second shared lock get blocked by
       # the exclusive lock
-      @sh_lock2.lock.should_not be_true
+      expect(@sh_lock2.lock).not_to be(true)
 
       sh2_th = Thread.new do
         begin
@@ -173,19 +173,19 @@ shared_examples_for :shared_exclusive_integration do
       logger.debug { "about to wait for @sh_lock2 to be blocked" }
 
       @sh_lock2.wait_until_blocked(5)
-      @sh_lock2.should be_waiting
+      expect(@sh_lock2).to be_waiting
 
       logger.debug { "@sh_lock2 is waiting" }
 
       # ok, now unlock the first in the chain
       @sh_lock.assert!
-      @sh_lock.unlock.should be_true
+      expect(@sh_lock.unlock).to be(true)
 
-      ex_th.join(5).should == ex_th
-      sh2_th.join(5).should == sh2_th
+      expect(ex_th.join(5)).to eq(ex_th)
+      expect(sh2_th.join(5)).to eq(sh2_th)
 
-      @array.length.should == 2
-      @array.should == [:ex_lock, :sh_lock2]
+      expect(@array.length).to eq(2)
+      expect(@array).to eq([:ex_lock, :sh_lock2])
     end
   end
 end # shared_exclusive_integration