zk 0.9.1 → 1.0.0.rc.1

data/spec/watch_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
 describe ZK do
-  describe do
+  describe 'watchers' do
     before do
-      @cnx_str = "localhost:#{ZK_TEST_PORT}"
-      @zk = ZK.new(@cnx_str)
-
-      @path = "/_testWatch"
-      wait_until { @zk.connected? }
+      mute_logger do
+        @cnx_str = "localhost:#{ZK_TEST_PORT}"
+        @zk = ZK.new(@cnx_str)
 
-      # make sure we start w/ clean state
-      @zk.rm_rf(@path)
+        @path = "/_testWatch"
+        wait_until { @zk.connected? }
+        @zk.rm_rf(@path)
+      end
     end
 
     after do
@@ -147,9 +147,193 @@ describe ZK do
       wait_while { events.empty? }
 
       events.should_not be_empty
+    end
+
+    describe ':all' do
+      before do
+        mute_logger do
+          @other_path = "#{@path}2"
+          @zk.rm_rf(@other_path)
+        end
+      end
+
+      after do
+        mute_logger do
+          @zk.rm_rf(@other_path)
+        end
+      end
+
+      it %[should receive all node events] do
+        events = []
+
+        sub = @zk.register(:all) do |ev|
+          logger.debug { "got event #{ev}" }
+          events << ev
+        end
 
+        @zk.stat(@path, :watch => true)
+        @zk.stat(@other_path, :watch => true)
+
+        @zk.create(@path)
+        @zk.create(@other_path, 'blah')
+
+        wait_until { events.length == 2 }.should be_true
+      end
     end
-  end
+
+    describe %[event interest] do
+      context do # event catcher scope
+        before do
+          @events = EventCatcher.new
+
+          @zk.register(@path, :created) do |event|
+            @events.created << event
+          end
+
+          @zk.register(@path, :changed) do |event|
+            @events.changed << event
+          end
+
+          @zk.register(@path, :child) do |event|
+            @events.child << event
+          end
+
+          @zk.register(@path, :deleted) do |event|
+            @events.deleted << event
+          end
+
+          # this will catch all events, that way we don't have to wait for an
+          # event to *not* be delivered to one of the other callbacks (which is
+          # kinda stupid)
+          @zk.register(@path) do |event|
+            @events.all << event
+          end
+        end
+
+        it %[should deliver only the created event to the created block] do
+          @zk.stat(@path, :watch => true).should_not exist
+
+          @zk.create(@path)
+          wait_while { @events.created.empty? }.should be_false
+          @events.created.first.should be_node_created
+
+          @zk.stat(@path, :watch => true).should exist
+
+          @events.all.length.should == 1
+
+          @zk.delete(@path)
+
+          wait_until { @events.all.length > 1 }
+
+          # :deleted event was delivered, make sure it didn't get delivered to the :created block
+          @events.created.length.should == 1
+        end
+
+        it %[should deliver only the changed event to the changed block] do
+          @zk.create(@path)
+
+          @zk.stat(@path, :watch => true).should exist
+
+          @zk.set(@path, 'data')
+
+          wait_while { @events.changed.empty? }
+
+          @events.changed.first.should be_node_changed
+
+          @zk.stat(@path, :watch => true).should exist
+
+          @events.all.length.should == 1
+
+          @zk.delete(@path)
+
+          wait_until { @events.all.length > 1 }
+
+          # :deleted event was delivered, make sure it didn't get delivered to the :changed block
+          @events.changed.length.should == 1
+        end
+
+        it %[should deliver only the child event to the child block] do
+          @zk.create(@path)
+
+          @zk.children(@path, :watch => true).should be_empty
+
+          child_path = @zk.create("#{@path}/m", '', :sequence => true)
+
+          wait_while { @events.child.empty? }
+
+          @events.child.first.should be_node_child
+
+          @zk.stat(@path, :watch => true).should exist
+
+          @events.all.length.should == 1
+
+          @zk.set(@path, '') # equivalent to a 'touch'
+
+          wait_until { @events.all.length > 1 }
+
+          # :changed event was delivered, make sure it didn't get delivered to the :child block
+          @events.child.length.should == 1
+        end
+
+        it %[should deliver only the deleted event to the deleted block] do
+          @zk.create(@path)
+
+          @zk.stat(@path, :watch => true).should exist
+
+          @zk.delete(@path)
+
+          wait_while { @events.deleted.empty? }
+
+          @events.deleted.first.should be_node_deleted
+
+          @zk.stat(@path, :watch => true).should_not exist
+
+          @events.all.length.should == 1
+
+          @zk.create(@path)
+
+          wait_until { @events.all.length > 1 }
+
+          # :deleted event was delivered, make sure it didn't get delivered to the :created block
+          @events.deleted.length.should == 1
+        end
+      end # event catcher scope
+
+      it %[should deliver interested events to a block registered for multiple deliveries] do
+        @events = []
+
+        @zk.register(@path, [:created, :changed]) do |event|
+          @events << event
+        end
+
+        @zk.stat(@path, :watch => true).should_not exist
+
+        @zk.create(@path)
+
+        wait_while { @events.empty? }
+
+        @events.length.should == 1
+
+        @events.first.should be_node_created
+
+        @zk.stat(@path, :watch => true).should exist
+
+        @zk.set(@path, 'blah')
+
+        wait_until { @events.length > 1 }
+
+        @events.length.should == 2
+
+        @events.last.should be_node_changed
+      end
+
+      it %[should barf if an invalid event name is given] do
+        lambda do
+          @zk.register(@path, :tripping) { }
+        end.should raise_error(ArgumentError)
+      end
+    end # event interest
+  end # watchers
 
   describe 'state watcher' do
     describe 'live-fire test' do
