zk 1.9.6 → 1.10.0

data/spec/zk/node_deletion_watcher_spec.rb

@@ -15,18 +15,18 @@ describe ZK::NodeDeletionWatcher do
       @zk.mkdir_p(@path)
 
       th = Thread.new { @n.block_until_deleted }
-      
-      @n.wait_until_blocked(5).should be_true
+
+      expect(@n.wait_until_blocked(5)).to be(true)
 
       logger.debug { "wait_until_blocked returned" }
 
-      @n.should be_blocked
+      expect(@n).to be_blocked
 
       @zk.rm_rf(@path)
 
-      th.join(5).should == th
-      @n.should_not be_blocked
-      @n.should be_done
+      expect(th.join(5)).to eq(th)
+      expect(@n).not_to be_blocked
+      expect(@n).to be_done
     end
 
     it %[should wake up if interrupt! is called] do
@@ -43,12 +43,12 @@ describe ZK::NodeDeletionWatcher do
 
       @n.wait_until_blocked(5)
 
-      @n.should be_blocked
+      expect(@n).to be_blocked
 
       @n.interrupt!
-      th.join(5).should == th
+      expect(th.join(5)).to eq(th)
 
-      @exc.should be_kind_of(ZK::Exceptions::WakeUpException)
+      expect(@exc).to be_kind_of(ZK::Exceptions::WakeUpException)
     end
 
     it %[should raise LockWaitTimeoutError if we time out waiting for a node to be deleted] do
@@ -62,28 +62,28 @@ describe ZK::NodeDeletionWatcher do
         end
       end
 
-      @n.wait_until_blocked(5).should be_true
+      expect(@n.wait_until_blocked(5)).to be(true)
 
       logger.debug { "wait_until_blocked returned" }
 
