zk 1.9.6 → 1.10.0

data/spec/zk/client_spec.rb

@@ -21,7 +21,7 @@ describe ZK::Client::Threaded do
       it %[should do the right thing and not fail] do
         # this is an extra special case where the user obviously hates us
 
-        @zk.should be_kind_of(ZK::Client::Threaded) # yeah yeah, just be sure
+        expect(@zk).to be_kind_of(ZK::Client::Threaded) # yeah yeah, just be sure
 
         shutdown_thread = nil
 
@@ -31,17 +31,17 @@ describe ZK::Client::Threaded do
 
         wait_while { shutdown_thread.nil? }
 
-        shutdown_thread.should_not be_nil
-        shutdown_thread.should be_kind_of(Thread)
+        expect(shutdown_thread).not_to be_nil
+        expect(shutdown_thread).to be_kind_of(Thread)
 
-        shutdown_thread.join(5).should == shutdown_thread
+        expect(shutdown_thread.join(5)).to eq(shutdown_thread)
 
-        wait_until(5) { @zk.closed? }.should be_true
+        expect(wait_until(5) { @zk.closed? }).to be(true)
       end
     end
   end
 
-  describe :reopen do
+  describe :reopen, :jruby => :broken do
     include_context 'connection opts'
 
     before do
@@ -53,15 +53,15 @@ describe ZK::Client::Threaded do
     end
 
     it %[should say the client is connected after reopen] do
-      @zk.connected?.should == true
+      expect(@zk.connected?).to eq(true)
 
       @zk.close!
 
-      @zk.connected?.should == false
+      expect(@zk.connected?).to eq(false)
 
       @zk.reopen
 
-      @zk.connected?.should == true
+      expect(@zk.connected?).to eq(true)
     end
   end
 
@@ -80,7 +80,7 @@ describe ZK::Client::Threaded do
       # TODO: this is a terrible test. there is no way to guarantee that this
       #       has been retried. the join at the end should not raise an error
 
-      @zk.should_not be_connected
+      expect(@zk).not_to be_connected
 
       th = Thread.new do
         @zk.stat('/path/to/blah', :retry_duration => 30)
@@ -89,11 +89,11 @@ describe ZK::Client::Threaded do
       th.run
 
       @zk.connect
-      th.join(5).should == th
+      expect(th.join(5)).to eq(th)
     end
 
     it %[barfs if the connection is closed before the connected event is received] do
-      @zk.should_not be_connected
+      expect(@zk).not_to be_connected
 
       exc = nil
 
@@ -110,14 +110,14 @@ describe ZK::Client::Threaded do
 
       @zk.close!
 
-      th.join(5).should == th
+      expect(th.join(5)).to eq(th)
 
-      exc.should_not be_nil
-      exc.should be_kind_of(ZK::Exceptions::Retryable)
+      expect(exc).not_to be_nil
+      expect(exc).to be_kind_of(ZK::Exceptions::Retryable)
     end
 
     it %[should barf if the timeout expires] do
-      @zk.should_not be_connected
+      expect(@zk).not_to be_connected
 
       exc = nil
 
@@ -132,10 +132,10 @@ describe ZK::Client::Threaded do
 
       th.run
 
-      th.join(5).should == th
+      expect(th.join(5)).to eq(th)
 
-      exc.should_not be_nil
-      exc.should be_kind_of(ZK::Exceptions::Retryable)
+      expect(exc).not_to be_nil
+      expect(exc).to be_kind_of(ZK::Exceptions::Retryable)
     end
   end
 end # ZK::Client::Threaded

data/spec/zk/election_spec.rb

@@ -4,7 +4,7 @@ describe ZK::Election, :jruby => :broken do
   include_context 'connection opts'
 
   before do
-    ZK.open(connection_host) do |cnx| 
+    ZK.open(connection_host) do |cnx|
       logger.debug { "REMOVING /_zkelection" }
       cnx.rm_rf('/_zkelection')
     end
@@ -56,8 +56,8 @@ describe ZK::Election, :jruby => :broken do
           end
 
           @palin.on_losing_election do