@@ -178,7 +362,7 @@ describe ZK do
           m.should_receive(:state).and_return(ZookeeperConstants::ZOO_CONNECTED_STATE)
         end
       end
-    end
+    end # registered listeners
   end
 end
 

data/spec/{z_k → zk}/client/locking_and_session_death_spec.rb

@@ -73,36 +73,4 @@ shared_examples_for 'locking and session death' do
   end
 end
 
-describe 'threaded client and locking behavior' do
-  include_context 'threaded client connection'
-
-  before do
-    @path = '/test'
-    @zk.create('/test') rescue ZK::Exceptions::NodeExists
-  end
-
-  describe 'block_until_node_deleted' do
-    it %[should raise an EventDispatchThreadException if called in the context of the event dispatch thread] do
-      @exception = nil
-
-      @zk.register(@path) do |event|
-        @zk.event_dispatch_thread?.should be_true
-
-        begin
-          @zk.block_until_node_deleted(@path)
-        rescue Exception => e
-          @exception = e
-        end
-      end
-
-      @zk.exists?(@path, :watch => true)
-
-      @zk.set(@path, 'blah')
-
-      wait_until(2) { @exception }.should be_kind_of(ZK::Exceptions::EventDispatchThreadException)
-    end
-  end
-
-  it_should_behave_like 'locking and session death'
-end
 

data/spec/zk/client_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe ZK::Client::Threaded do
+  include_context 'threaded client connection'
+  it_should_behave_like 'client'
+
+  describe :close! do
+    describe 'from a threadpool thread' 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
+
+        @zk.defer do
+          @zk.close!
+        end
+
+        wait_until { @zk.closed? }.should be_true 
+      end
+    end
+  end
+end
+

data/spec/{z_k → zk}/locker_spec.rb

@@ -464,46 +464,6 @@ describe "ZK::Locker chrooted" do
     it_should_behave_like 'ExclusiveLocker'
     it_should_behave_like 'shared-exclusive interaction'
   end
-
-  describe "when the root doesn't exist" do
-    let(:lock_name) { 'master' }
-
-    it %[should raise a NonExistentRootError] do
-      @got_lock = false
-
-      lambda do
-        zk.with_lock(lock_name) do
-          @got_lock = true
-        end
-      end.should raise_error(ZK::Exceptions::NonExistentRootError)
-
-      @got_lock.should_not be_true
-    end
-  end
 end
 
-describe 'ZK::Locker Multiplexed client', :client => :multiplexed do
-  let(:zk)  { ZK::Client::Multiplexed.new("localhost:#{ZK_TEST_PORT}") }
-  let(:zk2) { ZK::Client::Multiplexed.new("localhost:#{ZK_TEST_PORT}") }
-  let(:zk3) { ZK::Client::Multiplexed.new("localhost:#{ZK_TEST_PORT}") }
-
-  let(:connections) { [zk, zk2, zk3] }
-
-  let(:path) { "shlock" }
-  let(:root_lock_path) { "/_zklocking/#{path}" }
-
-  before do
-    wait_until{ connections.all?(&:connected?) }
-#     pending "Mutliplexed client locking is broken"
-  end
-
-  after do
-    connections.each { |c| c.close! }
-    wait_until { !connections.any?(&:connected?) }
-  end
-
-  it_should_behave_like 'SharedLocker'
-  it_should_behave_like 'ExclusiveLocker'
-  it_should_behave_like 'shared-exclusive interaction'
-end # ZK::Locker
 

