zk 1.9.6 → 1.10.0

data/spec/zk/watch_spec.rb

@@ -17,7 +17,7 @@ describe ZK do
     after do
       mute_logger do
         if @zk.connected?
-          @zk.close! 
+          @zk.close!
           wait_until { !@zk.connected? }
         end
 
@@ -33,29 +33,29 @@ describe ZK do
         locker.synchronize do
           callback_called = true
         end
-        event.path.should == @path
+        expect(event.path).to eq(@path)
       end
 
       @zk.exists?(@path, :watch => true)
       @zk.create(@path, "", :mode => :ephemeral)
 
       wait_until(5) { locker.synchronize { callback_called } }
-      callback_called.should be_true
+      expect(callback_called).to be(true)
     end
 
     describe :regression do
-      before do
-        pending_in_travis("these tests take too long or time out")
-      end
+      # before do
+      #   pending_in_travis("these tests take too long or time out")
+      # end
 
-      # this is stupid, and a bad test, but we have to check that events 
-      # don't get re-delivered to a single registered callback just because 
+      # this is stupid, and a bad test, but we have to check that events
+      # don't get re-delivered to a single registered callback just because
       # :watch => true was called twice
       #
       # again, we're testing a negative here, so consider this a regression check
       #
       def wait_for_events_to_not_be_delivered(events)
-        lambda { wait_until(0.2) { events.length >= 2 } }.should raise_error(WaitWatchers::TimeoutError)
+        expect { wait_until(0.2) { events.length >= 2 } }.to raise_error(WaitWatchers::TimeoutError)
       end
 
       it %[should only deliver an event once to each watcher registered for exists?] do
@@ -67,14 +67,14 @@ describe ZK do
         end
 
         2.times do
-          @zk.exists?(@path, :watch => true).should_not be_true
+          expect(@zk.exists?(@path, :watch => true)).not_to be(true)
         end
 
         @zk.create(@path, '', :mode => :ephemeral)
 
         wait_for_events_to_not_be_delivered(events)
 
-        events.length.should == 1
+        expect(events.length).to eq(1)
       end
 
       it %[should only deliver an event once to each watcher registered for get] do
@@ -89,14 +89,14 @@ describe ZK do
 
         2.times do
           data, stat = @zk.get(@path, :watch => true)
-          data.should == 'one'
+          expect(data).to eq('one')
         end
 
         @zk.set(@path, 'two')
 
         wait_for_events_to_not_be_delivered(events)
 
-        events.length.should == 1
+        expect(events.length).to eq(1)
       end
 
 
@@ -112,20 +112,20 @@ describe ZK do
 
         2.times do
           children = @zk.children(@path, :watch => true)
-          children.should be_empty
+          expect(children).to be_empty
         end
 
         @zk.create("#{@path}/pfx", '', :mode => :ephemeral_sequential)
 
         wait_for_events_to_not_be_delivered(events)
 
-        events.length.should == 1
+        expect(events.length).to eq(1)
       end
     end
 
     it %[should restrict_new_watches_for? if a successul watch has been set] do
       @zk.stat(@path, :watch => true)
-      @zk.event_handler.should be_restricting_new_watches_for(:data, @path)
+      expect(@zk.event_handler).to be_restricting_new_watches_for(:data, @path)
     end
 
     it %[should not a block on new watches after an operation fails] do
@@ -141,19 +141,19 @@ describe ZK do
 
       # get a path that doesn't exist with a watch
 
-      lambda { @zk.get(@path, :watch => true) }.should raise_error(ZK::Exceptions::NoNode)
+      expect { @zk.get(@path, :watch => true) }.to raise_error(ZK::Exceptions::NoNode)
 
-      @zk.event_handler.should_not be_restricting_new_watches_for(:data, @path)
+      expect(@zk.event_handler).not_to be_restricting_new_watches_for(:data, @path)
 
       @zk.stat(@path, :watch => true)
 
-      @zk.event_handler.should be_restricting_new_watches_for(:data, @path)
+      expect(@zk.event_handler).to be_restricting_new_watches_for(:data, @path)
 
       @zk.create(@path, '')
 
       wait_while { events.empty? }
 
-      events.should_not be_empty
+      expect(events).not_to be_empty
     end
 
     it %[should call a child listener when the node is deleted] do
@@ -177,10 +177,10 @@ describe ZK do
 
       event = events.pop
 
