zkruby 3.4.3

data/spec/protocol_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+# Raw object protocol, very similar to EM's native ObjectProtocol
+# Expects:
+#   #receive_data and #send_records to be invoked
+#   #receive_records and #send_data to be implemented
+class ProtocolBindingSpec
+    include ZooKeeper::Protocol
+    attr_reader :data,:binding
+
+    def initialize(mock)
+        @data = ""
+        @binding = mock
+    end
+
+    def receive_records(io)
+       data = io.read(@binding.packet_size())
+       @binding.receive_records(data)
+    end
+
+    def send_data(data)
+        @data << data
+    end
+end
+
+def length_encode(data)
+    [data.length,data].pack("NA*")
+end
+
+describe ZooKeeper::Protocol do
+
+    before :each do
+            @conn = ProtocolBindingSpec.new(mock("protocol binding"))
+    end
+
+    context "recieving data" do
+        it "should handle self contained packets" do
+            data = "a complete packet"
+            @conn.binding.stub(:packet_size).and_return(data.length)
+            @conn.binding.should_receive(:receive_records).with(data)
+            @conn.receive_data(length_encode(data))
+        end
+
+        it "should handle reply packets over multiple chunks" do
+            data = "a complete packet that will be split into chunks"
+            @conn.binding.stub(:packet_size).and_return(data.length)
+            @conn.binding.should_receive(:receive_records).with(data)
+            chunks = length_encode(data).scan(/.{1,12}/)
+            chunks.each { |c| @conn.receive_data(c) }
+        end
+
+        it "should handle replies containing multiple packets" do
+            p1 = "first packet"
+            p2 = "second packet"
+            @conn.binding.stub(:packet_size).and_return(p1.length,p2.length)
+            @conn.binding.should_receive(:receive_records).with(p1).ordered
+            @conn.binding.should_receive(:receive_records).with(p2).ordered
+            data = length_encode(p1) + length_encode(p2)
+            @conn.receive_data(data)
+        end
+    end
+
+    context "sending data" do
+        it "should length encode the data" do
+            mock_record = mock("a mock record")
+            mock_record.stub(:to_binary_s).and_return("a binary string")
+            @conn.send_records(mock_record)
+            @conn.data.should ==  [15,"a binary string"].pack("NA15")
+            
+        end
+    end
+end

data/spec/recipe_helper.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+#Helper classes for testing recipes against a mockable zookeeper client
+#with pseudo asynchronous behaviour
+
+module ZooKeeper
+    # We need to run callback blocks for results
+    # in a sequence and inject watches in the middle
+    class MockCallback
+        attr_accessor :errback, :callback, :err, :results
+        def initialize(init_callback)
+            @callback = init_callback
+        end
+        
+        def invoke()
+            cb,args = err ? [errback,[err]] : [callback,results]
+            cb.call(*args)
+        end
+    end
+
+    # This harness wraps a double on which the calls to a zk client can be stubbed
+    # with return values or exceptions (ZooKeeper::Error)
+    # If the recipe under test makes an asynchronous call to the mock client, then
+    # the callback block is captured alongside the stub result and put in a queue
+    # for later processing via #run_queue
+    # If the recipe makes a synchronous style call then the existing queue will be run
+    # before the stub result is returned directly.
+    class MockClient
+       attr_reader :double
+       def initialize(double)
+            @queue = []
+            # we delegate all stub methods to our double.
+            # if a block is supplied we return an op with the callback and result
+            # the op can take an err back. When the tests finish running
+            # we invoke the methods in the queue, repeatedly until the queue is empty
+            @double = double
+       end
+
+       def method_missing(meth,*args,&callback)
+            if callback
+                cb = ZooKeeper::MockCallback.new(callback)
+                begin
+                    cb.results = @double.send(meth,*args)
+                rescue ZooKeeper::Error => ex
+                    cb.err = ex.to_sym
+                end
+                @queue << cb
+                ZooKeeper::AsyncOp.new(cb)
+            else
+                # we won't get the return from a synchronous call until
+                # any pending asynchronous calls have completed
+                # only runs the current queued items, any additional activity
+                # queued as a result of a callback goes into a new queue
+                queued_cbs = @queue
+                @queue = []
+                queued_cbs.each { |cb| cb.invoke() }
+                @double.send(meth,*args) unless callback
+            end
+       end
+
+       def run_queue()
+            until @queue.empty?
+                cb = @queue.shift
+                cb.invoke()
+            end
+       end
+    end
+end #ZooKeeper

