zk 1.9.3 → 1.10.0

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,8 +47,8 @@ RSpec.configure do |config|
   if ZK.spawn_zookeeper?
     require 'zk-server'
 
-    config.before(:suite) do 
-      ::Logging.logger['spec'].debug { "Starting zookeeper service" }
+    config.before(:suite) do
+      SpecGlobalLogger.logger.debug { "Starting zookeeper service" }
       ZK::Server.run do |c|
         c.client_port = ZK.test_port
         c.force_sync  = false
@@ -58,7 +57,7 @@ RSpec.configure do |config|
     end
 
     config.after(:suite) do
-      ::Logging.logger['spec'].debug { "stopping zookeeper service" }
+      SpecGlobalLogger.logger.debug  { "stopping zookeeper service" }
       ZK::Server.shutdown
     end
   end
@@ -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/support/bogus_mongoid.rb

@@ -1,6 +1,6 @@
 class BogusMongoid
   include ZK::Mongoid::Locking
-  include ZK::Logging
+  include ZK::Logger
 
   attr_reader :id
 

data/spec/support/client_forker.rb

@@ -1,5 +1,5 @@
 class ClientForker
-  include ZK::Logging
+  include ZK::Logger
   attr_reader :base_path, :cnx_args, :stat
 
   def self.run(cnx_args, base_path)

data/spec/support/event_catcher.rb

@@ -1,6 +1,6 @@
 class EventCatcher
   extend Forwardable
-  include ZK::Logging
+  include ZK::Logger
 
   def_delegators :@mutex, :synchronize
 

data/spec/support/logging.rb

@@ -1,68 +1,36 @@
 module ZK
   TEST_LOG_PATH = File.join(ZK::ZK_ROOT, 'test.log')
 
-  def self.logging_gem_setup
-    layout_opts = { 
-      :pattern => '%.1l, [%d #%p] (%9.9T) %25.25c{2}:  %m\n',
-    }
-
-    layout_opts[:date_pattern] = ZK.jruby? ? '%H:%M:%S.%3N' : '%H:%M:%S.%6N'
-
-    layout = ::Logging.layouts.pattern(layout_opts)
-
-    appender = ENV['ZK_DEBUG'] ? ::Logging.appenders.stderr : ::Logging.appenders.file(ZK::TEST_LOG_PATH)
-    appender.layout = layout
-#     appender.immediate_at = "debug,info,warn,error,fatal"
-#     appender.auto_flushing = true
-    appender.auto_flushing = 25
-    appender.flush_period = 5
-
-    %w[ZK ClientForker spec Zookeeper].each do |name|
-      ::Logging.logger[name].tap do |log|
-        log.appenders = [appender]
-        log.level = :debug
+  def self.setup_test_logger
+    log =
+      if ENV['ZK_DEBUG']
+        ::Logger.new(STDERR)
+      else
+        ::Logger.new(TEST_LOG_PATH)
       end
-    end
-
-    # this logger is kinda noisy
-    ::Logging.logger['ZK::EventHandler'].level = :info
-
-    Zookeeper.logger = ::Logging.logger['Zookeeper']
-    Zookeeper.logger.level = ENV['ZOOKEEPER_DEBUG'] ? :debug : :warn
-
-    ZK::ForkHook.after_fork_in_child { ::Logging.reopen }
-  end
 
+    log.level = ::Logger::DEBUG
 
-  def self.stdlib_logger_setup
-    require 'logger'
-    log = ::Logger.new($stderr).tap {|l| l.level = ::Logger::DEBUG }
-    ZK.logger = log
-    Zookeeper.logger = log
+    ZK::Logger.wrapped_logger = log
   end
 end
 
-ZK.logging_gem_setup
-# ZK.stdlib_logger_setup
-
-# Zookeeper.logger = ZK.logger.clone_new_log(:progname => 'zoo')
-# Zookeeper.logger = ZK.logger
-# Zookeeper.set_debug_level(4)
+ZK.setup_test_logger
 
 module SpecGlobalLogger
+  extend self
+
   def logger
-    @spec_global_logger ||= ::Logging.logger['spec']
+    @spec_global_logger ||= Zookeeper::Logger::ForwardingLogger.for(ZK::Logger.wrapped_logger, 'spec')
   end
 
   # sets the log level to FATAL for the duration of the block
   def mute_logger