-      event.should_not be_nil
+      expect(event).not_to be_nil
 
-      event.path.should == @path
-      event.type.should == Zookeeper::ZOO_DELETED_EVENT
+      expect(event.path).to eq(@path)
+      expect(event.type).to eq(Zookeeper::ZOO_DELETED_EVENT)
 
       # Create the node again
       @zk.create(@path, '')
@@ -196,10 +196,10 @@ describe ZK do
 
       event = events.pop
 
-      event.should_not be_nil
+      expect(event).not_to be_nil
 
-      event.path.should == @path
-      event.type.should == Zookeeper::ZOO_DELETED_EVENT
+      expect(event.path).to eq(@path)
+      expect(event.type).to eq(Zookeeper::ZOO_DELETED_EVENT)
     end
 
     describe ':all' do
@@ -230,7 +230,7 @@ describe ZK do
         @zk.create(@path)
         @zk.create(@other_path, 'blah')
 
-        wait_until { events.length == 2 }.should be_true
+        expect(wait_until { events.length == 2 }).to be(true)
       end
     end
 
@@ -250,58 +250,58 @@ describe ZK do
 
         it %[should deliver only the created event to the created block] do
           @events.synchronize do
-            @zk.stat(@path, :watch => true).should_not exist
+            expect(@zk.stat(@path, :watch => true)).not_to exist
 
             @zk.create(@path)
 
             @events.wait_for_created
 
-            @events.created.should_not be_empty
-            @events.created.first.should be_node_created
-            @events.all.should_not be_empty
+            expect(@events.created).not_to be_empty
+            expect(@events.created.first).to be_node_created
+            expect(@events.all).not_to be_empty
 
-            @zk.stat(@path, :watch => true).should exist
+            expect(@zk.stat(@path, :watch => true)).to exist
 
-            @events.all.length.should == 1
+            expect(@events.all.length).to eq(1)
 
             @zk.delete(@path)
 
             @events.wait_for_all
           end
 
-          @events.all.length.should == 2
+          expect(@events.all.length).to eq(2)
 
           # :deleted event was delivered, make sure it didn't get delivered to the :created block
-          @events.created.length.should == 1
+          expect(@events.created.length).to eq(1)
         end
 
         it %[should deliver only the changed event to the changed block] do
           @events.synchronize do
             @zk.create(@path)
 
-            @zk.stat(@path, :watch => true).should exist
+            expect(@zk.stat(@path, :watch => true)).to exist
 
             @zk.set(@path, 'data')
 
             @events.wait_for_changed
           end
 
-          @events.changed.should_not be_empty
-          @events.changed.length.should == 1
-          @events.changed.first.should be_node_changed
+          expect(@events.changed).not_to be_empty
+          expect(@events.changed.length).to eq(1)
+          expect(@events.changed.first).to be_node_changed
 
-          @events.all.length.should == 1
+          expect(@events.all.length).to eq(1)
 
           @events.synchronize do
-            @zk.stat(@path, :watch => true).should exist
+            expect(@zk.stat(@path, :watch => true)).to exist
             @zk.delete(@path)
             @events.wait_for_all
           end
 
-          @events.all.length.should == 2
+          expect(@events.all.length).to eq(2)
 
           # :deleted event was delivered, make sure it didn't get delivered to the :changed block
-          @events.changed.length.should == 1
+          expect(@events.changed.length).to eq(1)
         end
 
         it %[should deliver only the child event to the child block] do
@@ -309,53 +309,53 @@ describe ZK do
 
           @events.synchronize do
             @zk.create(@path)
-            @zk.children(@path, :watch => true).should be_empty
+            expect(@zk.children(@path, :watch => true)).to be_empty
 
             child_path = @zk.create("#{@path}/m", '', :sequence => true)
 
             @events.wait_for_child
 
-            @events.child.length.should == 1
-            @events.child.first.should be_node_child
+            expect(@events.child.length).to eq(1)
+            expect(@events.child.first).to be_node_child
 
-            @zk.stat(@path, :watch => true).should exist
+            expect(@zk.stat(@path, :watch => true)).to exist
 
-            @events.all.length.should == 1
+            expect(@events.all.length).to eq(1)
 
             @zk.set(@path, '') # equivalent to a 'touch'
             @events.wait_for_all
           end
 