data/spec/rubyio_spec.rb

@@ -0,0 +1,8 @@
+require 'server_helper'
+require 'shared/binding'
+require 'zkruby/rubyio'
+
+describe ZooKeeper::RubyIO::Binding do
+    it_behaves_like "a zookeeper client binding"
+end
+

data/spec/sequences_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe ZooKeeper do
+    it "should convert a path to a prefix and the sequence id" do
+       
+        ZK.path_to_seq("/a/path/with-0000000001/a/sequence-0000000002").should == [ "/a/path/with-0000000001/a/sequence-",2 ]
+        ZK.path_to_seq("/tricky/9990000000004").should == [ "/tricky/999", 4 ]
+    end
+
+    it "should graciously handle a path without a sequence" do
+        ZK.path_to_seq("/a/path").should ==  ["/a/path",nil]
+        ZK.path_to_seq("/a/0000000001/").should == ["/a/0000000001/",nil]
+    end
+
+    it "should convert to a prefix and sequence id to a path" do
+        ZK.seq_to_path("/a/path",345).should == "/a/path0000000345"
+        ZK.seq_to_path("/a/path00/",123).should == "/a/path00/0000000123"
+    end
+end

data/spec/server_helper.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module ZooKeeperServerHelper
+
+    include Slf4r::Logger
+
+    def restart_cluster(delay=0)
+        system("../../bin/zkServer.sh stop >> zk.out")
+        Kernel::sleep(delay) if delay > 0
+        if (::RUBY_PLATFORM == "java")
+            #in JRuby 1.6.3 system does not return 
+            system("../../bin/zkServer.sh start >> zk.out &")
+        else
+            system("../../bin/zkServer.sh start >> zk.out")
+        end
+    end
+
+    def get_addresses()
+        "localhost:2181"
+    end
+
+    def safe_close(zk)
+        zk.close()
+        rescue ZooKeeper::Error => ex
+            puts "Ignoring close exception #{ex}"
+    end
+
+    def connect(options = {})
+        ZooKeeper.connect("localhost:2181",options)
+    end
+
+end
+
+include ZooKeeperServerHelper
+
+restart_cluster()
+sleep(3)
+require 'net/telnet'
+t = Net::Telnet.new("Host" => "localhost", "Port" => 2181)
+properties = t.cmd("mntr")
+
+RSpec.configure do |c|
+    #Exclude multi unless we are on a 3.4 server
+    c.filter_run_excluding :multi => true unless properties
+end

data/spec/shared/auth.rb

@@ -0,0 +1,40 @@
+shared_examples_for "authentication" do
+
+    describe "Authentication" do
+
+        around(:each) do |example|
+            @path = "/zkruby/rspec-auth"
+            @zk = connect(:scheme => "digest", :auth => "myuser:mypass", :binding => binding)
+            @zk.create(@path,"Auth Test",ZK::ACL_CREATOR_ALL,:ephemeral)
+
+            example.run
+
+            safe_close(@zk)
+        end
+
+
+        it "should not allow unauthenticated access" do
+            zk2 = connect(:binding => binding)
+            lambda { zk2.get(@path) }.should raise_error(ZooKeeper::Error)
+            zk2.close()
+        end
+
+        it "should allow authenticated access" do
+            zk2 = connect(:scheme => "digest", :auth => "myuser:mypass", :binding => binding)
+            stat,data = zk2.get(@path)
+            data.should == "Auth Test"
+            zk2.close()
+        end
+
+        it "should not allow access with bad password" do
+            zk2 = connect(:scheme => "digest", :auth => "myuser:badpass", :binding => binding)
+            lambda { zk2.get(@path) }.should raise_error(ZooKeeper::Error)
+            zk2.close()
+        end
+
+        # Digest doesn't actually validate credentials, just ensures they match against the ACL
+        # We'll need to test this with a mock Binding
+        it "should get to auth_failed if invalid credentials supplied" 
+
+    end
+end