-    zk_log = Logging.logger['ZK']
-    orig_level, zk_log.level = zk_log.level, :off
-    orig_zoo_level, Zookeeper.debug_level = Zookeeper.debug_level, Zookeeper::Constants::ZOO_LOG_LEVEL_ERROR
+    zk_log = ZK::Logger.wrapped_logger
+
+    orig_level, zk_log.level = zk_log.level, ::Logger::FATAL
     yield
   ensure
     zk_log.level = orig_level
-    Zookeeper.debug_level = orig_zoo_level
   end
 end
-

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
 

data/spec/zk/client_spec.rb

@@ -21,7 +21,7 @@ describe ZK::Client::Threaded 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
+        expect(@zk).to be_kind_of(ZK::Client::Threaded) # yeah yeah, just be sure
 
         shutdown_thread = nil
 
@@ -31,17 +31,17 @@ describe ZK::Client::Threaded do
 
         wait_while { shutdown_thread.nil? }
 
-        shutdown_thread.should_not be_nil
-        shutdown_thread.should be_kind_of(Thread)
+        expect(shutdown_thread).not_to be_nil
+        expect(shutdown_thread).to be_kind_of(Thread)
 
-        shutdown_thread.join(5).should == shutdown_thread
+        expect(shutdown_thread.join(5)).to eq(shutdown_thread)
 
-        wait_until(5) { @zk.closed? }.should be_true
+        expect(wait_until(5) { @zk.closed? }).to be(true)
       end
     end
   end
 
-  describe :reopen do
+  describe :reopen, :jruby => :broken do
     include_context 'connection opts'
 
     before do
@@ -53,15 +53,15 @@ describe ZK::Client::Threaded do
     end
 
     it %[should say the client is connected after reopen] do
-      @zk.connected?.should == true
+      expect(@zk.connected?).to eq(true)
 
       @zk.close!
 
-      @zk.connected?.should == false
+      expect(@zk.connected?).to eq(false)
 
       @zk.reopen
 
-      @zk.connected?.should == true
+      expect(@zk.connected?).to eq(true)
     end
   end
 
@@ -80,7 +80,7 @@ describe ZK::Client::Threaded do
       # TODO: this is a terrible test. there is no way to guarantee that this
       #       has been retried. the join at the end should not raise an error
 
-      @zk.should_not be_connected
+      expect(@zk).not_to be_connected
 
       th = Thread.new do
         @zk.stat('/path/to/blah', :retry_duration => 30)
@@ -89,11 +89,11 @@ describe ZK::Client::Threaded do
       th.run
 
       @zk.connect
-      th.join(5).should == th
+      expect(th.join(5)).to eq(th)
     end
 
     it %[barfs if the connection is closed before the connected event is received] do
-      @zk.should_not be_connected
+      expect(@zk).not_to be_connected
 
       exc = nil
 
@@ -110,14 +110,14 @@ describe ZK::Client::Threaded do
 
       @zk.close!
 
-      th.join(5).should == th
+      expect(th.join(5)).to eq(th)
 
-      exc.should_not be_nil
-      exc.should be_kind_of(ZK::Exceptions::Retryable)
+      expect(exc).not_to be_nil
+      expect(exc).to be_kind_of(ZK::Exceptions::Retryable)
     end
 
     it %[should barf if the timeout expires] do
-      @zk.should_not be_connected
+      expect(@zk).not_to be_connected
 
       exc = nil
 
@@ -132,10 +132,10 @@ describe ZK::Client::Threaded do
 
       th.run
 
-      th.join(5).should == th
+      expect(th.join(5)).to eq(th)
 
-      exc.should_not be_nil
-      exc.should be_kind_of(ZK::Exceptions::Retryable)
+      expect(exc).not_to be_nil
+      expect(exc).to be_kind_of(ZK::Exceptions::Retryable)
     end
   end
 end # ZK::Client::Threaded

data/spec/zk/election_spec.rb

@@ -4,7 +4,7 @@ describe ZK::Election, :jruby => :broken do
   include_context 'connection opts'
 
   before do