-          @events.all.length.should == 2
+          expect(@events.all.length).to eq(2)
 
           # :changed event was delivered, make sure it didn't get delivered to the :child block
-          @events.child.length.should == 1
+          expect(@events.child.length).to eq(1)
         end
 
         it %[should deliver only the deleted event to the deleted block] do
           @events.synchronize do
             @zk.create(@path)
-            @zk.stat(@path, :watch => true).should exist
+            expect(@zk.stat(@path, :watch => true)).to exist
             @zk.delete(@path)
 
             @events.wait_for_deleted
             @events.wait_while_all { |all| all.empty? }
 
-            @events.deleted.should_not be_empty
-            @events.deleted.first.should be_node_deleted
-            @events.all.length.should == 1
+            expect(@events.deleted).not_to be_empty
+            expect(@events.deleted.first).to be_node_deleted
+            expect(@events.all.length).to eq(1)
 
-            @zk.stat(@path, :watch => true).should_not exist
+            expect(@zk.stat(@path, :watch => true)).not_to exist
 
             @zk.create(@path)
 
             @events.wait_for_all
           end
 
-          @events.all.length.should be > 1
+          expect(@events.all.length).to be > 1
 
           # :deleted event was delivered, make sure it didn't get delivered to the :created block
-          @events.deleted.length.should == 1
+          expect(@events.deleted.length).to eq(1)
         end
       end # event catcher scope
 
@@ -372,30 +372,30 @@ describe ZK do
         end
 
         @events.synchronize do
-          @zk.stat(@path, :watch => true).should_not exist
+          expect(@zk.stat(@path, :watch => true)).not_to exist
 
           @zk.create(@path)
 
           @cond.wait(5)
 
-          @events.should_not be_empty
-          @events.length.should == 1
-          @events.first.should be_node_created
+          expect(@events).not_to be_empty
+          expect(@events.length).to eq(1)
+          expect(@events.first).to be_node_created
 
-          @zk.stat(@path, :watch => true).should exist
+          expect(@zk.stat(@path, :watch => true)).to exist
           @zk.set(@path, 'blah')
 
           @cond.wait(5)
         end
 
-        @events.length.should == 2
-        @events.last.should be_node_changed
+        expect(@events.length).to eq(2)
+        expect(@events.last).to be_node_changed
       end
 
       it %[should barf if an invalid event name is given] do
-        lambda do
+        expect do
           @zk.register(@path, :only => :tripping) { }
-        end.should raise_error(ArgumentError)
+        end.to raise_error(ArgumentError)
       end
     end # event interest
   end # watchers
@@ -416,21 +416,9 @@ describe ZK do
 
       it %[should fire the registered callback] do
         wait_while { @event.nil? }
-        @event.should_not be_nil
+        expect(@event).not_to be_nil
       end
     end
-
-    describe 'registered listeners' do
-      before do
-        @event = flexmock(:event) do |m|
-          m.should_receive(:type).and_return(-1)
-          m.should_receive(:zk=).with(any())
-          m.should_receive(:node_event?).and_return(false)
-          m.should_receive(:state_event?).and_return(true)
-          m.should_receive(:state).and_return(Zookeeper::Constants::ZOO_CONNECTED_STATE)
-        end
-      end
-    end # registered listeners
   end
 end
 

data/spec/zk/zookeeper_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 shared_examples_for 'ZK basic' do
   before do
-    logger.debug { "connection_args: #{connection_args.inspect}" } 
+    logger.debug { "connection_args: #{connection_args.inspect}" }
     begin
       @zk.create(@base_path)
     rescue ZK::Exceptions::NodeExists
@@ -11,58 +11,58 @@ shared_examples_for 'ZK basic' do
 
   describe ZK, "with no authentication" do
     it "should add authentication" do
-      @zk.add_auth({:scheme => 'digest', :cert => 'bob:password'}).should include({:rc => 0})
+      expect(@zk.add_auth({:scheme => 'digest', :cert => 'bob:password'})).to include({:rc => 0})
     end
   end
 
   describe ZK, "with no paths" do
     it "should not exist" do
-      @zk.exists?("#{@base_path}/test").should be_false
+      expect(@zk.exists?("#{@base_path}/test")).to be(false)
     end
 
     it "should create a path" do
