zk 1.9.3 → 1.10.0

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

data/spec/zk/locker/shared_locker_spec.rb

@@ -9,17 +9,17 @@ shared_examples_for 'ZK::Locker::SharedLocker' do
 
     it %[should raise LockAssertionFailedError if there is an exclusive lock with a number lower than ours] do
       # this should *really* never happen
-      locker.lock.should be_true
+      expect(locker.lock).to be(true)
       shl_path = locker.lock_path
 
-      locker2.lock.should be_true
+      expect(locker2.lock).to be(true)
 
-      locker.unlock.should be_true
-      locker.should_not be_locked
+      expect(locker.unlock).to be(true)
+      expect(locker).not_to be_locked
 
-      zk.exists?(shl_path).should be_false
+      expect(zk.exists?(shl_path)).to be(false)
 
-      locker2.lock_path.should_not == shl_path
+      expect(locker2.lock_path).not_to eq(shl_path)
 
       # convert the first shared lock path into a exclusive one
 
@@ -27,7 +27,7 @@ shared_examples_for 'ZK::Locker::SharedLocker' do
 
       zk.create(exl_path, :ephemeral => true)
 
-      lambda { locker2.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+      expect { locker2.assert! }.to raise_error(ZK::Exceptions::LockAssertionFailedError)
     end
   end
 
@@ -35,18 +35,18 @@ shared_examples_for 'ZK::Locker::SharedLocker' do
     describe %[with default options] 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
         ex_lock = ZK::Locker.exclusive_locker(zk, path)
-        ex_lock.lock.should be_true
-        locker.should_not be_acquirable
+        expect(ex_lock.lock).to be(true)
+        expect(locker).not_to be_acquirable
       end
     end
   end
@@ -59,13 +59,13 @@ shared_examples_for 'ZK::Locker::SharedLocker' 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
 
@@ -77,11 +77,11 @@ shared_examples_for 'ZK::Locker::SharedLocker' 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
     end
 
@@ -96,7 +96,7 @@ shared_examples_for 'ZK::Locker::SharedLocker' do
         it %[should acquire the lock after the write lock is released old-style] do
           ary = []
 
-          locker.lock.should be_false
+          expect(locker.lock).to be(false)
 
           th = Thread.new do
             locker.lock(true)
@@ -104,24 +104,24 @@ shared_examples_for 'ZK::Locker::SharedLocker' 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(@write_lock_path)
 
-          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
 
         it %[should acquire the lock after the write lock is released new-style] do
           ary = []
 
-          locker.lock.should be_false
+          expect(locker.lock).to be(false)
 
           th = Thread.new do
             locker.lock(:wait => true)
@@ -129,18 +129,18 @@ shared_examples_for 'ZK::Locker::SharedLocker' 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(@write_lock_path)
 
-          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
 
@@ -150,9 +150,9 @@ shared_examples_for 'ZK::Locker::SharedLocker' do
 
           write_lock_dir = File.dirname(@write_lock_path)
 
-          zk.children(write_lock_dir).length.should == 1
+          expect(zk.children(write_lock_dir).length).to eq(1)
 
-          locker.lock.should be_false
+          expect(locker.lock).to be(false)
 
           th = Thread.new do
             begin
@@ -164,16 +164,16 @@ shared_examples_for 'ZK::Locker::SharedLocker' 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 == 1
+          expect(zk.children(write_lock_dir).length).to eq(1)
 
-          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_spec.rb

@@ -14,9 +14,9 @@ describe ZK::Locker do
 
       ZK::Locker.cleanup(@zk)
 
-      lambda { locker.assert! }.should_not raise_error
+      expect { locker.assert! }.not_to raise_error
 
-      bogus_lock_dir_names.each { |n| @zk.stat("#{ZK::Locker.default_root_lock_node}/#{n}").should_not exist }
+      bogus_lock_dir_names.each { |n| expect(@zk.stat("#{ZK::Locker.default_root_lock_node}/#{n}")).not_to exist }
 
     end
   end

data/spec/zk/module_spec.rb

@@ -21,7 +21,7 @@ describe ZK do
 
     describe %[with a chrooted connection string and a :chroot => '/path'] do
       it %[should raise an ArgumentError] do
-        lambda { @zk = ZK.new("#{connection_host}/zktest", :chroot => '/zktest') }.should raise_error(ArgumentError)
+        expect { @zk = ZK.new("#{connection_host}/zktest", :chroot => '/zktest') }.to raise_error(ArgumentError)
       end
     end
 
@@ -29,7 +29,7 @@ describe ZK do
       before { @zk = ZK.new }
 
       it %[should create a default connection] do
-        @zk.should be_connected
+        expect(@zk).to be_connected
       end
     end
 
@@ -54,10 +54,10 @@ describe ZK do
           before { @zk = ZK.new(:chroot => chroot_path) }
 
           it %[should use the default connection string, create the chroot and return the connection] do
-            @zk.exists?('/').should be_true
+            expect(@zk.exists?('/')).to be(true)
             @zk.create('/blah', 'data')
 
-            @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+            expect(@unchroot.get("#{chroot_path}/blah").first).to eq('data')
           end
         end
 
@@ -69,10 +69,10 @@ describe ZK do
             end
 
             it %[should create the chroot path and then return the connection] do
-              @zk.exists?('/').should be_true
+              expect(@zk.exists?('/')).to be(true)
               @zk.create('/blah', 'data')
 
-              @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+              expect(@unchroot.get("#{chroot_path}/blah").first).to eq('data')
             end
           end
 
@@ -82,26 +82,26 @@ describe ZK do
             end
 
             it %[should create the chroot path and then return the connection] do
-              @zk.exists?('/').should be_true
+              expect(@zk.exists?('/')).to be(true)
               @zk.create('/blah', 'data')
 
-              @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+              expect(@unchroot.get("#{chroot_path}/blah").first).to eq('data')
             end
           end
 
           describe %[and :chroot => :check] do
             it %[should barf with a ChrootPathDoesNotExistError] do
-              lambda do
+              expect do
                 # assign in case of a bug, that way this connection will get torn down
                 @zk = ZK.new("#{connection_host}#{chroot_path}", :chroot => :check)
-              end.should raise_error(ZK::Exceptions::ChrootPathDoesNotExistError)
+              end.to raise_error(ZK::Exceptions::ChrootPathDoesNotExistError)
             end
           end
 
           describe %[and :chroot => :do_nothing] do
             it %[should return a connection in a weird state] do
               @zk = ZK.new("#{connection_host}#{chroot_path}", :chroot => :do_nothing)
-              lambda { @zk.get('/') }.should raise_error(ZK::Exceptions::NoNode)
+              expect { @zk.get('/') }.to raise_error(ZK::Exceptions::NoNode)
             end
           end
 
@@ -109,10 +109,10 @@ describe ZK do
             before { @zk = ZK.new(connection_host, :chroot => chroot_path) }
 
             it %[should create the chroot path and then return the connection] do
-              @zk.exists?('/').should be_true
+              expect(@zk.exists?('/')).to be(true)
               @zk.create('/blah', 'data')
 
-              @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+              expect(@unchroot.get("#{chroot_path}/blah").first).to eq('data')
             end
           end
         end # as a connection string
@@ -125,10 +125,10 @@ describe ZK do
           before { @zk = ZK.new(:chroot => chroot_path) }
 
           it %[should use the default connection string and totally work] do
-            @zk.exists?('/').should be_true
+            expect(@zk.exists?('/')).to be(true)
             @zk.create('/blah', 'data')
 
-            @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+            expect(@unchroot.get("#{chroot_path}/blah").first).to eq('data')
           end
         end
 
@@ -139,10 +139,10 @@ describe ZK do
             end
 
             it %[should totally work] do
-              @zk.exists?('/').should be_true
+              expect(@zk.exists?('/')).to be(true)
               @zk.create('/blah', 'data')
 
-              @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+              expect(@unchroot.get("#{chroot_path}/blah").first).to eq('data')
             end
           end
 
@@ -152,26 +152,26 @@ describe ZK do
             end
 
             it %[should totally work] do
-              @zk.exists?('/').should be_true
+              expect(@zk.exists?('/')).to be(true)
               @zk.create('/blah', 'data')
 
-              @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+              expect(@unchroot.get("#{chroot_path}/blah").first).to eq('data')
             end
           end
 
           describe %[and :chroot => :check] do
             it %[should totally work] do
-              lambda do
+              expect do
                 # assign in case of a bug, that way this connection will get torn down
                 @zk = ZK.new("#{connection_host}#{chroot_path}", :chroot => :check)
-              end.should_not raise_error
+              end.not_to raise_error
             end
           end
 
           describe %[and :chroot => :do_nothing] do
             it %[should totally work] do
               @zk = ZK.new("#{connection_host}#{chroot_path}", :chroot => :do_nothing)
-              lambda { @zk.get('/') }.should_not raise_error
+              expect { @zk.get('/') }.not_to raise_error
             end
           end
 
@@ -179,15 +179,15 @@ describe ZK do
             before { @zk = ZK.new(connection_host, :chroot => chroot_path) }
 
             it %[should totally work] do
-              @zk.exists?('/').should be_true
+              expect(@zk.exists?('/')).to be(true)
               @zk.create('/blah', 'data')
 
-              @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+              expect(@unchroot.get("#{chroot_path}/blah").first).to eq('data')
             end
           end
         end # as a connection string
       end # that exists
-    end # with a chroot 
+    end # with a chroot
   end # :new
 end # ZK