slyphon-zookeeper 0.3.0 → 0.8.0.rc.1

data/spec/spec_helper.rb

@@ -9,34 +9,57 @@ gem 'flexmock', '~> 0.8.11'
 require 'flexmock'
 require 'zookeeper'
 
-Zookeeper.logger = Logger.new(File.expand_path('../../test.log', __FILE__)).tap do |log|
-  log.level = Logger::DEBUG
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].sort.each { |f| require(f) }
+
+if ENV['ZKRB_DEBUG']
+  Zookeeper.logger = Logger.new($stderr).tap { |l| l.level = Logger::DEBUG }
+  Zookeeper.set_debug_level(4)
+else
+  Zookeeper.logger = Logger.new(File.expand_path('../../test.log', __FILE__)).tap do |log|
+    log.level = Logger::DEBUG
+  end
 end
 
-Dir[File.expand_path('../support/**/*.rb', __FILE__)].sort.each { |f| require(f) }
+if ENV['ZKRB_NOLOG']
+  Zookeeper.logger.level = Logger::FATAL
+  Zookeeper.set_debug_level(0)
+end
+
+module ZookeeperSpecHeleprs
+  class TimeoutError < StandardError; end
 
-# NOTE: this is a useful debugging setup. have our logs and the low-level C
-# logging statements both go to stderr. to use, comment the above and uncomment
-# below
+  def logger
+    Zookeeper.logger
+  end
 
-# Zookeeper.logger = Logger.new($stderr).tap { |l| l.level = Logger::DEBUG }
-# Zookeeper.set_debug_level(4)
+  # method to wait until block passed returns true or timeout (default is 10 seconds) is reached 
+  # raises TiemoutError on timeout
+  def wait_until(timeout=10)
+    time_to_stop = Time.now + timeout
+    while true
+      rval = yield
+      return rval if rval
+      raise TimeoutError, "timeout of #{timeout}s exceeded" if Time.now > time_to_stop
+      Thread.pass
+    end
+  end
 
-def logger
-  Zookeeper.logger
+  # inverse of wait_until
+  def wait_while(timeout=10)
+    time_to_stop = Time.now + timeout
+    while true
+      rval = yield
+      return rval unless rval
+      raise TimeoutError, "timeout of #{timeout}s exceeded" if Time.now > time_to_stop
+      Thread.pass
+    end
+  end
 end
 
 RSpec.configure do |config|
   config.mock_with :flexmock
+  config.include ZookeeperSpecHeleprs
+  config.extend ZookeeperSpecHeleprs
 end
 
 
-# method to wait until block passed returns true or timeout (default is 10 seconds) is reached 
-def wait_until(timeout=10, &block)
-  time_to_stop = Time.now + timeout
-  until yield do 
-    break if Time.now > time_to_stop
-    sleep 0.3
-  end
-end
-

data/spec/zookeeper_spec.rb

@@ -1,1049 +1,24 @@
 require 'spec_helper'
+require 'shared/connection_examples'
 