-            @obama_won.should be_true
-            @palin.leader_acked?.should be_true
+            expect(@obama_won).to be(true)
+            expect(@palin.leader_acked?).to be(true)
             @palin_lost = true
           end
 
@@ -68,21 +68,21 @@ describe ZK::Election, :jruby => :broken do
           oth.run
 
           wait_until { @obama_waiting }
-          @obama_waiting.should be_true
+          expect(@obama_waiting).to be(true)
 
           # palin's callbacks haven't fired
-          @palin_lost.should be_nil
+          expect(@palin_lost).to be_nil
 
           latch.release
 
           wait_until { @obama_won }
-          @obama_won.should be_true
+          expect(@obama_won).to be(true)
 
-          lambda { oth.join(1).should == oth }.should_not raise_error
+          expect { expect(oth.join(1)).to eq(oth) }.not_to raise_error
 
           wait_until { @palin_lost }
 
-          @palin_lost.should be_true
+          expect(@palin_lost).to be(true)
         end
       end
 
@@ -92,7 +92,7 @@ describe ZK::Election, :jruby => :broken do
           @obama_won = @obama_lost = @palin_won = @palin_lost = nil
           win_latch, lose_latch = Latch.new, Latch.new
 
-          @obama.on_winning_election do 
+          @obama.on_winning_election do
             logger.debug { "obama on_winning_election fired" }
             @obama_won = true
             win_latch.release
@@ -115,50 +115,50 @@ describe ZK::Election, :jruby => :broken do
             @palin_lost = true
             lose_latch.release
           end
-          
+
           @obama.vote!
           @palin.vote!
 
           win_latch.await
-          @obama_won.should be_true
+          expect(@obama_won).to be(true)
 
           lose_latch.await
-          @palin_lost.should be_true
+          expect(@palin_lost).to be(true)
         end
 
         describe 'winner' do
           it %[should fire the on_winning_election callbacks] do
-            @obama_won.should be_true
+            expect(@obama_won).to be(true)
           end
 
           it %[should not fire the on_losing_election callbacks] do
-            @obama_lost.should be_nil
+            expect(@obama_lost).to be_nil
           end
 
           it %[should acknowledge completion of winning callbacks] do
-            @zk.exists?(@obama.leader_ack_path).should be_true
+            expect(@zk.exists?(@obama.leader_ack_path)).to be(true)
           end
 
           it %[should write its data to the leader_ack node] do