-    ZK.open(connection_host) do |cnx| 
+    ZK.open(connection_host) do |cnx|
       logger.debug { "REMOVING /_zkelection" }
       cnx.rm_rf('/_zkelection')
     end
@@ -56,8 +56,8 @@ describe ZK::Election, :jruby => :broken do
           end
 
           @palin.on_losing_election do
-            @obama_won.should be_true
-            @palin.leader_acked?.should be_true
+            expect(@obama_won).to be(true)
+            expect(@palin.leader_acked?).to be(true)
             @palin_lost = true
           end
 
@@ -68,21 +68,21 @@ describe ZK::Election, :jruby => :broken do
           oth.run
 
           wait_until { @obama_waiting }
-          @obama_waiting.should be_true
+          expect(@obama_waiting).to be(true)
 
           # palin's callbacks haven't fired
-          @palin_lost.should be_nil
+          expect(@palin_lost).to be_nil
 
           latch.release
 
           wait_until { @obama_won }
-          @obama_won.should be_true
+          expect(@obama_won).to be(true)
 
-          lambda { oth.join(1).should == oth }.should_not raise_error
+          expect { expect(oth.join(1)).to eq(oth) }.not_to raise_error
 
           wait_until { @palin_lost }
 
-          @palin_lost.should be_true
+          expect(@palin_lost).to be(true)
         end
       end
 
@@ -92,7 +92,7 @@ describe ZK::Election, :jruby => :broken do
           @obama_won = @obama_lost = @palin_won = @palin_lost = nil
           win_latch, lose_latch = Latch.new, Latch.new
 
-          @obama.on_winning_election do 
+          @obama.on_winning_election do
             logger.debug { "obama on_winning_election fired" }
             @obama_won = true
             win_latch.release
@@ -115,50 +115,50 @@ describe ZK::Election, :jruby => :broken do
             @palin_lost = true
             lose_latch.release
           end
-          
+
           @obama.vote!
           @palin.vote!
 
           win_latch.await
-          @obama_won.should be_true
+          expect(@obama_won).to be(true)
 
           lose_latch.await
-          @palin_lost.should be_true
+          expect(@palin_lost).to be(true)
         end
 
         describe 'winner' do
           it %[should fire the on_winning_election callbacks] do
-            @obama_won.should be_true
+            expect(@obama_won).to be(true)
           end
 
           it %[should not fire the on_losing_election callbacks] do
-            @obama_lost.should be_nil
+            expect(@obama_lost).to be_nil
           end
 
           it %[should acknowledge completion of winning callbacks] do
-            @zk.exists?(@obama.leader_ack_path).should be_true
+            expect(@zk.exists?(@obama.leader_ack_path)).to be(true)
           end
 
           it %[should write its data to the leader_ack node] do