-shared_examples_for "all success return values" do
-  it %[should have a return code of Zookeeper::ZOK] do
-    @rv[:rc].should == Zookeeper::ZOK
-  end
-
-  it %[should have a req_id integer] do
-    @rv[:req_id].should be_kind_of(Integer)
-  end
-end
-
-shared_examples_for "all" do
-  def ensure_node(path, data)
-    if zk.stat(:path => path)[:stat].exists?
-      zk.set(:path => path, :data => data)
-    else
-      zk.create(:path => path, :data => data)
-    end
-  end
-
-  before :each do
-    ensure_node(path, data)
-  end
-
-  after :each do
-    ensure_node(path, data)
-  end
-
-  after :all do
-    Zookeeper.logger.warn "running shared examples after :all"
-    # close the chrooted connection
-    zk.delete(:path => path)
-    zk.close
-
-    wait_until do 
-      begin
-        !zk.connected?
-      rescue RuntimeError
-        true
-      end
-    end
-  end
-
-  # unfortunately, we can't test w/o exercising other parts of the driver, so
-  # if "set" is broken, this test will fail as well (but whaddyagonnado?)
-  describe :get do
-    describe :sync do
-      it_should_behave_like "all success return values"
-
-      before do
-        @rv = zk.get(:path => path)
-      end
-
-      it %[should return the data] do
-        @rv[:data].should == data
-      end
-
-      it %[should return a stat] do
-        @rv[:stat].should_not be_nil
-        @rv[:stat].should be_kind_of(ZookeeperStat::Stat)
-      end
-    end
-
-    describe :sync_watch do
-      it_should_behave_like "all success return values"
-
-      before do
-        @event = nil
-        @watcher = Zookeeper::WatcherCallback.new
-
-        @rv = zk.get(:path => path, :watcher => @watcher, :watcher_context => path) 
-      end
-
-      it %[should return the data] do
-        @rv[:data].should == data
-      end
-
-      it %[should set a watcher on the node] do
-        # test the watcher by changing node data
-        zk.set(:path => path, :data => 'blah')[:rc].should be_zero
-
-        wait_until(1.0) { @watcher.completed? }
-
-        @watcher.path.should == path
-        @watcher.context.should == path
-        @watcher.should be_completed
-        @watcher.type.should == Zookeeper::ZOO_CHANGED_EVENT
-      end
-    end
-
-    describe :async do
-      before do
-        @cb = Zookeeper::DataCallback.new
-
-        @rv = zk.get(:path => path, :callback => @cb, :callback_context => path)
-        wait_until(1.0) { @cb.completed? }
-        @cb.should be_completed
-      end
-
-      it_should_behave_like "all success return values"
-
-      it %[should have a return code of ZOK] do
-        @cb.return_code.should == Zookeeper::ZOK
-      end
-
-      it %[should have the stat object in the callback] do
-        @cb.stat.should_not be_nil
-        @cb.stat.should be_kind_of(ZookeeperStat::Stat)
-      end
-
-      it %[should have the data] do
-        @cb.data.should == data
-      end
-    end
-
-    describe :async_watch do
-      it_should_behave_like "all success return values"
-
-      before do
-        @cb = Zookeeper::DataCallback.new
-        @watcher = Zookeeper::WatcherCallback.new
-
-        @rv = zk.get(:path => path, :callback => @cb, :callback_context => path, :watcher => @watcher, :watcher_context => path)
-        wait_until(1.0) { @cb.completed? }
-        @cb.should be_completed
-      end
-
-      it %[should have the stat object in the callback] do
-        @cb.stat.should_not be_nil
-        @cb.stat.should be_kind_of(ZookeeperStat::Stat)
-      end
-
-      it %[should have the data] do
-        @cb.data.should == data
-      end
-
-      it %[should have a return code of ZOK] do
-        @cb.return_code.should == Zookeeper::ZOK
-      end
-
-      it %[should set a watcher on the node] do
-        zk.set(:path => path, :data => 'blah')[:rc].should be_zero
-
-        wait_until(2) { @watcher.completed? }
-
-        @watcher.should be_completed
-
-        @watcher.path.should == path
-        @watcher.context.should == path
-      end
-    end
-
-    describe 'bad arguments' do
-      it %[should barf with a BadArguments error] do
-        lambda { zk.get(:bad_arg => 'what!?') }.should raise_error(ZookeeperExceptions::ZookeeperException::BadArguments)
-      end
-    end
-  end   # get
-
-  describe :set do
-    before do
-      @new_data = "Four score and \007 years ago"
-      @stat = zk.stat(:path => path)[:stat]
-    end
-
-    describe :sync do
-      describe 'without version' do
-        it_should_behave_like "all success return values"
-
-        before do
-          @rv = zk.set(:path => path, :data => @new_data)
-        end
-
-        it %[should return the new stat] do
-          @rv[:stat].should_not be_nil
-          @rv[:stat].should be_kind_of(ZookeeperStat::Stat)
-          @rv[:stat].version.should > @stat.version
-        end
-      end
-
-      describe 'with current version' do
-        it_should_behave_like "all success return values"
-
-        before do
-          @rv = zk.set(:path => path, :data => @new_data, :version => @stat.version)
-        end
-
-        it %[should return the new stat] do
-          @rv[:stat].should_not be_nil
-          @rv[:stat].should be_kind_of(ZookeeperStat::Stat)
-          @rv[:stat].version.should > @stat.version
-        end
-      end
-
-      describe 'with outdated version' do
-        before do
-          # need to do a couple of sets to ramp up the version
-          3.times { |n| @stat = zk.set(:path => path, :data => "#{@new_data}#{n}")[:stat] }
-
-          @rv = zk.set(:path => path, :data => @new_data, :version => 0)
-        end
-
-        it %[should have a return code of ZBADVERSION] do
-          @rv[:rc].should == Zookeeper::ZBADVERSION
-        end
-
-        it %[should return a stat with !exists] do
-          @rv[:stat].exists.should be_false
-        end
-      end
-
-      describe 'error' do
-        it %[should barf if the data size is too large], :input_size => true do
-          large_data = '0' * (1024 ** 2)
-
-          lambda { zk.set(:path => path, :data => large_data) }.should raise_error(ZookeeperExceptions::ZookeeperException::DataTooLargeException)
-        end
-      end
-    end   # sync
-
-    describe :async do
-      before do
-        @cb = Zookeeper::StatCallback.new
-      end
-
-      describe 'without version' do
-        it_should_behave_like "all success return values"
-
-        before do
-          @rv = zk.set(:path => path, :data => @new_data, :callback => @cb, :callback_context => path)
-
-          wait_until(2) { @cb.completed? }
-          @cb.should be_completed
-        end
-
-        it %[should have the stat in the callback] do
-          @cb.stat.should_not be_nil
-          @cb.stat.version.should > @stat.version
-        end
-
-        it %[should have a return code of ZOK] do
-          @cb.return_code.should == Zookeeper::ZOK
-        end
-      end
-
-      describe 'with current version' do
-        it_should_behave_like "all success return values"
-
-        before do
-          @rv = zk.set(:path => path, :data => @new_data, :callback => @cb, :callback_context => path, :version => @stat.version)
-
-          wait_until(2) { @cb.completed? }
-          @cb.should be_completed
-        end
-
-        it %[should have the stat in the callback] do
-          @cb.stat.should_not be_nil
-          @cb.stat.version.should > @stat.version
-        end
-
-        it %[should have a return code of ZOK] do
-          @cb.return_code.should == Zookeeper::ZOK
-        end
-      end
-
-      describe 'with outdated version' do
-        before do
-          # need to do a couple of sets to ramp up the version
-          3.times { |n| @stat = zk.set(:path => path, :data => "#{@new_data}#{n}")[:stat] }
-
-          @rv = zk.set(:path => path, :data => @new_data, :callback => @cb, :callback_context => path, :version => 0)
-
-          wait_until(2) { @cb.completed? }
-          @cb.should be_completed
-        end
-
-        it %[should have a return code of ZBADVERSION] do
-          @cb.return_code.should == Zookeeper::ZBADVERSION
-        end
-
-        it %[should return a stat with !exists] do
-          @cb.stat.exists.should be_false
-        end
-      end
-
-      describe 'error' do
-        it %[should barf if the data size is too large], :input_size => true do
-          large_data = '0' * (1024 ** 2)
-
-          lambda { zk.set(:path => path, :data => large_data, :callback => @cb, :callback_context => path) }.should raise_error(ZookeeperExceptions::ZookeeperException::DataTooLargeException)
-        end
-      end
-
-    end # async
-  end # set
-
-  describe :get_children do
-    before do
-      @children = %w[child0 child1 child2]
-
-      @children.each do |name|
-        zk.create(:path => "#{path}/#{name}", :data => name)
-      end
-    end
-
-    after do
-      @children.each do |name|
-        zk.delete(:path => "#{path}/#{name}")
-      end
-    end
-
-    describe :sync do
-      it_should_behave_like "all success return values"
-
-      before do
-        @rv = zk.get_children(:path => path)
-      end
-
-      it %[should have an array of names of the children] do
-        @rv[:children].should be_kind_of(Array)
-        @rv[:children].length.should == 3
-        @rv[:children].sort.should == @children.sort 
-      end
-
-      # "Three shall be the number of the counting, and the number of the counting shall be 3"
-
-      it %[should have a stat object whose num_children is 3] do
-        @rv[:stat].should_not be_nil
-        @rv[:stat].should be_kind_of(ZookeeperStat::Stat)
-        @rv[:stat].num_children.should == 3
-      end
-    end
-
-    describe :sync_watch do
-      it_should_behave_like "all success return values"
-
-      before do
-        @addtl_child = 'child3'
-
-        @watcher = Zookeeper::WatcherCallback.new
-
-        @rv = zk.get_children(:path => path, :watcher => @watcher, :watcher_context => path)
-      end
-
-      after do
-        zk.delete(:path => "#{path}/#{@addtl_child}")
-      end
-
-      it %[should have an array of names of the children] do
-        @rv[:children].should be_kind_of(Array)
-        @rv[:children].length.should == 3
-        @rv[:children].sort.should == @children.sort 
-      end
-
-      it %[should have a stat object whose num_children is 3] do
-        @rv[:stat].should_not be_nil
-        @rv[:stat].should be_kind_of(ZookeeperStat::Stat)
-        @rv[:stat].num_children.should == 3
-      end
-
-      it %[should set a watcher for children on the node] do
-        @watcher.should_not be_completed
-
-        zk.create(:path => "#{path}/#{@addtl_child}", :data => '')[:rc].should == Zookeeper::ZOK
-
-        wait_until { @watcher.completed? }
-        @watcher.should be_completed
-
-        @watcher.path.should == path
-        @watcher.context.should == path
-        @watcher.type.should == Zookeeper::ZOO_CHILD_EVENT
-      end
-    end
-
-    describe :async do
-      it_should_behave_like "all success return values"
-
-      before do
-        @cb = ZookeeperCallbacks::StringsCallback.new
-        @rv = zk.get_children(:path => path, :callback => @cb, :callback_context => path)
-
-        wait_until { @cb.completed? }
-        @cb.should be_completed
-      end
-
-      it %[should succeed] do
-        @cb.return_code.should == Zookeeper::ZOK
-      end
-
-      it %[should return an array of children] do
-        @cb.children.should be_kind_of(Array)
-        @cb.children.length.should == 3
-        @cb.children.sort.should == @children.sort 
-      end
-
-      it %[should have a stat object whose num_children is 3] do
-        @cb.stat.should_not be_nil
-        @cb.stat.should be_kind_of(ZookeeperStat::Stat)
-        @cb.stat.num_children.should == 3
-      end
-    end
-
-    describe :async_watch do
-      it_should_behave_like "all success return values"
-
-      before do
-        @addtl_child = 'child3'
-
-        @watcher = Zookeeper::WatcherCallback.new
-        @cb = ZookeeperCallbacks::StringsCallback.new
-
-        @rv = zk.get_children(:path => path, :watcher => @watcher, :watcher_context => path, :callback => @cb, :callback_context => path)
-        wait_until { @cb.completed? }
-        @cb.should be_completed
-      end
-
-      after do
-        zk.delete(:path => "#{path}/#{@addtl_child}")
-      end
-
-      it %[should succeed] do
-        @cb.return_code.should == Zookeeper::ZOK
-      end
-
-      it %[should return an array of children] do
-        @cb.children.should be_kind_of(Array)
-        @cb.children.length.should == 3
-        @cb.children.sort.should == @children.sort 
-      end
-
-      it %[should have a stat object whose num_children is 3] do
-        @cb.stat.should_not be_nil
-        @cb.stat.should be_kind_of(ZookeeperStat::Stat)
-        @cb.stat.num_children.should == 3
-      end
-
-      it %[should set a watcher for children on the node] do
-        @watcher.should_not be_completed
-
-        zk.create(:path => "#{path}/#{@addtl_child}", :data => '')[:rc].should == Zookeeper::ZOK
-
-        wait_until { @watcher.completed? }
-        @watcher.should be_completed
-
-        @watcher.path.should == path
-        @watcher.context.should == path
-        @watcher.type.should == Zookeeper::ZOO_CHILD_EVENT
-      end
-    end
-  end
-
-  # NOTE: the jruby version of stat on non-existent node will have a
-  # return_code of 0, but the C version will have a return_code of -101
-  describe :stat do
-    describe :sync do
-      it_should_behave_like "all success return values"
-
-      before do
-        @rv = zk.stat(:path => path)
-      end
-
-      it %[should have a stat object] do
-        @rv[:stat].should be_kind_of(Zookeeper::Stat)
-      end
-    end
-
-    describe :sync_watch do
-      it_should_behave_like "all success return values"
-
-      before do
-        @watcher = Zookeeper::WatcherCallback.new
-
-        @rv = zk.stat(:path => path, :watcher => @watcher, :watcher_context => path)
-      end
-
-      it %[should have a stat object] do
-        @rv[:stat].should be_kind_of(Zookeeper::Stat)
-      end
-
-      it %[should set a watcher for data changes on the node] do
-        @watcher.should_not be_completed
-
-        zk.set(:path => path, :data => 'skunk')[:rc].should == Zookeeper::ZOK
-
-        wait_until { @watcher.completed? }
-        @watcher.should be_completed
-
-        @watcher.path.should == path
-        @watcher.context.should == path
-        @watcher.type.should == Zookeeper::ZOO_CHANGED_EVENT
-      end
-    end
-
-    describe :async do
-      it_should_behave_like "all success return values"
-
-      before do
-        @cb = ZookeeperCallbacks::StatCallback.new
-        @rv = zk.stat(:path => path, :callback => @cb, :callback_context => path)
-
-        wait_until { @cb.completed? }
-        @cb.should be_completed
-      end
-
-      it %[should succeed] do
-        @cb.return_code.should == Zookeeper::ZOK
-      end
-
-      it %[should have a stat object] do
-        @cb.stat.should be_kind_of(Zookeeper::Stat)
-      end
-    end
-
-    describe :async_watch do
-      it_should_behave_like "all success return values"
-
-      before do
-        @addtl_child = 'child3'
-
-        @watcher = Zookeeper::WatcherCallback.new
-
-        @cb = ZookeeperCallbacks::StatCallback.new
-        @rv = zk.stat(:path => path, :callback => @cb, :callback_context => path, :watcher => @watcher, :watcher_context => path)
-
-        wait_until { @cb.completed? }
-        @cb.should be_completed
-      end
-
-      after do
-        zk.delete(:path => "#{path}/#{@addtl_child}")
-      end
-
-      it %[should succeed] do
-        @cb.return_code.should == Zookeeper::ZOK
-      end
-
-      it %[should have a stat object] do
-        @cb.stat.should be_kind_of(Zookeeper::Stat)
-      end
-
-      it %[should set a watcher for data changes on the node] do
-        @watcher.should_not be_completed
-
-        zk.set(:path => path, :data => 'skunk')[:rc].should == Zookeeper::ZOK
-
-        wait_until { @watcher.completed? }
-        @watcher.should be_completed
-
-        @watcher.path.should == path
-        @watcher.context.should == path
-        @watcher.type.should == Zookeeper::ZOO_CHANGED_EVENT
-      end
-    end
-  end   # stat
-
-  describe :create do
-    before do
-      # remove the path set up by the global 'before' block
-      zk.delete(:path => path)
-    end
-
-    describe :sync do
-      describe 'error' do
-        it %[should barf if the data size is too large], :input_size => true do
-          large_data = '0' * (1024 ** 2)
-
-          lambda { zk.create(:path => path, :data => large_data) }.should raise_error(ZookeeperExceptions::ZookeeperException::DataTooLargeException)
-        end
-      end
-
-      describe :default_flags do
-        it_should_behave_like "all success return values"
-
-        before do
-          @rv = zk.create(:path => path)
-        end
-
-        it %[should return the path that was set] do
-          @rv[:path].should == path
-        end
-
-        it %[should have created a permanent node] do
-          st = zk.stat(:path => path)
-          st[:rc].should == Zookeeper::ZOK
-
-          st[:stat].ephemeral_owner.should == 0
-        end
-      end
-
-      describe :ephemeral do
-        it_should_behave_like "all success return values"
-
-        before do
-          @rv = zk.create(:path => path, :ephemeral => true)
-        end
-
-        it %[should return the path that was set] do
-          @rv[:path].should == path
-        end
-
-        it %[should have created a ephemeral node] do
-          st = zk.stat(:path => path)
-          st[:rc].should == Zookeeper::ZOK
-
-          st[:stat].ephemeral_owner.should_not be_zero
-        end
-      end
-
-      describe :sequence do
-        it_should_behave_like "all success return values"
-
-        before do
-          @orig_path  = path
-          @rv         = zk.create(:path => path, :sequence => true)
-          @s_path     = @rv[:path]    # make sure this gets cleaned up
-        end
-
-        after do
-          zk.delete(:path => @s_path)
-        end
-
-        it %[should return the path that was set] do
-          @rv[:path].should_not == @orig_path
-        end
-
-        it %[should have created a permanent node] do
-          st = zk.stat(:path => @s_path)
-          st[:rc].should == Zookeeper::ZOK
-
-          st[:stat].ephemeral_owner.should be_zero
-        end
-      end
-
-      describe :ephemeral_sequence do
-        it_should_behave_like "all success return values"
-
-        before do
-          @orig_path  = path
-          @rv         = zk.create(:path => path, :sequence => true, :ephemeral => true)
-          @s_path     = @rv[:path]    # make sure this gets cleaned up
-        end
-
-        after do
-          zk.delete(:path => @s_path)
-        end
-
-        it %[should return the path that was set] do
-          @rv[:path].should_not == @orig_path
-        end
-
-        it %[should have created an ephemeral node] do
-          st = zk.stat(:path => @s_path)
-          st[:rc].should == Zookeeper::ZOK
-
-          st[:stat].ephemeral_owner.should_not be_zero
-        end
-      end
-
-      describe :acl do
-        it %[should work] do
-          pending "need to write acl tests"
-        end
-      end
-    end
-
-    describe :async do
-      before do
-        @cb = ZookeeperCallbacks::StringCallback.new
-      end
-
-      describe :default_flags do
-        it_should_behave_like "all success return values"
-
-        before do
-          @rv = zk.create(:path => path, :callback => @cb, :callback_context => path)
-          wait_until(2) { @cb.completed? }
-          @cb.should be_completed
-        end
-
-        it %[should have a path] do
-          @cb.path.should_not be_nil
-        end
-
-        it %[should return the path that was set] do
-          @cb.path.should == path
-        end
-
-        it %[should have created a permanent node] do
-          st = zk.stat(:path => path)
-          st[:rc].should == Zookeeper::ZOK
-
-          st[:stat].ephemeral_owner.should == 0
-        end
-      end
-
-      describe 'error' do
-        it %[should barf if the data size is too large], :input_size => true do
-          large_data = '0' * (1024 ** 2)
-
-          lambda do
-            zk.create(:path => path, :data => large_data, :callback => @cb, :callback_context => path)
-          end.should raise_error(ZookeeperExceptions::ZookeeperException::DataTooLargeException)
-        end
-      end
-
-
-      describe :ephemeral do
-        it_should_behave_like "all success return values"
-
-        before do
-          @rv = zk.create(:path => path, :ephemeral => true, :callback => @cb, :callback_context => path)
-          wait_until(2) { @cb.completed? }
-          @cb.should be_completed
-        end
-
-        it %[should have a path] do
-          @cb.path.should_not be_nil
-        end
-
-        it %[should return the path that was set] do
-          @cb.path.should == path
-        end
-
-        it %[should have created a ephemeral node] do
-          st = zk.stat(:path => path)
-          st[:rc].should == Zookeeper::ZOK
-
-          st[:stat].ephemeral_owner.should_not be_zero
-        end
-      end
-
-      describe :sequence do
-        it_should_behave_like "all success return values"
-
-        before do
-          @orig_path  = path
-          @rv         = zk.create(:path => path, :sequence => true, :callback => @cb, :callback_context => path)
-
-          wait_until(2) { @cb.completed? }
-          @cb.should be_completed
-
-          @s_path = @cb.path
-        end
-
-        after do
-          zk.delete(:path => @s_path)
-        end
-
-        it %[should have a path] do
-          @cb.path.should_not be_nil
-        end
-
-        it %[should return the path that was set] do
-          @cb.path.should_not == @orig_path
-        end
-
-        it %[should have created a permanent node] do
-          st = zk.stat(:path => @s_path)
-          st[:rc].should == Zookeeper::ZOK
-
-          st[:stat].ephemeral_owner.should be_zero
-        end
-      end
-
-      describe :ephemeral_sequence do
-        it_should_behave_like "all success return values"
-
-        before do
-          @orig_path  = path
-          @rv         = zk.create(:path => path, :sequence => true, :ephemeral => true, :callback => @cb, :callback_context => path)
-          path       = @rv[:path]    # make sure this gets cleaned up
-
-          wait_until(2) { @cb.completed? }
-          @cb.should be_completed
-          @s_path = @cb.path
-        end
-
-        after do
-          zk.delete(:path => @s_path)
-        end
-
-        it %[should have a path] do
-          @cb.path.should_not be_nil
-        end
-
-        it %[should return the path that was set] do
-          @s_path.should_not == @orig_path
-        end
-
-        it %[should have created an ephemeral node] do
-          st = zk.stat(:path => @s_path)
-          st[:rc].should == Zookeeper::ZOK
-
-          st[:stat].ephemeral_owner.should_not be_zero
-        end
-      end # ephemeral_sequence
-    end # async
-  end # create
-
-  describe :delete do
-    describe :sync do
-      describe 'without version' do
-        it_should_behave_like "all success return values"
-
-        before do
-          zk.create(:path => path)
-          @rv = zk.delete(:path => path)
-        end
-
-        it %[should have deleted the node] do
-          zk.stat(:path => path)[:stat].exists.should be_false
-        end
-      end
-
-      describe 'with current version' do
-        it_should_behave_like "all success return values"
-
-        before do
-          zk.create(:path => path)
-
-          @stat = zk.stat(:path => path)[:stat]
-          @stat.exists.should be_true
-
-          @rv = zk.delete(:path => path, :version => @stat.version)
-        end
-
-        it %[should have deleted the node] do
-          zk.stat(:path => path)[:stat].exists.should be_false
-        end
-      end
-
-      describe 'with old version' do
-        before do
-          3.times { |n| @stat = zk.set(:path => path, :data => n.to_s)[:stat] }
-
-          @rv = zk.delete(:path => path, :version => 0)
-        end
-
-        it %[should have a return code of ZBADVERSION] do
-          @rv[:rc].should == Zookeeper::ZBADVERSION
-        end
-      end
-    end # sync
-
-    describe :async do
-      before do
-        @cb = ZookeeperCallbacks::VoidCallback.new
-      end
-
-      describe 'without version' do
-        it_should_behave_like "all success return values"
-
-        before do
-          @rv = zk.delete(:path => path, :callback => @cb, :callback_context => path)
-          wait_until { @cb.completed? }
-          @cb.should be_completed
-        end
-
-        it %[should have a success return_code] do
-          @cb.return_code.should == Zookeeper::ZOK
-        end
-
-        it %[should have deleted the node] do
-          zk.stat(:path => path)[:stat].exists.should be_false
-        end
-      end
-
-      describe 'with current version' do
-        it_should_behave_like "all success return values"
-
-        before do
-          @stat = zk.stat(:path => path)[:stat]
-          @rv   = zk.delete(:path => path, :version => @stat.version, :callback => @cb, :callback_context => path)
-          wait_until { @cb.completed? }
-          @cb.should be_completed
-        end
-
-        it %[should have a success return_code] do
-          @cb.return_code.should == Zookeeper::ZOK
-        end
-
-        it %[should have deleted the node] do
-          zk.stat(:path => path)[:stat].exists.should be_false
-        end
-      end
-
-      describe 'with old version' do
-        before do
-          3.times { |n| @stat = zk.set(:path => path, :data => n.to_s)[:stat] }
-
-          @rv = zk.delete(:path => path, :version => 0, :callback => @cb, :callback_context => path)
-          wait_until { @cb.completed? }
-          @cb.should be_completed
-        end
-
-        it %[should have a return code of ZBADVERSION] do
-          @cb.return_code.should == Zookeeper::ZBADVERSION
-        end
-      end
-    end # async
-  end # delete
-
-  describe :get_acl do
-    describe :sync do
-      it_should_behave_like "all success return values"
-
-      before do
-        @rv = zk.get_acl(:path => path)
-      end
-
-      it %[should return a stat for the path] do
-        @rv[:stat].should be_kind_of(ZookeeperStat::Stat)
-      end
-
-      it %[should return the acls] do
-        acls = @rv[:acl]
-        acls.should be_kind_of(Array)
-        h = acls.first
-
-        h.should be_kind_of(Hash)
-
-        h[:perms].should == Zookeeper::ZOO_PERM_ALL
-        h[:id][:scheme].should == 'world'
-        h[:id][:id].should == 'anyone'
-      end
-    end
-
-    describe :async do
-      it_should_behave_like "all success return values"
-
-      before do
-        @cb = Zookeeper::ACLCallback.new
-        @rv = zk.get_acl(:path => path, :callback => @cb, :callback_context => path)
-
-        wait_until(2) { @cb.completed? }
-        @cb.should be_completed
-      end
-
-      it %[should return a stat for the path] do
-        @cb.stat.should be_kind_of(ZookeeperStat::Stat)
-      end
-
-      it %[should return the acls] do
-        acls = @cb.acl
-        acls.should be_kind_of(Array)
-
-        acl = acls.first
-        acl.should be_kind_of(ZookeeperACLs::ACL)
-
-        acl.perms.should == Zookeeper::ZOO_PERM_ALL
-
-        acl.id.scheme.should == 'world'
-        acl.id.id.should == 'anyone'
-      end
-    end
-  end
-
-  describe :set_acl do
-    before do
-      @perms = 5
-      @new_acl = [ZookeeperACLs::ACL.new(:perms => @perms, :id => ZookeeperACLs::ZOO_ANYONE_ID_UNSAFE)]
-      pending("No idea how to set ACLs")
-    end
-
-    describe :sync do
-      it_should_behave_like "all success return values"
-
-      before do
-        @rv = zk.set_acl(:path => path, :acl => @new_acl)
-      end
-    end
-  end
-
-  describe :session_id do
-    it %[should return the session_id as a Fixnum] do
-      zk.session_id.should be_kind_of(Fixnum)
-    end
-  end
-
-  describe :session_passwd do
-    it %[should return the session passwd as a String] do
-      zk.session_passwd.should be_kind_of(String)
-    end
-  end
-end
 
 describe 'Zookeeper' do
   let(:path) { "/_zktest_" }
   let(:data) { "underpants" } 
   let(:zk_host) { 'localhost:2181' }
 