-      @zk.create("#{@base_path}/test", "test_data", :mode => :ephemeral).should == "#{@base_path}/test"
+      expect(@zk.create("#{@base_path}/test", "test_data", :mode => :ephemeral)).to eq("#{@base_path}/test")
     end
 
     it "should be able to set the data" do
       @zk.create("#{@base_path}/test", "something", :mode => :ephemeral)
       @zk.set("#{@base_path}/test", "somethingelse")
-      @zk.get("#{@base_path}/test").first.should == "somethingelse"
+      expect(@zk.get("#{@base_path}/test").first).to eq("somethingelse")
     end
 
     it "should raise an exception for a non existent path" do
-      lambda { @zk.get("/non_existent_path") }.should raise_error(ZK::Exceptions::NoNode)
+      expect { @zk.get("/non_existent_path") }.to raise_error(ZK::Exceptions::NoNode)
     end
 
     it "should create a path with sequence set" do
-      @zk.create("#{@base_path}/test", "test_data", :mode => :persistent_sequential).should =~ /test(\d+)/
+      expect(@zk.create("#{@base_path}/test", "test_data", :mode => :persistent_sequential)).to match(/test(\d+)/)
     end
 
     it "should create an ephemeral path" do
-      @zk.create("#{@base_path}/test", "test_data", :mode => :ephemeral).should == "#{@base_path}/test"
+      expect(@zk.create("#{@base_path}/test", "test_data", :mode => :ephemeral)).to eq("#{@base_path}/test")
     end
 
     it "should remove ephemeral path when client session ends" do
-      @zk.create("#{@base_path}/test", "test_data", :mode => :ephemeral).should == "#{@base_path}/test"
-      @zk.exists?("#{@base_path}/test").should_not be_nil
+      expect(@zk.create("#{@base_path}/test", "test_data", :mode => :ephemeral)).to eq("#{@base_path}/test")
+      expect(@zk.exists?("#{@base_path}/test")).not_to be_nil
       @zk.close!
       wait_until(2) { !@zk.connected? }
-      @zk.should_not be_connected
+      expect(@zk).not_to be_connected
 
       @zk = ZK.new(*connection_args)
       wait_until{ @zk.connected? }
-      @zk.exists?("#{@base_path}/test").should be_false
+      expect(@zk.exists?("#{@base_path}/test")).to be(false)
     end
 
     it "should remove sequential ephemeral path when client session ends" do
       created = @zk.create("#{@base_path}/test", "test_data", :mode => :ephemeral_sequential)
-      created.should =~ /test(\d+)/
-      @zk.exists?(created).should_not be_nil
+      expect(created).to match(/test(\d+)/)
+      expect(@zk.exists?(created)).not_to be_nil
       @zk.close!
 
       @zk = ZK.new(*connection_args)
       wait_until{ @zk.connected? }
-      @zk.exists?(created).should be_false
+      expect(@zk.exists?(created)).to be(false)
     end
   end
 
@@ -72,57 +72,57 @@ shared_examples_for 'ZK basic' do
     end
 
     it "should return a stat" do
-      @zk.stat("#{@base_path}/test").should be_instance_of(Zookeeper::Stat)
+      expect(@zk.stat("#{@base_path}/test")).to be_instance_of(Zookeeper::Stat)
     end
 
     it "should return a boolean" do
-      @zk.exists?("#{@base_path}/test").should be_true
+      expect(@zk.exists?("#{@base_path}/test")).to be(true)
     end
 
     it "should get data and stat" do
       data, stat = @zk.get("#{@base_path}/test")
-      data.should == "test_data"
-      stat.should be_a_kind_of(Zookeeper::Stat)
-      stat.created_time.should_not == 0
+      expect(data).to eq("test_data")
+      expect(stat).to be_a_kind_of(Zookeeper::Stat)
+      expect(stat.created_time).not_to eq(0)
     end
 
     it "should set data with a file" do
       file = File.read('spec/test_file.txt')
       @zk.set("#{@base_path}/test", file)
-      @zk.get("#{@base_path}/test").first.should == file
+      expect(@zk.get("#{@base_path}/test").first).to eq(file)
     end
 
     it "should delete path" do
       @zk.delete("#{@base_path}/test")
-      @zk.exists?("#{@base_path}/test").should be_false
+      expect(@zk.exists?("#{@base_path}/test")).to be(false)
     end
 
     it "should create a child path" do