data/spec/zk/module_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+# tests for the top-level module methods of ZK
+
+describe ZK do
+  describe :new do
+    let(:chroot_path) { '/zktest/path/to/chroot' }
+
+    after do
+      mute_logger do
+        @zk.close! if @zk and not @zk.closed?
+      end
+    end
+
+    describe %[with a chrooted connection string and a :chroot => '/path'] do
+      it %[should raise an ArgumentError] do
+        lambda { @zk = ZK.new('localhost:2181/zktest', :chroot => '/zktest') }.should raise_error(ArgumentError)
+      end
+    end
+
+    describe 'with no arguments' do
+      before { @zk = ZK.new }
+
+      it %[should create a default connection] do
+        @zk.should be_connected
+      end
+    end
+
+    describe %[with a chroot] do
+      before do
+        mute_logger do
+          @unchroot = ZK.new
+        end
+      end
+
+      after do
+        mute_logger do
+          @unchroot.rm_rf('/zktest')
+          @unchroot.close! if @unchroot and not @unchroot.closed?
+        end
+      end
+
+      describe %[that doesn't exist] do
+        before { @unchroot.rm_rf('/zktest') }
+
+        describe %[with no host and a :chroot => '/path' argument] do
+          before { @zk = ZK.new(:chroot => chroot_path) }
+
+          it %[should use the default connection string, create the chroot and return the connection] do
+            @zk.exists?('/').should be_true
+            @zk.create('/blah', 'data')
+
+            @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+          end
+        end
+
+        describe %[as a connection string] do
+          describe %[and no explicit option] do
+            before do
+              @zk = ZK.new("localhost:2181#{chroot_path}")    # implicit create
+            end
+
+            it %[should create the chroot path and then return the connection] do
+              @zk.exists?('/').should be_true
+              @zk.create('/blah', 'data')
+
+              @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+            end
+          end
+
+          describe %[and an explicit :chroot => :create] do
+            before do
+              @zk = ZK.new("localhost:2181#{chroot_path}", :chroot => :create)
+            end
+
+            it %[should create the chroot path and then return the connection] do
+              @zk.exists?('/').should be_true
+              @zk.create('/blah', 'data')
+
+              @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+            end
+          end
+
+          describe %[and :chroot => :check] do
+            it %[should barf with a ChrootPathDoesNotExistError] do
+              lambda do
+                # assign in case of a bug, that way this connection will get torn down
+                @zk = ZK.new("localhost:2181#{chroot_path}", :chroot => :check)
+              end.should raise_error(ZK::Exceptions::ChrootPathDoesNotExistError)
+            end
+          end
+
+          describe %[and :chroot => :do_nothing] do
+            it %[should return a connection in a weird state] do
+              @zk = ZK.new("localhost:2181#{chroot_path}", :chroot => :do_nothing)
+              lambda { @zk.get('/') }.should raise_error(ZK::Exceptions::NoNode)
+            end
+          end
+
+          describe %[and :chroot => '/path'] do
+            before { @zk = ZK.new("localhost:2181", :chroot => chroot_path) }
+
+            it %[should create the chroot path and then return the connection] do
+              @zk.exists?('/').should be_true
+              @zk.create('/blah', 'data')
+
+              @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+            end
+          end
+        end # as a connection string
+      end # that doesn't exist
+
+      describe %[that exists] do
+        before { @unchroot.mkdir_p(chroot_path) }
+
+        describe %[with no host and a :chroot => '/path' argument] do
+          before { @zk = ZK.new(:chroot => chroot_path) }
+
+          it %[should use the default connection string and totally work] do
+            @zk.exists?('/').should be_true
+            @zk.create('/blah', 'data')
+
+            @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+          end
+        end
+
+        describe %[as a connection string] do
+          describe %[and no explicit option] do
+            before do
+              @zk = ZK.new("localhost:2181#{chroot_path}")    # implicit create
+            end
+
+            it %[should totally work] do
+              @zk.exists?('/').should be_true
+              @zk.create('/blah', 'data')
+
+              @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+            end
+          end
+
+          describe %[and an explicit :chroot => :create] do
+            before do
+              @zk = ZK.new("localhost:2181#{chroot_path}", :chroot => :create)
+            end
+
+            it %[should totally work] do
+              @zk.exists?('/').should be_true
+              @zk.create('/blah', 'data')
+
+              @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+            end
+          end
+
+          describe %[and :chroot => :check] do
+            it %[should totally work] do
+              lambda do
+                # assign in case of a bug, that way this connection will get torn down
+                @zk = ZK.new("localhost:2181#{chroot_path}", :chroot => :check)
+              end.should_not raise_error
+            end
+          end
+
+          describe %[and :chroot => :do_nothing] do
+            it %[should totally work] do
+              @zk = ZK.new("localhost:2181#{chroot_path}", :chroot => :do_nothing)
+              lambda { @zk.get('/') }.should_not raise_error
+            end
+          end
+
+          describe %[and :chroot => '/path'] do
+            before { @zk = ZK.new("localhost:2181", :chroot => chroot_path) }
+
+            it %[should totally work] do
+              @zk.exists?('/').should be_true
+              @zk.create('/blah', 'data')
+
+              @unchroot.get("#{chroot_path}/blah").first.should == 'data'
+            end
+          end
+        end # as a connection string
+      end # that exists
+    end # with a chroot 
+  end # :new
+end # ZK
+

data/spec/{z_k → zk}/mongoid_spec.rb

@@ -1,7 +1,5 @@
 require 'spec_helper'
 
-require 'tracer'
-
 describe ZK::Mongoid::Locking do
   before do
     ZK::Mongoid::Locking.zk_lock_pool = ZK.new_pool('localhost:2181', :min_clients => 1, :max_clients => 5)

data/spec/{z_k → zk}/pool_spec.rb

@@ -1,7 +1,5 @@
 require 'spec_helper'
 
-require 'tracer'
-
 describe ZK::Pool do
   describe :Simple do
 

data/spec/{z_k → zk}/threadpool_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe ZK::Threadpool do
-
   before do
     @threadpool = ZK::Threadpool.new
   end
@@ -20,7 +19,6 @@ describe ZK::Threadpool do
     end
   end
 
-
   describe :defer do
     it %[should run the given block on a thread in the threadpool] do
       @th = nil
@@ -39,9 +37,28 @@ describe ZK::Threadpool do
       lambda { @threadpool.defer(bad_obj) }.should raise_error(ArgumentError)
     end
 
-    it %[should barf if the threadpool is not running] do
+    it %[should not barf if the threadpool is not running] do
       @threadpool.shutdown
-      lambda { @threadpool.defer { "hai!" } }.should raise_error(ZK::Exceptions::ThreadpoolIsNotRunningException)
+      lambda { @threadpool.defer { "hai!" } }.should_not raise_error
+    end
+  end
+
+  describe :on_exception do
+    it %[should register a callback that will be called if an exception is raised on the threadpool] do
+      @ary = []
+
+      @threadpool.on_exception { |exc| @ary << exc }
+        
+      @threadpool.defer { raise "ZOMG!" }
+
+      wait_while(2) { @ary.empty? }
+
+      @ary.length.should == 1
+
+      e = @ary.shift
+
+      e.should be_kind_of(RuntimeError)
+      e.message.should == 'ZOMG!'
     end
   end
 
@@ -70,5 +87,16 @@ describe ZK::Threadpool do
     end
   end
 
+  describe :on_threadpool? do
+    it %[should return true if we're currently executing on one of the threadpool threads] do
+      @a = []
+      @threadpool.defer { @a << @threadpool.on_threadpool? }
+
+      wait_while(2) { @a.empty? }
+      @a.should_not be_empty
+
+      @a.first.should be_true
+    end
+  end
 end
 

data/spec/zookeeper_spec.rb

@@ -117,12 +117,7 @@ shared_examples_for 'ZK basic' do
   end
 end
 
-describe 'basic multiplexed', :client => :multiplexed do
-  include_context 'multiplexed client connection'
-  it_should_behave_like 'ZK basic'
-end
-
-describe 'basic threaded', :client => :threaded do
+describe 'basic threaded', :threaded => true do
   include_context 'threaded client connection'
   it_should_behave_like 'ZK basic'
 end

data/zk.gemspec

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
-require "z_k/version"
+require "zk/version"
 
 Gem::Specification.new do |s|
   s.name        = "zk"
@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.summary     = %q{A high-level wrapper around the zookeeper driver}
   s.description = s.summary + "\n"
 
-  s.add_runtime_dependency 'slyphon-zookeeper', '~> 0.8.1'
+  s.add_runtime_dependency 'slyphon-zookeeper', '~> 0.9.2'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")