-  let(:zk) do
-    Zookeeper.logger.debug { "creating root instance" }
-    Zookeeper.new(zk_host)
-  end
-
-  it_should_behave_like "all"
-end
-
-
-describe 'Zookeeper chrooted' do
-  let(:path) { "/_zkchroottest_" }
-  let(:data) { "underpants" } 
-  let(:chroot_path) { '/slyphon-zookeeper-chroot' }
-
-  # Ok, i can't explain this, but when you run these tests, the zk instance
-  # gets set up *once* and re-used, which is different from above, where it's
-  # set up new each time
-  #
-  let(:zk) do
-    Zookeeper.logger.debug { "creating chrooted zk instance" }
-    Zookeeper.new("localhost:2181#{chroot_path}")
-  end
-
-  def with_open_zk(host='localhost:2181')
-    z = Zookeeper.new(host)
-    yield z
-  ensure
-    z.close
-
-    wait_until do 
-      begin
-        !z.connected?
-      rescue RuntimeError
-        true
-      end
-    end
+  before do
+    @zk = Zookeeper.new(zk_host)
   end
 
-  before :all do
-    Zookeeper.logger.warn "running before :all"
-
-    with_open_zk do |z|
-      z.create(:path => chroot_path, :data => '')
-    end
+  after do
+    @zk and @zk.close
   end
 
-  after :all do
-    with_open_zk do |z|
-      z.delete(:path => chroot_path)
-    end
+  def zk
+    @zk
   end
 
-  it_should_behave_like "all"
+  it_should_behave_like "connection"
 end
 
-
-