data/spec/shared/basic.rb

@@ -0,0 +1,180 @@
+shared_examples_for "basic integration" do
+
+    before(:each) do
+         @zk.create("/zkruby","node for zk ruby testing",ZK::ACL_OPEN_UNSAFE) unless @zk.exists?("/zkruby")
+    end
+
+    it "should return a stat for the root path" do
+        stat = @zk.stat("/")
+        stat.should be_a ZooKeeper::Data::Stat
+    end
+
+    it "should asynchronously return a stat for the root path" do
+        op = @zk.stat("/") do |stat|
+            stat.should be_a ZooKeeper::Data::Stat
+            :success
+        end
+
+        op.value.should == :success
+    end
+
+    it "should perform ZooKeeper CRUD" do
+        path = @zk.create("/zkruby/rspec","someData",ZK::ACL_OPEN_UNSAFE,:ephemeral)
+        path.should == "/zkruby/rspec"
+        @zk.exists?("/zkruby/rspec").should be_true
+        stat,data = @zk.get("/zkruby/rspec")
+        stat.should be_a ZooKeeper::Data::Stat
+        data.should == "someData"
+        new_stat = @zk.set("/zkruby/rspec","different data",stat.version)
+        new_stat.should be_a ZooKeeper::Data::Stat
+        stat,data = @zk.get("/zkruby/rspec")
+        data.should == "different data"
+        cstat,children = @zk.children("/zkruby")
+        children.should include("rspec")
+        @zk.delete("/zkruby/rspec",stat.version)
+        @zk.exists?("/zkruby/rspec").should be_false
+    end
+
+    it "should accept -1 to delete any version" do
+        path = @zk.create("/zkruby/rspec","someData",ZK::ACL_OPEN_UNSAFE,:ephemeral)
+        @zk.delete("/zkruby/rspec",-1)
+        @zk.exists?("/zkruby/rspec").should be_false
+    end
+
+    context "exceptions" do
+
+        it "should raise ZK::Error for synchronous method" do
+            begin
+                get_caller = caller
+                @zk.get("/anunknownpath")
+                fail "Expected no node error"
+            rescue ZooKeeper::Error => ex
+                # only because JRuby 1.9 doesn't support the === syntax for exceptions
+                ZooKeeper::Error::NO_NODE.should === ex
+                ex.message.should =~ /\/anunknownpath/
+                skip = if defined?(JRUBY_VERSION) then 2 else 1 end
+                ex.backtrace[skip..-1].should == get_caller
+            end
+        end
+
+        it "should capture ZK error for asynchronous method" do
+            get_caller = caller
+            op = @zk.get("/an/unknown/path") { raise "callback invoked unexpectedly" }
+           
+            begin
+                op.value
+                fail "Expected no node error"
+            rescue ZooKeeper::Error => ex
+                ZooKeeper::Error::NO_NODE.should === ex
+                ex.message.should =~ /\/an\/unknown\/path/
+                ex.backtrace[1..-1].should == get_caller
+            end
+        end
+
+        it "should call the error call back for asynchronous errors" do
+            op = @zk.get("/an/unknown/path") do
+                :callback_invoked_unexpectedly
+            end
+
+            op.on_error do |err|
+                case err
+                when ZK::Error::NO_NODE
+                    :found_no_node_error
+                else
+                    raise err
+                end
+            end
+
+            op.value.should == :found_no_node_error
+        end
+
+        it "should capture exceptions from asynchronous callback" do
+            async_caller = nil
+            op = @zk.exists?("/zkruby") do |stat|
+                raise "oops"
+            end
+
+            begin
+                op.value
+                fail "Expected RuntimeError"
+            rescue RuntimeError => ex
+                ex.message.should =~ /oops/
+            end
+        end
+
+    end
+
+    context "anti herd-effect features" do
+        it "should randomly shuffle the address list"
+
+        it "should randomly delay reconnections within one seventh of the timeout"
+    end    
+
+
+    context "auto reconnect" do
+
+        it "should stay connected" do
+            sleep(@zk.timeout * 2.0)
+            @zk.exists?("/zkruby").should be_true
+        end
+
+
+        it "should seamlessly reconnect within the timeout period" do
+            watcher = mock("Watcher").as_null_object
+            watcher.should_receive(:process_watch).with(ZK::KeeperState::DISCONNECTED,nil,ZK::WatchEvent::NONE)
+            watcher.should_receive(:process_watch).with(ZK::KeeperState::CONNECTED,nil,ZK::WatchEvent::NONE)
+            watcher.should_not_receive(:process_watch).with(ZK::KeeperState::EXPIRED,nil,ZK::WatchEvent::NONE)
+            @zk.watcher = watcher
+            restart_cluster(2)
+            @zk.exists?("/zkruby").should be_true
+        end
+
+        it "should eventually expire the session" do
+            watcher = mock("Watcher").as_null_object
+            watcher.should_receive(:process_watch).with(ZK::KeeperState::DISCONNECTED,nil,ZK::WatchEvent::NONE)
+            watcher.should_receive(:process_watch).with(ZK::KeeperState::EXPIRED,nil,ZK::WatchEvent::NONE)
+            @zk.watcher = watcher
+            restart_cluster(@zk.timeout * 2.0)
+            lambda { @zk.exists?("/zkruby") }.should raise_error(ZooKeeper::Error)
+        end
+
+    end
+
+
+    context "mixed sync and async calls" do
+
+        before(:each) do
+            @zk.delete("/zkruby/sync_async", -1) if @zk.exists?("/zkruby/sync_async") 
+        end
+
+        it "should handle a synchronous call inside an asynchronous callback" do
+            op = @zk.create("/zkruby/sync_async","somedata",ZK::ACL_OPEN_UNSAFE) do
+                ZK.current.should equal(@zk)
+                stat, data = @zk.get("/zkruby/sync_async")
+                data
+            end
+
+            op.value.should == "somedata"
+        end
+
+        it "should handle a synchronous call inside an asynchronous error callback" do
+
+            op = @zk.create("/zkruby/some_never_created_node/test","test_data",ZK::ACL_OPEN_UNSAFE) do
+                :should_not_get_here
+            end
+
+            op.on_error do |err|
+                ZK.current.should equal(@zk)
+                case err
+                when ZK::Error::NO_NODE
+                    stat,data = @zk.get("/zkruby") 
+                    :success
+                else
+                    raise err
+                end
+            end
+
+            op.value.should == :success
+        end
+    end
+end

data/spec/shared/binding.rb

@@ -0,0 +1,33 @@
+require 'server_helper'
+require 'shared/basic'
+require 'shared/util'
+require 'shared/chroot'
+require 'shared/watch'
+require 'shared/multi'
+require 'shared/auth'
+
+shared_examples_for "a zookeeper client binding" do
+
+    let (:binding) { described_class }
+
+    context "A local connection" do
+    
+        around(:each) do |example|
+            ZooKeeper.connect(get_addresses(),:binding => binding) do | zk |
+                @zk = zk
+                ZooKeeper.current.should == zk
+                example.run
+            end
+        end
+
+        include_examples("basic integration")
+        include_examples("util recipes")
+        include_examples("multi")
+
+    end
+
+    include_examples("authentication")
+    include_examples("chrooted connection")
+    include_examples("watches")
+end
+