zk 1.9.6 → 1.10.0

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
 

data/spec/zk/mongoid_spec.rb

@@ -18,7 +18,7 @@ describe ZK::Mongoid::Locking do
     unless th.join(5) == th
       logger.warn { "Forcing pool closed!" }
       ZK::Mongoid::Locking.zk_lock_pool.force_close!
-      th.join(5).should == th
+      expect(th.join(5)).to eq(th)
     end
 
     ZK::Mongoid::Locking.zk_lock_pool = nil
@@ -35,8 +35,8 @@ describe ZK::Mongoid::Locking do
       end
 
       th.join_until { !@lock_state.nil? }
-      @lock_state.should_not be_nil
-      @lock_state.should be_true
+      expect(@lock_state).not_to be_nil
+      expect(@lock_state).to be(true)
     end
 
     it %[should allow another thread to enter the shared lock] do
@@ -52,10 +52,10 @@ describe ZK::Mongoid::Locking do
         end
 
         @th1.join_until { @counter > 0 }
-        @counter.should > 0
+        expect(@counter).to be > 0
 
         @th1.join_until { @queue.num_waiting > 0 }
-        @queue.num_waiting.should > 0
+        expect(@queue.num_waiting).to be > 0
 
         @th2 = Thread.new do
           @other_doc.with_shared_lock do
@@ -64,9 +64,9 @@ describe ZK::Mongoid::Locking do
         end
 
         @th2.join_until { @counter == 2 }
-        @counter.should == 2
+        expect(@counter).to eq(2)
 
-        @th2.join(2).should == @th2
+        expect(@th2.join(2)).to eq(@th2)
       ensure
         @queue << :unlock
 
@@ -102,32 +102,32 @@ describe ZK::Mongoid::Locking do
         end
 
         @th1.join_until { q2.num_waiting >= 1 }
-        q2.num_waiting.should >= 1
+        expect(q2.num_waiting).to be >= 1
 
         @th2.join_until { q1.size == 0 }
-        q1.size.should be_zero
+        expect(q1.size).to be_zero
 
-        @got_exclusive_lock.should_not be_true
+        expect(@got_exclusive_lock).not_to be(true)
 
         q2.enq(:release)
 
         @th1.join_until { q2.size == 0 }
-        q2.size.should be_zero
+        expect(q2.size).to be_zero
 
         @th2.join_until(5) { @got_exclusive_lock }
-        @got_exclusive_lock.should be_true
+        expect(@got_exclusive_lock).to be(true)
 
       rescue Exception => e
         $stderr.puts e.to_std_format
         raise e
-      ensure 
+      ensure
         q2 << :release
 
         unless @th1.join(2)
           $stderr.puts "UH OH! @th1 IS HUNG!!"
         end
 
-        unless @th2.join(2) 
+        unless @th2.join(2)
           $stderr.puts "UH OH! @th2 IS HUNG!!"
         end
       end
@@ -145,8 +145,8 @@ describe ZK::Mongoid::Locking do
       end
 
       th.join_until { !@lock_state.nil? }
-      @lock_state.should_not be_nil
-      @lock_state.should be_true
+      expect(@lock_state).not_to be_nil
+      expect(@lock_state).to be(true)
     end
 
     it %[should allow the same thread to re-enter the lock] do
@@ -165,7 +165,7 @@ describe ZK::Mongoid::Locking do
       end
 
       th.join_until { @counter >= 2 }
-      @counter.should == 2
+      expect(@counter).to eq(2)
     end
 
     it %[should block another thread from entering the lock] do
@@ -181,9 +181,9 @@ describe ZK::Mongoid::Locking do
       end
 
       th1.join_until { @counter == 1 }
-      @counter.should == 1
+      expect(@counter).to eq(1)
 
-      th1.zk_mongoid_lock_registry[:exclusive].should include(@doc.zk_lock_name)
+      expect(th1.zk_mongoid_lock_registry[:exclusive]).to include(@doc.zk_lock_name)
 
       th2 = Thread.new do
         @other_doc.lock_for_update do
@@ -196,17 +196,17 @@ describe ZK::Mongoid::Locking do
 
       # this is not a deterministic check of whether or not th2 ran and did not
       # get the lock but probably close enough
-      
-      @counter.should == 1
-      @other_doc_got_lock.should == false
-      th2.zk_mongoid_lock_registry[:exclusive].should_not include(@other_doc.zk_lock_name)
+
+      expect(@counter).to eq(1)
+      expect(@other_doc_got_lock).to eq(false)
+      expect(th2.zk_mongoid_lock_registry[:exclusive]).not_to include(@other_doc.zk_lock_name)
 
       queue << :release_lock