-      @zk.create("#{@base_path}/test/child", "child", :mode => :ephemeral).should == "#{@base_path}/test/child"
+      expect(@zk.create("#{@base_path}/test/child", "child", :mode => :ephemeral)).to eq("#{@base_path}/test/child")
     end
 
     it "should create sequential child paths" do
-      (child1 = @zk.create("#{@base_path}/test/child", "child1", :mode => :persistent_sequential)).should =~ /\/test\/child(\d+)/
-      (child2 = @zk.create("#{@base_path}/test/child", "child2", :mode => :persistent_sequential)).should =~ /\/test\/child(\d+)/
+      expect(child1 = @zk.create("#{@base_path}/test/child", "child1", :mode => :persistent_sequential)).to match(/\/test\/child(\d+)/)
+      expect(child2 = @zk.create("#{@base_path}/test/child", "child2", :mode => :persistent_sequential)).to match(/\/test\/child(\d+)/)
       children = @zk.children("#{@base_path}/test")
-      children.length.should == 2
-      children.should be_include(child1.match(/\/test\/(child\d+)/)[1])
-      children.should be_include(child2.match(/\/test\/(child\d+)/)[1])
+      expect(children.length).to eq(2)
+      expect(children).to be_include(child1.match(/\/test\/(child\d+)/)[1])
+      expect(children).to be_include(child2.match(/\/test\/(child\d+)/)[1])
     end
 
     it "should have no children" do
-      @zk.children("#{@base_path}/test").should be_empty
+      expect(@zk.children("#{@base_path}/test")).to be_empty
     end
   end
 
   describe ZK, "with children" do
     before(:each) do
       @zk.create("#{@base_path}/test", "test_data", :mode => :persistent)
-      @zk.create("#{@base_path}/test/child", "child", :mode => "persistent").should == "#{@base_path}/test/child"
+      expect(@zk.create("#{@base_path}/test/child", "child", :mode => "persistent")).to eq("#{@base_path}/test/child")
     end
 
     it "should get children" do
-      @zk.children("#{@base_path}/test").should eql(["child"])
+      expect(@zk.children("#{@base_path}/test")).to eql(["child"])
     end
   end
 end

data/zk.gemspec

@@ -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 'zookeeper', '~> 1.4.0'
+  s.add_runtime_dependency 'zookeeper', '~> 1.5.0'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

metadata

@@ -1,48 +1,48 @@
 --- !ruby/object:Gem::Specification
 name: zk
 version: !ruby/object:Gem::Version
-  version: 1.9.6
+  version: 1.10.0
 platform: ruby
 authors:
 - Jonathan D. Simms
 - Topper Bowers
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-09-28 00:00:00.000000000 Z
+date: 2021-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zookeeper
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
-description: ! 'A high-level wrapper around the zookeeper driver
+        version: 1.5.0
+description: 'A high-level wrapper around the zookeeper driver
 
-'
+  '
 email:
 - slyphon@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .dotfiles/ctags_paths
-- .dotfiles/rspec-logging
-- .dotfiles/ruby-gemset
-- .dotfiles/ruby-version
-- .dotfiles/rvmrc
-- .gitignore
-- .gitmodules
-- .travis.yml
-- .yardopts
+- ".dotfiles/ctags_paths"
+- ".dotfiles/rspec-logging"
+- ".dotfiles/ruby-gemset"
+- ".dotfiles/ruby-version"
+- ".dotfiles/rvmrc"
+- ".github/workflows/build.yml"
+- ".gitignore"
+- ".gitmodules"
+- ".yardopts"
 - Gemfile
 - Guardfile
 - LICENSE
@@ -137,24 +137,23 @@ files:
 homepage: https://github.com/slyphon/zk
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: A high-level wrapper around the zookeeper driver
 test_files:

data/.travis.yml

@@ -1,30 +0,0 @@
-# This should kick us over to the docker system
-sudo: false
-
-notifications:
-  email:
-    - slyphon@gmail.com
-    - eric@5stops.com
-
-env:
-  - SPAWN_ZOOKEEPER='true'
-
-# pull in releaseops submodule
-before_install:
-  - gem update bundler
-  - git submodule update --init --recursive
-
-rvm:
-  - 1.9.3
-  - 1.9.2
-  - 1.8.7
-  - ree
-  - 2.0.0
-  - 2.1.0
-  - 2.2.0
-
-# jruby specs are too intesive for travis
-#   - jruby-18mode
-#   - jruby-19mode
-
-bundler_args: --without development docs coverage