-            @zk.get(@obama.leader_ack_path).first.should == @data1
+            expect(@zk.get(@obama.leader_ack_path).first).to eq(@data1)
           end
 
           it %[should know it's the leader] do
-            @obama.should be_leader
+            expect(@obama).to be_leader
           end
         end
 
         describe 'loser' do # gets a talk show on Fox News? I KEED! I KEED!
           it %[should know it isn't the leader] do
-            @palin.should_not be_leader
+            expect(@palin).not_to be_leader
           end
 
           it %[should not fire the winning callbacks] do
-            @palin_won.should_not be_true
+            expect(@palin_won).not_to be(true)
           end
 
           it %[should fire the losing callbacks] do
-            @palin_lost.should be_true
+            expect(@palin_lost).to be(true)
           end
 
           it %[should take over as leader when the current leader goes away] do
@@ -167,13 +167,13 @@ describe ZK::Election, :jruby => :broken do
             @obama.zk.close!
             wait_until { @palin_won }
 
-            @palin_won.should be_true # god forbid
+            expect(@palin_won).to be(true) # god forbid
 
             wait_until { @zk2.exists?(@palin.leader_ack_path) }
 
-            @zk2.exists?(@palin.leader_ack_path).should be_true
+            expect(@zk2.exists?(@palin.leader_ack_path)).to be(true)
 
-            @zk2.get(@palin.leader_ack_path).first.should == @data2
+            expect(@zk2.get(@palin.leader_ack_path).first).to eq(@data2)
           end
 
           it %[should remain leader if the original leader comes back] do
@@ -193,9 +193,9 @@ describe ZK::Election, :jruby => :broken do
               newbama.vote!
               wait_until { newbama.voted? }
 
-              newbama.should be_voted
-              win_again.should be_false
-              newbama.should_not be_leader
+              expect(newbama).to be_voted
+              expect(win_again).to be(false)
+              expect(newbama).not_to be_leader
             end
           end
         end
@@ -207,12 +207,12 @@ describe ZK::Election, :jruby => :broken do
     before do
       @zk3 = ZK.new(*connection_args)
 
-      @zk3.exists?('/_zkelection/2012/leader_ack').should be_false
+      expect(@zk3.exists?('/_zkelection/2012/leader_ack')).to be(false)
 
       @obama = ZK::Election::Candidate.new(@zk, @election_name, :data => @data1)
       @palin = ZK::Election::Candidate.new(@zk2, @election_name, :data => @data2)
 
-      @zk3.exists?('/_zkelection/2012/leader_ack').should be_false
+      expect(@zk3.exists?('/_zkelection/2012/leader_ack')).to be(false)
 
       @observer = ZK::Election::Observer.new(@zk3, @election_name)
     end
@@ -231,17 +231,17 @@ describe ZK::Election, :jruby => :broken do
 
           @observer.observe!
           wait_until { !@observer.leader_alive.nil? }
-          @observer.leader_alive.should_not be_nil
-          @zk3.exists?(@observer.root_election_node).should be_false
+          expect(@observer.leader_alive).not_to be_nil
+          expect(@zk3.exists?(@observer.root_election_node)).to be(false)
         end
 
         it %[should set leader_alive to false] do
-          @observer.leader_alive.should be_false
+          expect(@observer.leader_alive).to be(false)
         end
 
         it %[should fire death callbacks] do
-          @events.length.should == 1
-          @events.first.should == :death
+          expect(@events.length).to eq(1)
+          expect(@events.first).to eq(:death)
         end
       end
 
@@ -263,19 +263,19 @@ describe ZK::Election, :jruby => :broken do
         end
 
         it %[should be obama that won] do
-          @obama.should be_leader
+          expect(@obama).to be_leader
         end
 
         it %[should be palin that lost] do
-          @palin.should_not be_leader
+          expect(@palin).not_to be_leader
         end
 
         it %[should set leader_alive to true] do
-          @observer.leader_alive.should be_true
+          expect(@observer.leader_alive).to be(true)
         end
 
         it %[should fire the new leader callbacks] do
-          @got_life_event.should be_true
+          expect(@got_life_event).to be(true)
         end
       end
 
@@ -286,7 +286,7 @@ describe ZK::Election, :jruby => :broken do
           wait_until { @obama.leader? }
 
           @palin.vote!
-          @palin.should_not be_leader
+          expect(@palin).not_to be_leader
 
           @got_life_event = @got_death_event = false
 
@@ -297,23 +297,23 @@ describe ZK::Election, :jruby => :broken do
 
           wait_until { !@observer.leader_alive.nil? }
 
-          @observer.leader_alive.should be_true
+          expect(@observer.leader_alive).to be(true)
           @zk.close!
           wait_until { !@zk.connected? && @palin.leader? && @palin.leader_acked? }
         end
 
         it %[should be palin who is leader] do
-          @palin.should be_leader
+          expect(@palin).to be_leader
         end
 
         it %[should have seen both the death and life events] do
-          pending 'this test is flapping'
-          @got_life_event.should be_true
-          @got_death_event.should be_true
+          # pending 'this test is flapping'
+          expect(@got_life_event).to be(true)
+          expect(@got_death_event).to be(true)
         end
 
         it %[should see the data of the new leader] do
-          @observer.leader_data.should == 'palin'
+          expect(@observer.leader_data).to eq('palin')
         end
       end
     end

data/spec/zk/extensions_spec.rb

@@ -6,8 +6,8 @@ module ZK
 
       it %[should not barf if backtrace is nil] do
         exc = StandardError.new
-        exc.backtrace.should be_nil
-        lambda { exc.to_std_format }.should_not raise_error
+        expect(exc.backtrace).to be_nil
+        expect { exc.to_std_format }.not_to raise_error
       end
     end
   end

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