zk 1.9.6 → 1.10.0

data/spec/shared/client_examples.rb

@@ -6,29 +6,29 @@ shared_examples_for 'client' do
       @path_ary = %W[#{base} test mkdir_p path creation]
       @bogus_path = File.join('', *@path_ary)
     end
-   
+
     it %[should create all intermediate paths for the path givem] do
-      @zk.should_not be_exists(@bogus_path)
-      @zk.should_not be_exists(File.dirname(@bogus_path))
+      expect(@zk.exists?(@bogus_path)).to be(false)
+      expect(@zk.exists?(File.dirname(@bogus_path))).to be(false)
       @zk.mkdir_p(@bogus_path)
-      @zk.should be_exists(@bogus_path)
+      expect(@zk.exists?(@bogus_path)).to be(true)
     end
 
     it %[should place the data only at the leaf node] do
       @zk.mkdir_p(@bogus_path, :data => 'foobar')
-      @zk.get(@bogus_path).first.should == 'foobar'
+      expect(@zk.get(@bogus_path).first).to eq('foobar')
 
       path = ''
       @path_ary[0..-2].each do |el|
         path = File.join(path, el)
-        @zk.get(path).first.should == ''
+        expect(@zk.get(path).first).to eq('')
       end
     end
 
     it %[should replace the data at the leaf node if it already exists] do
       @zk.mkdir_p(@bogus_path, :data => 'blahfoo')
       @zk.mkdir_p(@bogus_path, :data => 'foodink')
-      @zk.get(@bogus_path).first.should == 'foodink'
+      expect(@zk.get(@bogus_path).first).to eq('foodink')
     end
   end
 
@@ -37,14 +37,14 @@ shared_examples_for 'client' do
     describe 'only path given' do
       it %[should create a node with blank data] do
         @zk.create(@base_path)
-        @zk.get(@base_path).first.should == ''
+        expect(@zk.get(@base_path).first).to eq('')
       end
     end
 
     describe 'path and data given' do
       it %[should create a node with the path and data] do
         @zk.create(@base_path, 'blah')
-        @zk.get(@base_path).first.should == 'blah'
+        expect(@zk.get(@base_path).first).to eq('blah')
       end
     end
 
@@ -52,37 +52,37 @@ shared_examples_for 'client' do
       it %[should create a sequential node with blank data] do
         @zk.create(@base_path)
         path = @zk.create("#{@base_path}/v", :sequential => true)
-        path.start_with?(@base_path).should be_true
+        expect(path.start_with?(@base_path)).to be(true)
 
-        File.basename(path).should match(/v\d+/)
+        expect(File.basename(path)).to match(/v\d+/)
 
-        @zk.get(path).first.should == ''
+        expect(@zk.get(path).first).to eq('')
       end
 
       it %[should create a sequential node with given data] do
         @zk.create(@base_path)
         path = @zk.create("#{@base_path}/v", 'thedata', :sequential => true)
-        path.start_with?(@base_path).should be_true
+        expect(path.start_with?(@base_path)).to be(true)
 
-        File.basename(path).should match(/v\d+/)
+        expect(File.basename(path)).to match(/v\d+/)
 
         data, st = @zk.get(path)
-        data.should == 'thedata'
-        st.should_not be_ephemeral
+        expect(data).to eq('thedata')
+        expect(st).not_to be_ephemeral
       end
     end
 
     describe 'path and ephemeral' do
       it %[should create an ephemeral node with blank data] do
         @zk.create(@base_path, :ephemeral => true)
-        @zk.get(@base_path).last.should be_ephemeral
+        expect(@zk.get(@base_path).last).to be_ephemeral
       end
 
       it %[should create an ephemeral node with given data] do
         @zk.create(@base_path, 'thedata', :ephemeral => true)
         data, stat = @zk.get(@base_path)
-        data.should == 'thedata'
-        stat.should be_ephemeral
+        expect(data).to eq('thedata')
+        expect(stat).to be_ephemeral
       end
     end
 
@@ -90,45 +90,45 @@ shared_examples_for 'client' do
       it %[should create a sequential ephemeral node with blank data] do
         @zk.create(@base_path)
         path = @zk.create("#{@base_path}/v", :sequential => true, :ephemeral => true)
-        path.start_with?(@base_path).should be_true
+        expect(path.start_with?(@base_path)).to be(true)
 
-        File.basename(path).should match(/v\d+/)
+        expect(File.basename(path)).to match(/v\d+/)
 
         data, st = @zk.get(path)
-        data.should == ''
-        st.should be_ephemeral
+        expect(data).to eq('')
+        expect(st).to be_ephemeral
       end
 
       it %[should create a sequential ephemeral node with given data] do
         @zk.create(@base_path)
         path = @zk.create("#{@base_path}/v", 'thedata', :sequential => true, :ephemeral => true)
-        path.start_with?(@base_path).should be_true
+        expect(path.start_with?(@base_path)).to be(true)
 
-        File.basename(path).should match(/v\d+/)
+        expect(File.basename(path)).to match(/v\d+/)
 
         data, st = @zk.get(path)
-        data.should == 'thedata'
-        st.should be_ephemeral
+        expect(data).to eq('thedata')
+        expect(st).to be_ephemeral
       end
     end
 
     it %[should barf if someone hands 3 params] do
-      lambda { @zk.create(@base_path, 'data', :sequence) }.should raise_error(ArgumentError)
+      expect { @zk.create(@base_path, 'data', :sequence) }.to raise_error(ArgumentError)
     end
 
     it %[should barf if both :sequence and :sequential are given] do
-      lambda { @zk.create(@base_path, 'data', :sequence => true, :sequential => true) }.should raise_error(ArgumentError)
+      expect { @zk.create(@base_path, 'data', :sequence => true, :sequential => true) }.to raise_error(ArgumentError)
     end
 
     describe %[:ignore option] do
       it %[should squelch node_exists] do
         @zk.create(@base_path)
 
-        proc { @zk.create(@base_path, :ignore => :node_exists).should be_nil }.should_not raise_error(ZK::Exceptions::NoNode)
+        expect { expect(@zk.create(@base_path, :ignore => :node_exists)).to be_nil }.not_to raise_error
       end
 
       it %[should squelch no_node] do
-        proc { @zk.create("#{@base_path}/foo/bar/baz", :ignore => :no_node).should be_nil }.should_not raise_error(ZK::Exceptions::NoNode)
+        expect { expect(@zk.create("#{@base_path}/foo/bar/baz", :ignore => :no_node)).to be_nil }.not_to raise_error
       end
     end
 
@@ -136,11 +136,11 @@ shared_examples_for 'client' do
       let(:path) { "#{@base_path}/foo/bar" }
 
       it %[should barf if anything but the the :set value is given] do
-        proc { @zk.create(path, :or => :GFY) }.should raise_error(ArgumentError)
+        expect { @zk.create(path, :or => :GFY) }.to raise_error(ArgumentError)
       end
 
       def create_args(opts={})
-        proc do 
+        proc do
           begin
             @zk.create(path, opts.merge(:or => :set))
           ensure
@@ -150,24 +150,24 @@ shared_examples_for 'client' do
       end
 
       it %[should barf if any node option besides 'persistent' is given] do
-        create_args(:persistent => true).should_not         raise_error
-        create_args(:sequential => true).should             raise_error(ArgumentError)
-        create_args(:mode => :ephemeral).should             raise_error(ArgumentError)
-        create_args(:mode => :ephemeral_sequential).should  raise_error(ArgumentError)
-        create_args(:mode => :sequential).should            raise_error(ArgumentError)
+        expect(create_args(:persistent => true)).not_to         raise_error
+        expect(create_args(:sequential => true)).to             raise_error(ArgumentError)
+        expect(create_args(:mode => :ephemeral)).to             raise_error(ArgumentError)
+        expect(create_args(:mode => :ephemeral_sequential)).to  raise_error(ArgumentError)
+        expect(create_args(:mode => :sequential)).to            raise_error(ArgumentError)
       end
 
       it %[should replace the data at the leaf node if it already exists] do
         @zk.mkdir_p(path, :data => 'foodink')
         @zk.create(path, 'blahfoo', :or => :set)
-        @zk.get(path).first.should == 'blahfoo'
+        expect(@zk.get(path).first).to eq('blahfoo')
       end
 
       it %[should create the intermediate paths] do
-        proc { @zk.create(path, 'foobar', :or => :set) }.should_not raise_error
+        expect { @zk.create(path, 'foobar', :or => :set) }.not_to raise_error
 
-        @zk.stat(@base_path).should exist
-        @zk.stat("#{@base_path}/foo").should exist
+        expect(@zk.stat(@base_path)).to exist
+        expect(@zk.stat("#{@base_path}/foo")).to exist
       end
     end
   end
@@ -178,16 +178,16 @@ shared_examples_for 'client' do
         @zk.create(@base_path)
         @zk.create("#{@base_path}/blah")
 
-        proc { @zk.delete(@base_path, :ignore => :not_empty).should be_nil }.should_not raise_error
+        expect { expect(@zk.delete(@base_path, :ignore => :not_empty)).to be_nil }.not_to raise_error
       end
 
       it %[should squelch no_node] do
-        proc { @zk.delete("#{@base_path}/foo/bar/baz", :ignore => :no_node).should be_nil }.should_not raise_error
+        expect { expect(@zk.delete("#{@base_path}/foo/bar/baz", :ignore => :no_node)).to be_nil }.not_to raise_error
       end
 
       it %[should squelch bad_version] do
         @zk.create(@base_path)
-        proc { @zk.delete("#{@base_path}", :version => 7, :ignore => :bad_version).should be_nil }.should_not raise_error
+        expect { expect(@zk.delete("#{@base_path}", :version => 7, :ignore => :bad_version)).to be_nil }.not_to raise_error
       end
     end
   end
@@ -197,21 +197,21 @@ shared_examples_for 'client' do
       before do
         @missing_path = '/thispathdoesnotexist'
         begin
-          @zk.delete(@missing_path) 
+          @zk.delete(@missing_path)
         rescue ZK::Exceptions::NoNode
         end
       end
 
       it %[should not raise any error] do
-        lambda { @zk.stat(@missing_path) }.should_not raise_error
+        expect { @zk.stat(@missing_path) }.not_to raise_error
       end
 
       it %[should return a Stat object] do
-        @zk.stat(@missing_path).should be_kind_of(Zookeeper::Stat)
+        expect(@zk.stat(@missing_path)).to be_kind_of(Zookeeper::Stat)
       end
 
       it %[should return a stat that not exists?] do
-        @zk.stat(@missing_path).should_not be_exists
+        expect(@zk.stat(@missing_path)).not_to be_exists
       end
     end
   end
@@ -219,12 +219,12 @@ shared_examples_for 'client' do
   describe :set do
     describe %[:ignore option] do
       it %[should squelch no_node] do
-        proc { @zk.set("#{@base_path}/foo/bar/baz", '', :ignore => :no_node).should be_nil }.should_not raise_error
+        expect { expect(@zk.set("#{@base_path}/foo/bar/baz", '', :ignore => :no_node)).to be_nil }.not_to raise_error
       end
 
       it %[should squelch bad_version] do
         @zk.create(@base_path)
-        proc { @zk.set("#{@base_path}", '', :version => 7, :ignore => :bad_version).should be_nil }.should_not raise_error
+        expect { expect(@zk.set("#{@base_path}", '', :version => 7, :ignore => :bad_version)).to be_nil }.not_to raise_error
       end
     end
   end
@@ -236,7 +236,7 @@ shared_examples_for 'client' do
 
     describe 'no node initially' do
       before do
-        @zk.exists?(@path).should be_false
+        expect(@zk.exists?(@path)).to be(false)
       end
 
       it %[should not block] do
@@ -248,42 +248,42 @@ shared_examples_for 'client' do
         end
 
         th.join(2)
-        @a.should be_true
+        expect(@a).to be(true)
       end
     end
 
     describe 'node exists initially' do
       before do
         @zk.create(@path, :mode => :ephemeral)
-        @zk.exists?(@path).should be_true
+        expect(@zk.exists?(@path)).to be(true)
       end
 
       it %[should block until the node is deleted] do
         @a = false
 
-        th = Thread.new do
+        Thread.new do
           @zk.block_until_node_deleted(@path)
           @a = true
         end
 
         Thread.pass
-        @a.should be_false
+        expect(@a).to be(false)
 
         @zk.delete(@path)
 
         wait_until(2) { @a }
-        @a.should be_true
+        expect(@a).to be(true)
       end
     end
   end
 
   describe 'session_id and session_passwd' do
     it %[should expose the underlying session_id] do
-      @zk.session_id.should be_kind_of(Integer)
+      expect(@zk.session_id).to be_kind_of(Integer)
     end
 
     it %[should expose the underlying session_passwd] do
-      @zk.session_passwd.should be_kind_of(String)
+      expect(@zk.session_passwd).to be_kind_of(String)
     end
   end
 
@@ -296,22 +296,22 @@ shared_examples_for 'client' do
       end
 
 #       after do
-#         logger.info { "AFTER EACH" } 
+#         logger.info { "AFTER EACH" }
 #         @zk.delete(@path)
 #       end
 
       def ensure_event_delivery!
         @sub ||= @zk.event_handler.register(@path) do |event|
-          logger.debug { "got event: #{event.inspect}" } 
+          logger.debug { "got event: #{event.inspect}" }
           @queue << event
         end
 
-        @zk.exists?(@path, :watch => true).should be_false
+        expect(@zk.exists?(@path, :watch => true)).to be(false)
         @zk.create(@path)
 
-        logger.debug { "waiting for event delivery" } 
+        logger.debug { "waiting for event delivery" }
 
-        wait_until(2) do 
+        wait_until(2) do
           begin
             event = @queue.pop(true)
             logger.debug { "got event: #{event}" }
@@ -323,7 +323,7 @@ shared_examples_for 'client' do
         end
 
         # first watch delivered correctly
-        @events.length.should > 0
+        expect(@events.length).to be > 0
       end
 
       it %[should fire re-registered watchers after reopen (#9)] do
@@ -357,14 +357,14 @@ shared_examples_for 'client' do
       # note: we can't trust the events to be delivered in any particular order
       # since they're happening on two different threads. if we see we're connected
       # in the beginning, that there was a disconnection, then a reopen, that's
-      # probably fine. 
+      # probably fine.
       #
       # we also check that the session_id was changed, which is the desired effect
 
       orig_session_id = @zk.session_id
-      @zk.should be_connected
+      expect(@zk).to be_connected
 
-      props = { 
+      props = {
         :session_event?   => true,
         :node_event?      => false,
         :client_invalid?  => true,
@@ -372,8 +372,8 @@ shared_examples_for 'client' do
         :state            => Zookeeper::ZOO_EXPIRED_SESSION_STATE,
       }
 
-      bogus_event = flexmock(:expired_session_event, props)
-      bogus_event.should_receive(:zk=).with(@zk).once
+      bogus_event = instance_double(Zookeeper::Callbacks::WatcherCallback, props)
+      expect(bogus_event).to receive(:zk=).with(@zk).once
 
       mutex = Monitor.new
       cond  = mutex.new_cond
@@ -388,20 +388,20 @@ shared_examples_for 'client' do
       end
 
       mutex.synchronize do
-        events.should be_empty
+        expect(events).to be_empty
         @zk.event_handler.process(bogus_event)
       end
 
-      logger.debug { "events: #{events.inspect}" } 
+      logger.debug { "events: #{events.inspect}" }
 
       mutex.synchronize do
         time_to_stop = Time.now + 2
         cond.wait_while { (events.length < 2 ) && (Time.now < time_to_stop) }
       end
 
-      events.should include(Zookeeper::ZOO_EXPIRED_SESSION_STATE) 
-      events.should include(Zookeeper::ZOO_CONNECTED_STATE)
-      @zk.session_id.should_not == orig_session_id
+      expect(events).to include(Zookeeper::ZOO_EXPIRED_SESSION_STATE)
+      expect(events).to include(Zookeeper::ZOO_CONNECTED_STATE)
+      expect(@zk.session_id).not_to eq(orig_session_id)
     end
   end # reconnection
 
@@ -410,17 +410,17 @@ shared_examples_for 'client' do
       @ary = []
 
       @zk.on_exception { |exc| @ary << exc }
-        
+
       @zk.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
 
@@ -431,8 +431,8 @@ shared_examples_for 'client' do
       @zk.defer { @ary << @zk.on_threadpool? }
 
       wait_while(2) { @ary.empty? }
-      @ary.length.should == 1
-      @ary.first.should be_true
+      expect(@ary.length).to eq(1)
+      expect(@ary.first).to be(true)
     end
   end
 end

data/spec/shared/locker_examples.rb

@@ -6,50 +6,50 @@
 shared_examples_for 'LockerBase#assert!' do
   it %[should raise LockAssertionFailedError if its connection is no longer connected?] do
     zk.close!
-    lambda { locker.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+    expect { locker.assert! }.to raise_error(ZK::Exceptions::LockAssertionFailedError)
   end
 
   it %[should raise LockAssertionFailedError if locked? is false] do
-    locker.should_not be_locked
-    lambda { locker.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+    expect(locker).not_to be_locked
+    expect { locker.assert! }.to raise_error(ZK::Exceptions::LockAssertionFailedError)
   end
 
   it %[should raise LockAssertionFailedError lock_path does not exist] do
     locker.lock
-    lambda { locker.assert! }.should_not raise_error
+    expect { locker.assert! }.not_to raise_error
 
     zk.delete(locker.lock_path)
-    lambda { locker.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+    expect { locker.assert! }.to raise_error(ZK::Exceptions::LockAssertionFailedError)
   end
 
   it %[should raise LockAssertionFailedError if our parent node's ctime is different than what we think it should be] do
-    locker.lock.should be_true
+    expect(locker.lock).to be(true)
 
     zk.rm_rf(File.dirname(locker.lock_path)) # remove the parent node
     zk.mkdir_p(locker.lock_path)
 
-    lambda { locker.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+    expect { locker.assert! }.to raise_error(ZK::Exceptions::LockAssertionFailedError)
   end
 end
 
 shared_examples_for 'LockerBase#unlock' do
   it %[should not delete a lock path it does not own] do
-    locker.lock.should be_true
+    expect(locker.lock).to be(true)
 
     zk.rm_rf(File.dirname(locker.lock_path)) # remove the parent node
     zk.mkdir_p(File.dirname(locker.lock_path))
 
-    locker2.lock.should be_true
+    expect(locker2.lock).to be(true)
 
-    locker2.lock_path.should == locker.lock_path
+    expect(locker2.lock_path).to eq(locker.lock_path)
 
-    lambda { locker2.assert! }.should_not raise_error
+    expect { locker2.assert! }.not_to raise_error
 
     lock_path = locker.lock_path
 
-    locker.unlock.should be_false
+    expect(locker.unlock).to be(false)
 
-    zk.stat(lock_path).should exist
+    expect(zk.stat(lock_path)).to exist
   end
 end
 

data/spec/spec_helper.rb

@@ -9,11 +9,11 @@ if File.exists?(release_ops_path)
   ReleaseOps::SimpleCov.maybe_start
 end
 
-
 Bundler.require(:development, :test)
 
 require 'zk'
 require 'benchmark'
+require 'pry'
 
 # Requires supporting ruby files with custom matchers and macros, etc,
 # in spec/support/ and its subdirectories.
@@ -21,11 +21,10 @@ Dir[File.expand_path("../{support,shared}/**/*.rb", __FILE__)].sort.each {|f| re
 
 $stderr.sync = true
 
-require 'flexmock'
-
 RSpec.configure do |config|
-  config.mock_with :flexmock
-  config.include(FlexMock::ArgumentTypes)
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
 
   [WaitWatchers, SpecGlobalLogger, Pendings].each do |mod|
     config.include(mod)
@@ -48,7 +47,7 @@ RSpec.configure do |config|
   if ZK.spawn_zookeeper?
     require 'zk-server'
 
-    config.before(:suite) do 
+    config.before(:suite) do
       SpecGlobalLogger.logger.debug { "Starting zookeeper service" }
       ZK::Server.run do |c|
         c.client_port = ZK.test_port
@@ -68,24 +67,24 @@ RSpec.configure do |config|
     count = 0
     ObjectSpace.each_object(klass) { |o| count += 1 if tester.call(o) }
     unless count.zero?
-      raise "There were #{count} leaked #{klass} objects after #{example.full_description.inspect}" 
+      raise "There were #{count} leaked #{klass} objects after #{example.full_description.inspect}"
     end
   end
 
   # these make tests run slow
   if ENV['ZK_LEAK_CHECK']
-    config.after do 
+    config.after do
       leak_check(ZK::Client::Threaded) { |o| !o.closed? }
       leak_check(ZK::ThreadedCallback, &:alive?)
       leak_check(ZK::Threadpool, &:alive?)
       leak_check(Thread) { |th| Thread.current != th && th.alive? }
-      ZK::ForkHook.hooks.values.flatten.should be_empty
+      expect(ZK::ForkHook.hooks.values.flatten).to be_empty
     end
   end
 end
 
 class ::Thread
-  # join with thread until given block is true, the thread joins successfully, 
+  # join with thread until given block is true, the thread joins successfully,
   # or timeout seconds have passed
   #
   def join_until(timeout=2)
@@ -97,7 +96,7 @@ class ::Thread
       Thread.pass
     end
   end
-  
+
   def join_while(timeout=2)
     time_to_stop = Time.now + timeout
 

data/spec/zk/00_forked_client_integration_spec.rb

@@ -23,9 +23,9 @@ describe 'forked client integration' do
     it %[should deliver callbacks in the child] do
       10.times do 
         ClientForker.run(@cnx_args, @base_path) do |forker|
-          forker.stat.should_not be_signaled
-          forker.stat.should be_exited
-          forker.stat.should be_success
+          expect(forker.stat).not_to be_signaled
+          expect(forker.stat).to be_exited
+          expect(forker.stat).to be_success
         end
       end
     end # should deliver callbacks in the child

data/spec/zk/client/locking_and_session_death_spec.rb

@@ -42,9 +42,9 @@ shared_examples_for 'session death' do
     deliver_session_event_to(zoo_state, @other_zk)
 
     # ditto, this is probably happening synchrnously
-    wait_until(2) { @a }.should be_true
+    expect(wait_until(2) { @a }).to be(true)
 
-    lambda { th.join(2) }.should raise_error(zoo_error_class)
+    expect { th.join(2) }.to raise_error(zoo_error_class)
   end
 end # session death