-      th.join(5).should == th
-      
-      @exc.should be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
-      @n.should be_done
-      @n.should be_timed_out
+      expect(th.join(5)).to eq(th)
+
+      expect(@exc).to be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
+      expect(@n).to be_done
+      expect(@n).to be_timed_out
     end
   end
 
   describe %[when the node doesn't exist] do
     it %[should not block the caller and be done] do
-      @zk.exists?(@path).should be_false
+      expect(@zk.exists?(@path)).to be(false)
 
       th = Thread.new { @n.block_until_deleted }
 
       @n.wait_until_blocked
-      @n.should_not be_blocked
-      th.join(5).should == th
-      @n.should be_done
+      expect(@n).not_to be_blocked
+      expect(th.join(5)).to eq(th)
+      expect(@n).to be_done
     end
   end
 
@@ -140,23 +140,27 @@ describe ZK::NodeDeletionWatcher do
       runner.run
       controller.run
       controller.join
-      runner.join(5).should == runner
-      watcher.should be_done
+      expect(runner.join(5)).to eq(runner)
+      expect(watcher).to be_done
     end
 
     context %[threshold not supplied] do
       let(:watcher_params){}
 
       it 'should raise' do
-        expect{ watcher }.to_not raise_exception
+        expect{ watcher }.to_not raise_error
+      end
+
+      describe '#threshold' do
+        subject { super().threshold }
+        it { should be_zero }
       end
-      its(:threshold){ should be_zero }
     end
 
     context %[invalid threshold given] do
       let(:watcher_params){ {:threshold => :foo} }
       it 'should raise' do
-        expect{ watcher }.to raise_exception
+        expect{ watcher }.to raise_error(ZK::Exceptions::BadArguments)
       end
     end
 
@@ -168,10 +172,14 @@ describe ZK::NodeDeletionWatcher do
           runner.run
           controller.run
           controller.join
-          runner.join(5).should == runner
-          watcher.should be_done
+          expect(runner.join(5)).to eq(runner)
+          expect(watcher).to be_done
+        end
+
+        describe '#threshold' do
+          subject { super().threshold }
+          it { should == 1 }
         end
-        its(:threshold){ should == 1 }
       end
 
       context do
@@ -181,10 +189,10 @@ describe ZK::NodeDeletionWatcher do
           runner.run
           controller.run
           controller.join
-          runner.join(5).should == runner
-          @exc.should be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
-          watcher.should be_done
-          watcher.should be_timed_out
+          expect(runner.join(5)).to eq(runner)
+          expect(@exc).to be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
+          expect(watcher).to be_done
+          expect(watcher).to be_timed_out
         end
       end
     end

data/spec/zk/pool_spec.rb

@@ -8,7 +8,7 @@ describe ZK::Pool do
       report_realtime('opening pool') do
         @pool_size = 2
         @connection_pool = ZK::Pool::Simple.new(connection_host, @pool_size, :watcher => :default)
-        @connection_pool.should be_open
+        expect(@connection_pool).to be_open
       end
     end
 
@@ -22,7 +22,7 @@ describe ZK::Pool do
           unless th.join(5) == th
             logger.warn { "Forcing pool closed!" }
             @connection_pool.force_close!
-            th.join(5).should == th
+            expect(th.join(5)).to eq(th)
           end
         end
       end
@@ -40,7 +40,7 @@ describe ZK::Pool do
     it "should allow you to execute commands on a connection" do
       @connection_pool.with_connection do |zk|
         zk.create("/test_pool", "", :mode => :ephemeral)
-        zk.exists?("/test_pool").should be_true
+        expect(zk.exists?("/test_pool")).to be(true)
       end
     end
 
@@ -48,14 +48,12 @@ describe ZK::Pool do
       it %[should allow you to execute commands on the connection pool itself] do
         @connection_pool.create('/test_pool', '', :mode => :persistent)
         wait_until(2) { @connection_pool.exists?('/test_pool') }
-        @connection_pool.exists?('/test_pool').should be_true
+        expect(@connection_pool.exists?('/test_pool')).to be(true)
       end
     end
 
     describe :close_all! do
       it %[should shutdown gracefully] do
-        release_q  = Queue.new
-
         latch = Latch.new
 
         @about_to_block = false
@@ -76,30 +74,30 @@ describe ZK::Pool do
           @cond.wait(@mutex) while @cnx.nil?
         end
 
-        @cnx.should_not be_nil
+        expect(@cnx).not_to be_nil
 
         closing_th = Thread.new do
           @connection_pool.close_all!
         end
 
         wait_until(5) { @connection_pool.closing? }
-        @connection_pool.should be_closing
+        expect(@connection_pool).to be_closing
         logger.debug { "connection pool is closing" }
 
-        lambda { @connection_pool.with_connection { |c| c } }.should raise_error(ZK::Exceptions::PoolIsShuttingDownException)
+        expect { @connection_pool.with_connection { |c| c } }.to raise_error(ZK::Exceptions::PoolIsShuttingDownException)
 
         latch.release
 
-        open_th.join(5).should == open_th
+        expect(open_th.join(5)).to eq(open_th)
 
         @connection_pool.wait_until_closed
 
-        @connection_pool.should be_closed
+        expect(@connection_pool).to be_closed
 
-        lambda do
-          closing_th.join(1).should == closing_th
-          open_th.join(1).should == open_th
-        end.should_not raise_error
+        expect do
+          expect(closing_th.join(1)).to eq(closing_th)
+          expect(open_th.join(1)).to eq(open_th)
+        end.not_to raise_error
       end
     end
 
@@ -111,8 +109,8 @@ describe ZK::Pool do
           @cnx << @connection_pool.checkout
         end
 
-        @cnx.length.should_not be_zero
-        
+        expect(@cnx.length).not_to be_zero
+
         # this exc nonsense is because 1.8.7's scheduler is broken
         @exc = nil
 
@@ -131,8 +129,8 @@ describe ZK::Pool do
 
         @connection_pool.wait_until_closed
 
-        th.join(5).should == th
-        @exc.should be_kind_of(ZK::Exceptions::PoolIsShuttingDownException)
+        expect(th.join(5)).to eq(th)
+        expect(@exc).to be_kind_of(ZK::Exceptions::PoolIsShuttingDownException)
       end
     end
 
@@ -143,7 +141,7 @@ describe ZK::Pool do
 
       @connection_pool.with_connection do |zk|
         begin
-          zk.delete(@path) 
+          zk.delete(@path)
         rescue ZK::Exceptions::NoNode
         end
       end
@@ -152,63 +150,59 @@ describe ZK::Pool do
         zk.watcher.register(@path) do |event|
 
           @callback_called = true
-          event.path.should == @path
+          expect(event.path).to eq(@path)
         end
 
-        zk.exists?(@path, :watch => true).should be_false
+        expect(zk.exists?(@path, :watch => true)).to be(false)
       end
 
       @connection_pool.with_connection do |zk|
-        zk.create(@path, "", :mode => :ephemeral).should == @path
+        expect(zk.create(@path, "", :mode => :ephemeral)).to eq(@path)
       end
 
       wait_until(1) { @callback_called }
 
-      @callback_called.should be_true
+      expect(@callback_called).to be(true)
     end
 
     # These tests are seriously yucky, but they show that when a client is !connected?
     # the pool behaves properly and will not return that client to the caller.
-    
+
     describe 'health checking with disconnected client', :rbx => :broken do
       before do
         wait_until(2) { @connection_pool.available_size == 2 }
-        @connection_pool.available_size.should == 2
+        expect(@connection_pool.available_size).to eq(2)
 
         @connections = @connection_pool.connections
-        @connections.length.should == 2
+        expect(@connections.length).to eq(2)
 
         @cnx1 = @connections.shift
 
-        mock_sub = flexmock(:subscription)
+        mock_sub = double(:subscription)
 
-        @mcnx1 = flexmock(@cnx1) do |m|
-          m.should_receive(:connected?).at_least.once.and_return(false)
-          m.should_receive(:on_connected).with(Proc).at_least.once.and_return(mock_sub)
-        end
+        expect(@cnx1).to receive(:connected?).at_least(1).and_return(false)
+        expect(@cnx1).to receive(:on_connected).at_least(1).and_yield.and_return(mock_sub)
 
-        @connections.unshift(@mcnx1)
+        @connections.unshift(@cnx1)
       end
 
       after do
-        @connections.delete(@mcnx1)
-        @connections.unshift(@cnx1)
         [@cnx1, @cnx2].each { |c| @connection_pool.checkin(c) }
       end
 
       it %[should remove the disconnected client from the pool] do
-        @connection_pool.available_size.should == 2
+        expect(@connection_pool.available_size).to eq(2)
 
         @cnx2 = @connection_pool.checkout
-        
+
         # this is gross and relies on knowing internal state
-        @connection_pool.checkout(false).should be_false
+        expect(@connection_pool.checkout(false)).to be(false)
 
-        @cnx2.should_not be_nil
-        @cnx2.should_not == @mcnx1
+        expect(@cnx2).not_to be_nil
+        expect(@cnx2).not_to eq(@cnx1)
 
-        @connection_pool.available_size.should == 0
-        @connections.should include(@mcnx1)
+        expect(@connection_pool.available_size).to eq(0)
+        expect(@connections).to include(@cnx1)
       end
     end
   end # Simple
@@ -221,18 +215,18 @@ describe ZK::Pool do
       @max_clients = 2
       @timeout = 10
       @connection_pool = ZK::Pool::Bounded.new(connection_host, :min_clients => @min_clients, :max_clients => @max_clients, :timeout => @timeout)
-      @connection_pool.should be_open
+      expect(@connection_pool).to be_open
       wait_until(2) { @connection_pool.available_size > 0 }
     end
 
     after do
       @connection_pool.force_close! unless @connection_pool.closed?
-      @connection_pool.should be_closed
+      expect(@connection_pool).to be_closed
     end
 
     describe 'initial state' do
       it %[should have initialized the minimum number of clients] do
-        @connection_pool.size.should == @min_clients
+        expect(@connection_pool.size).to eq(@min_clients)
       end
     end
 
@@ -248,41 +242,38 @@ describe ZK::Pool do
 
       it %[should grow if it can] do
         wait_until(2) { @connection_pool.available_size > 0 }
-        @connection_pool.available_size.should > 0
+        expect(@connection_pool.available_size > 0).to be(true)
 
-        @connection_pool.size.should == 1
+        expect(@connection_pool.size).to eq(1)
 
         logger.debug { "checking out @cnx1" }
         @cnx1 = @connection_pool.checkout
-        @cnx1.should_not be_false
+        expect(@cnx1).not_to be(false)
 
-        @connection_pool.can_grow_pool?.should be_true
+        expect(@connection_pool.can_grow_pool?).to be(true)
 
         logger.debug { "checking out @cnx2" }
         @cnx2 = @connection_pool.checkout
-        @cnx2.should_not be_false
-        @cnx2.should be_connected
+        expect(@cnx2).not_to be(false)
+        expect(@cnx2).to be_connected
 
-        @cnx1.object_id.should_not == @cnx2.object_id
+        expect(@cnx1.object_id).not_to eq(@cnx2.object_id)
 
         [@cnx1, @cnx2].each { |c| @connection_pool.checkin(c) }
       end
 
       it %[should not grow past max_clients and block] do
-        win_q = Queue.new
         lose_q = Queue.new
 
-        threads = []
-
         @cnx1 = @connection_pool.checkout
-        @cnx1.should_not be_false
+        expect(@cnx1).not_to be(false)
 
-        @connection_pool.can_grow_pool?.should be_true
+        expect(@connection_pool.can_grow_pool?).to be(true)
 
         @cnx2 = @connection_pool.checkout
-        @cnx2.should_not be_false
+        expect(@cnx2).not_to be(false)
 
-        @connection_pool.can_grow_pool?.should be_false
+        expect(@connection_pool.can_grow_pool?).to be(false)
 
         logger.debug { "spawning losing thread" }
 
@@ -299,22 +290,22 @@ describe ZK::Pool do
         # logger.debug { "count waiters: #{@connection_pool.count_waiters}" }
         # @connection_pool.count_waiters.should == 1
 
-        loser[:cnx].should be_nil
+        expect(loser[:cnx]).to be_nil
 
         [@cnx1, @cnx2].each { |c| @connection_pool.checkin(c) }
 
         loser.join_until(2) { loser[:cnx] }
-        loser[:cnx].should_not be_nil
+        expect(loser[:cnx]).not_to be_nil
 
         lose_q.enq(:release)
 
-        lambda { loser.join(2).should == loser }.should_not raise_error
+        expect { expect(loser.join(2)).to eq(loser) }.not_to raise_error
 
         logger.debug { "joined losing thread" }
 
-        @connection_pool.count_waiters.should be_zero
-        @connection_pool.available_size.should == 2
-        @connection_pool.size.should == 2
+        expect(@connection_pool.count_waiters).to be_zero
+        expect(@connection_pool.available_size).to eq(2)
+        expect(@connection_pool.size).to eq(2)
       end
     end   # should grow to max_clients
 

data/spec/zk/threaded_callback_spec.rb

@@ -17,11 +17,11 @@ describe ZK::ThreadedCallback do
   end
 
   after do
-    @tcb.shutdown.should be_true
+    expect(@tcb.shutdown).to be(true)
   end
 
   it %[should have started the thread] do
-    @tcb.should be_alive
+    expect(@tcb).to be_alive
   end
 
   describe %[pausing for fork] do
@@ -31,19 +31,19 @@ describe ZK::ThreadedCallback do
       end
 
       it %[should stop the thread] do
-        @tcb.should_not be_alive
+        expect(@tcb).not_to be_alive
       end
 
       it %[should allow calls] do
-        lambda { @tcb.call(:a) }.should_not raise_error
+        expect { @tcb.call(:a) }.not_to raise_error
       end
     end
 
     describe %[when not running] do
       it %[should barf with InvalidStateError] do
-        @tcb.shutdown.should be_true
-        @tcb.should_not be_alive
-        lambda { @tcb.pause_before_fork_in_parent }.should raise_error(ZK::Exceptions::InvalidStateError)
+        expect(@tcb.shutdown).to be(true)
+        expect(@tcb).not_to be_alive
+        expect { @tcb.pause_before_fork_in_parent }.to raise_error(ZK::Exceptions::InvalidStateError)
       end
     end
   end
@@ -52,7 +52,7 @@ describe ZK::ThreadedCallback do
     describe %[after pause] do
       before do
         @tcb.pause_before_fork_in_parent
-        @tcb.should_not be_alive
+        expect(@tcb).not_to be_alive
       end
 
       it %[should deliver any calls on resume] do
@@ -65,13 +65,13 @@ describe ZK::ThreadedCallback do
 
         wait_until { @called.length >= 2 }
 
-        @called.length.should >= 2
+        expect(@called.length).to be >= 2
       end
     end
 
     describe %[if not paused] do
       it %[should barf with InvalidStateError] do
-        lambda { @tcb.resume_after_fork_in_parent }.should raise_error(ZK::Exceptions::InvalidStateError)
+        expect { @tcb.resume_after_fork_in_parent }.to raise_error(ZK::Exceptions::InvalidStateError)
       end
     end
   end

data/spec/zk/threadpool_spec.rb

@@ -11,11 +11,11 @@ describe ZK::Threadpool do
 
   describe :new do
     it %[should be running] do
-      @threadpool.should be_running
+      expect(@threadpool).to be_running
     end
 
     it %[should use the default size] do
-      @threadpool.size.should == ZK::Threadpool.default_size
+      expect(@threadpool.size).to eq(ZK::Threadpool.default_size)
     end
   end
 
@@ -27,19 +27,19 @@ describe ZK::Threadpool do
 
       wait_until(2) { @th }
 
-      @th.should_not == Thread.current
+      expect(@th).not_to eq(Thread.current)
     end
 
     it %[should barf if the argument is not callable] do
-      bad_obj = flexmock(:not_callable)
-      bad_obj.should_not respond_to(:call)
+      bad_obj = double(:not_callable)
+      expect(bad_obj).not_to respond_to(:call)
 
-      lambda { @threadpool.defer(bad_obj) }.should raise_error(ArgumentError)
+      expect { @threadpool.defer(bad_obj) }.to raise_error(ArgumentError)
     end
 
     it %[should not barf if the threadpool is not running] do
       @threadpool.shutdown
-      lambda { @threadpool.defer { "hai!" } }.should_not raise_error
+      expect { @threadpool.defer { "hai!" } }.not_to raise_error
     end
   end
 
@@ -48,42 +48,42 @@ describe ZK::Threadpool do
       @ary = []
 
       @threadpool.on_exception { |exc| @ary << exc }
-        
+
       @threadpool.defer { raise "ZOMG!" }
 
       wait_while(2) { @ary.empty? }
 
-      @ary.length.should == 1
+      expect(@ary.length).to eq(1)
 
       e = @ary.shift
 
-      e.should be_kind_of(RuntimeError)
-      e.message.should == 'ZOMG!'
+      expect(e).to be_kind_of(RuntimeError)
+      expect(e.message).to eq('ZOMG!')
     end
   end
 
   describe :shutdown do
     it %[should set running to false] do
       @threadpool.shutdown
-      @threadpool.should_not be_running
+      expect(@threadpool).not_to be_running
     end
   end
 
   describe :start! do
     it %[should be able to start a threadpool that had previously been shutdown (reuse)] do
       @threadpool.shutdown
-      @threadpool.start!.should be_true
+      expect(@threadpool.start!).to be(true)
 
-      @threadpool.should be_running
+      expect(@threadpool).to be_running
 
       @rval = nil
 
-      @threadpool.defer do 
+      @threadpool.defer do
         @rval = true
       end
 
       wait_until(2) { @rval }
-      @rval.should be_true
+      expect(@rval).to be(true)
     end
   end
 
@@ -93,24 +93,24 @@ describe ZK::Threadpool do
       @threadpool.defer { @a << @threadpool.on_threadpool? }
 
       wait_while(2) { @a.empty? }
-      @a.should_not be_empty
+      expect(@a).not_to be_empty
 
-      @a.first.should be_true
+      expect(@a.first).to be(true)
     end
   end
 
   describe :pause_before_fork_in_parent do
     it %[should stop all running threads] do
-      @threadpool.should be_running
-      @threadpool.should be_alive
+      expect(@threadpool).to be_running
+      expect(@threadpool).to be_alive
       @threadpool.pause_before_fork_in_parent
 
-      @threadpool.should_not be_alive
+      expect(@threadpool).not_to be_alive
     end
 
     it %[should raise InvalidStateError if already paused] do
       @threadpool.pause_before_fork_in_parent
-      lambda { @threadpool.pause_before_fork_in_parent }.should raise_error(ZK::Exceptions::InvalidStateError)
+      expect { @threadpool.pause_before_fork_in_parent }.to raise_error(ZK::Exceptions::InvalidStateError)
     end
   end
 
@@ -121,12 +121,12 @@ describe ZK::Threadpool do
 
     it %[should start all threads running again] do
       @threadpool.resume_after_fork_in_parent
-      @threadpool.should be_alive
+      expect(@threadpool).to be_alive
     end
 
     it %[should raise InvalidStateError if not in paused state] do
       @threadpool.shutdown
-      lambda { @threadpool.resume_after_fork_in_parent }.should raise_error(ZK::Exceptions::InvalidStateError)
+      expect { @threadpool.resume_after_fork_in_parent }.to raise_error(ZK::Exceptions::InvalidStateError)
     end
 
     it %[should run callbacks deferred while paused] do
@@ -147,7 +147,7 @@ describe ZK::Threadpool do
 
       latch.await(2)
 
-      calls.should_not be_empty
+      expect(calls).not_to be_empty
     end
   end
 end