-            @zk.get(@obama.leader_ack_path).first.should == @data1
+            expect(@zk.get(@obama.leader_ack_path).first).to eq(@data1)
           end
 
           it %[should know it's the leader] do
-            @obama.should be_leader
+            expect(@obama).to be_leader
           end
         end
 
         describe 'loser' do # gets a talk show on Fox News? I KEED! I KEED!
           it %[should know it isn't the leader] do
-            @palin.should_not be_leader
+            expect(@palin).not_to be_leader
           end
 
           it %[should not fire the winning callbacks] do
-            @palin_won.should_not be_true
+            expect(@palin_won).not_to be(true)
           end
 
           it %[should fire the losing callbacks] do
-            @palin_lost.should be_true
+            expect(@palin_lost).to be(true)
           end
 
           it %[should take over as leader when the current leader goes away] do
@@ -167,13 +167,13 @@ describe ZK::Election, :jruby => :broken do
             @obama.zk.close!
             wait_until { @palin_won }
 
-            @palin_won.should be_true # god forbid
+            expect(@palin_won).to be(true) # god forbid
 
             wait_until { @zk2.exists?(@palin.leader_ack_path) }
 
-            @zk2.exists?(@palin.leader_ack_path).should be_true
+            expect(@zk2.exists?(@palin.leader_ack_path)).to be(true)
 
-            @zk2.get(@palin.leader_ack_path).first.should == @data2
+            expect(@zk2.get(@palin.leader_ack_path).first).to eq(@data2)
           end
 
           it %[should remain leader if the original leader comes back] do
@@ -193,9 +193,9 @@ describe ZK::Election, :jruby => :broken do
               newbama.vote!
               wait_until { newbama.voted? }
 
-              newbama.should be_voted
-              win_again.should be_false
-              newbama.should_not be_leader
+              expect(newbama).to be_voted
+              expect(win_again).to be(false)
+              expect(newbama).not_to be_leader
             end
           end
         end
@@ -207,12 +207,12 @@ describe ZK::Election, :jruby => :broken do
     before do
       @zk3 = ZK.new(*connection_args)
 
-      @zk3.exists?('/_zkelection/2012/leader_ack').should be_false
+      expect(@zk3.exists?('/_zkelection/2012/leader_ack')).to be(false)
 
       @obama = ZK::Election::Candidate.new(@zk, @election_name, :data => @data1)
       @palin = ZK::Election::Candidate.new(@zk2, @election_name, :data => @data2)
 
-      @zk3.exists?('/_zkelection/2012/leader_ack').should be_false
+      expect(@zk3.exists?('/_zkelection/2012/leader_ack')).to be(false)
 
       @observer = ZK::Election::Observer.new(@zk3, @election_name)
     end
@@ -231,17 +231,17 @@ describe ZK::Election, :jruby => :broken do
 
           @observer.observe!
           wait_until { !@observer.leader_alive.nil? }
-          @observer.leader_alive.should_not be_nil
-          @zk3.exists?(@observer.root_election_node).should be_false
+          expect(@observer.leader_alive).not_to be_nil
+          expect(@zk3.exists?(@observer.root_election_node)).to be(false)
         end
 
         it %[should set leader_alive to false] do
-          @observer.leader_alive.should be_false
+          expect(@observer.leader_alive).to be(false)
         end
 
         it %[should fire death callbacks] do
-          @events.length.should == 1
-          @events.first.should == :death
+          expect(@events.length).to eq(1)
+          expect(@events.first).to eq(:death)
         end
       end
 
@@ -263,19 +263,19 @@ describe ZK::Election, :jruby => :broken do
         end
 
         it %[should be obama that won] do
-          @obama.should be_leader
+          expect(@obama).to be_leader
         end
 
         it %[should be palin that lost] do
-          @palin.should_not be_leader
+          expect(@palin).not_to be_leader
         end
 
         it %[should set leader_alive to true] do
-          @observer.leader_alive.should be_true
+          expect(@observer.leader_alive).to be(true)
         end
 
         it %[should fire the new leader callbacks] do
-          @got_life_event.should be_true
+          expect(@got_life_event).to be(true)
         end
       end
 
@@ -286,7 +286,7 @@ describe ZK::Election, :jruby => :broken do
           wait_until { @obama.leader? }
 
           @palin.vote!
-          @palin.should_not be_leader
+          expect(@palin).not_to be_leader
 
           @got_life_event = @got_death_event = false
 
@@ -297,23 +297,23 @@ describe ZK::Election, :jruby => :broken do
 
           wait_until { !@observer.leader_alive.nil? }
 
-          @observer.leader_alive.should be_true
+          expect(@observer.leader_alive).to be(true)
           @zk.close!
           wait_until { !@zk.connected? && @palin.leader? && @palin.leader_acked? }
         end
 
         it %[should be palin who is leader] do
-          @palin.should be_leader
+          expect(@palin).to be_leader
         end
 
         it %[should have seen both the death and life events] do
-          pending 'this test is flapping'
-          @got_life_event.should be_true
-          @got_death_event.should be_true
+          # pending 'this test is flapping'
+          expect(@got_life_event).to be(true)
+          expect(@got_death_event).to be(true)
         end
 
         it %[should see the data of the new leader] do
-          @observer.leader_data.should == 'palin'
+          expect(@observer.leader_data).to eq('palin')
         end
       end
     end

data/spec/zk/extensions_spec.rb

@@ -6,8 +6,8 @@ module ZK
 
       it %[should not barf if backtrace is nil] do
         exc = StandardError.new
-        exc.backtrace.should be_nil
-        lambda { exc.to_std_format }.should_not raise_error
+        expect(exc.backtrace).to be_nil
+        expect { exc.to_std_format }.not_to raise_error
       end
     end
   end