-      th1.join(5).should == th1
+      expect(th1.join(5)).to eq(th1)
 
       th2.join_until { @counter == 2 }
-      @counter.should == 2
-      @other_doc_got_lock.should be_true
+      expect(@counter).to eq(2)
+      expect(@other_doc_got_lock).to be(true)
     end
 
     describe :with_name do
@@ -217,7 +217,7 @@ describe ZK::Mongoid::Locking do
       after do
         if @queue.num_waiting > 0
           @queue << :bogus
-          @th1.join(5).should == @th1
+          expect(@th1.join(5)).to eq(@th1)
         end
       end
 
@@ -235,9 +235,9 @@ describe ZK::Mongoid::Locking do
         end
 
         @th1.join_until { @counter == 1 }
-        @counter.should == 1
+        expect(@counter).to eq(1)
 
-        @th1.zk_mongoid_lock_registry[:exclusive].should include(@doc.zk_lock_name(@name))
+        expect(@th1.zk_mongoid_lock_registry[:exclusive]).to include(@doc.zk_lock_name(@name))
 
         @th2 = Thread.new do
           @other_doc.lock_for_update(@name) do
@@ -250,16 +250,16 @@ describe ZK::Mongoid::Locking do
 
         # this is not a deterministic check of whether or not @th2 ran and did not
         # get the lock but probably close enough
-        
-        @counter.should == 1
-        @other_doc_got_lock.should == false
+
+        expect(@counter).to eq(1)
+        expect(@other_doc_got_lock).to eq(false)
 
         @queue << :release_lock
-        @th1.join(5).should == @th1
+        expect(@th1.join(5)).to eq(@th1)
 
         @th2.join_until { @counter == 2 }
-        @counter.should == 2
-        @other_doc_got_lock.should be_true
+        expect(@counter).to eq(2)
+        expect(@other_doc_got_lock).to be(true)
       end
 
       it %[should not affect another thread using a different name] do
@@ -276,9 +276,9 @@ describe ZK::Mongoid::Locking do
         end
 
         @th1.join_until { @counter == 1 }
-        @counter.should == 1
+        expect(@counter).to eq(1)
 
-        @th1.zk_mongoid_lock_registry[:exclusive].should include(@doc.zk_lock_name(@name))
+        expect(@th1.zk_mongoid_lock_registry[:exclusive]).to include(@doc.zk_lock_name(@name))
 
         @th2 = Thread.new do
           @other_doc.lock_for_update do
@@ -288,41 +288,41 @@ describe ZK::Mongoid::Locking do
         end
 
         @th2.join_until { @other_doc_got_lock }
-        @other_doc_got_lock.should be_true
-        
-        @counter.should == 2
+        expect(@other_doc_got_lock).to be(true)
+
+        expect(@counter).to eq(2)
 
         @queue << :release_lock
-        @th1.join(2).should == @th1
+        expect(@th1.join(2)).to eq(@th1)
       end
     end
   end
 
   describe :assert_locked_for_update! do
     it %[should raise MustBeExclusivelyLockedException if the current thread does not hold the lock] do
-      lambda { @doc.assert_locked_for_update! }.should raise_error(ZK::Exceptions::MustBeExclusivelyLockedException)
+      expect { @doc.assert_locked_for_update! }.to raise_error(ZK::Exceptions::MustBeExclusivelyLockedException)
     end
 
     it %[should not raise an exception if the current thread holds the lock] do
-      lambda do
+      expect do
         @doc.lock_for_update do
           @doc.assert_locked_for_update!
         end
-      end.should_not raise_error
+      end.not_to raise_error
     end
   end
 
   describe :assert_locked_for_share! do
     it %[should raise MustBeShareLockedException if the current thread does not hold a shared lock] do
-      lambda { @doc.assert_locked_for_share! }.should raise_error(ZK::Exceptions::MustBeShareLockedException)
+      expect { @doc.assert_locked_for_share! }.to raise_error(ZK::Exceptions::MustBeShareLockedException)
     end
 
     it %[should not raise an exception if the current thread holds a shared lock] do
-      lambda do
+      expect do
         @doc.with_shared_lock do
           @doc.assert_locked_for_share!
         end
-      end.should_not raise_error
+      end.not_to raise_error
     end
   end
 end