diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 3fea61b..9f48542 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -15,6 +15,7 @@ jobs:
       matrix:
         os:
           - ubuntu-latest
+          - ubuntu-20.04
           - macos-latest
         ruby:
           - '2.5'
@@ -30,6 +31,10 @@ jobs:
         exclude:
           - os: macos-latest
             gcc: 7
+          - os: ubuntu-latest
+            gcc: 7
+          - os: ubuntu-20.04
+            gcc: latest
 
     steps:
       - uses: actions/checkout@v2
diff --git a/CHANGELOG b/CHANGELOG
index 0c1ace6..61c2133 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,3 +1,6 @@
+v1.5.4
+  * Ruby 3.2 compatibility (h/t: @cheister & @EricRoos)
+
 v1.5.3
   * Ruby 3.1 compatibility (h/t: @casperisfine)
 
diff --git a/Gemfile b/Gemfile
index 388bc60..88b8017 100644
--- a/Gemfile
+++ b/Gemfile
@@ -2,10 +2,10 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'rake', '~> 0.9.0'
+gem 'rake', '>= 13.0'
 
 group :test do
-  gem "rspec" , "~> 2.11"
+  gem "rspec" , "~> 3.0"
   gem 'eventmachine', '1.0.4'
   gem 'evented-spec', '~> 0.9.0'
   gem 'zk-server', '~> 1.0', :git => 'https://github.com/zk-ruby/zk-server.git'
diff --git a/Rakefile b/Rakefile
index 4a1c65e..69f3d9e 100644
--- a/Rakefile
+++ b/Rakefile
@@ -4,7 +4,7 @@ release_ops_path = File.expand_path('../releaseops/lib', __FILE__)
 # we use a submodule because it doesn't depend on anything else (*cough* bundler)
 # and can be shared across projects
 #
-if File.exists?(release_ops_path)
+if File.exist?(release_ops_path)
   require File.join(release_ops_path, 'releaseops')
 
   # sets up the multi-ruby zk:test_all rake tasks
@@ -17,7 +17,7 @@ if File.exists?(release_ops_path)
   # Define a task to run code coverage tests
   ReleaseOps::TestTasks.define_simplecov_tasks
 
-  # set up yard:server, yard:gems, and yard:clean tasks 
+  # set up yard:server, yard:gems, and yard:clean tasks
   # for doing documentation stuff
   ReleaseOps::YardTasks.define
 
diff --git a/ext/Rakefile b/ext/Rakefile
index cff8a5c..1a27115 100644
--- a/ext/Rakefile
+++ b/ext/Rakefile
@@ -4,9 +4,9 @@ ZKRB_WRAPPER = %w[zkrb_wrapper.c zkrb_wrapper.h]
 
 namespace :zkrb do
   task :clean do
-    if File.exists?('Makefile')
+    if File.exist?('Makefile')
       sh 'make clean'
-      rm 'Makefile' # yep, regenerate this
+      FileUtils.rm('Makefile') # yep, regenerate this
     else
       $stderr.puts "nothing to clean, no Makefile"
     end
diff --git a/ext/extconf.rb b/ext/extconf.rb
index d9b3813..4111042 100644
--- a/ext/extconf.rb
+++ b/ext/extconf.rb
@@ -58,7 +58,7 @@ def safe_sh(cmd)
   else
     puts "Building zkc."
 
-    unless File.exists?('c')
+    unless File.exist?('c')
       safe_sh "tar xzf #{BUNDLE} 2>&1"
       PATCHES.each do |patch|
         safe_sh "patch -p0 < #{patch} 2>&1"
@@ -87,7 +87,7 @@ def safe_sh(cmd)
     %w[a la dylib].each do |ext|
       origin_lib_name = "libzookeeper_#{stmt}.#{ext}"
       dest_lib_name = "libzookeeper_#{stmt}_gem.#{ext}"
-      system("cp -f #{origin_lib_name} #{dest_lib_name}") if File.exists?(origin_lib_name)
+      system("cp -f #{origin_lib_name} #{dest_lib_name}") if File.exist?(origin_lib_name)
     end
   end
 end
diff --git a/lib/zookeeper/version.rb b/lib/zookeeper/version.rb
index 4dfa498..d9908f5 100644
--- a/lib/zookeeper/version.rb
+++ b/lib/zookeeper/version.rb
@@ -1,4 +1,4 @@
 module Zookeeper
-  VERSION = '1.5.3'
+  VERSION = '1.5.4'
   DRIVER_VERSION = '3.4.5'
 end
diff --git a/spec/c_zookeeper_spec.rb b/spec/c_zookeeper_spec.rb
index e83e899..68b4fcb 100644
--- a/spec/c_zookeeper_spec.rb
+++ b/spec/c_zookeeper_spec.rb
@@ -29,20 +29,20 @@ def wait_until_connected(timeout=10)
       end
 
       it %[should be in connected state within a reasonable amount of time] do
-        wait_until_connected.should be_true
+        expect(wait_until_connected).to be_truthy
       end
 
       describe :after_connected do
         before do
-          wait_until_connected.should be_true
+          expect(wait_until_connected).to be_truthy
         end
 
         it %[should have a connection event after being connected] do
           event = wait_until(10) { @event_queue.pop }
-          event.should be
-          event[:req_id].should == Zookeeper::Constants::ZKRB_GLOBAL_CB_REQ
-          event[:type].should   == Zookeeper::Constants::ZOO_SESSION_EVENT
-          event[:state].should  == Zookeeper::Constants::ZOO_CONNECTED_STATE
+          expect(event).to be
+          expect(event[:req_id]).to eq(Zookeeper::Constants::ZKRB_GLOBAL_CB_REQ)
+          expect(event[:type]).to   eq(Zookeeper::Constants::ZOO_SESSION_EVENT)
+          expect(event[:state]).to  eq(Zookeeper::Constants::ZOO_CONNECTED_STATE)
         end
       end
     end
diff --git a/spec/chrooted_connection_spec.rb b/spec/chrooted_connection_spec.rb
index c0d2c09..bf7f9bf 100644
--- a/spec/chrooted_connection_spec.rb
+++ b/spec/chrooted_connection_spec.rb
@@ -3,7 +3,7 @@
 
 describe 'Zookeeper chrooted' do
   let(:path) { "/_zkchroottest_" }
-  let(:data) { "underpants" } 
+  let(:data) { "underpants" }
   let(:chroot_path) { '/slyphon-zookeeper-chroot' }
 
   let(:connection_string) { "#{Zookeeper.default_cnx_str}#{chroot_path}" }
@@ -35,8 +35,8 @@ def zk
 
         it %[should successfully create the path] do
           rv = zk.create(:path => '/', :data => '')
-          rv[:rc].should be_zero
-          rv[:path].should == ''
+          expect(rv[:rc]).to be_zero
+          expect(rv[:path]).to eq('')
         end
       end
     end
@@ -53,8 +53,8 @@ def zk
 
         it %[should return ZNONODE] do
           rv = zk.create(:path => '/', :data => '')
-          rv[:rc].should_not be_zero
-          rv[:rc].should == Zookeeper::Exceptions::ZNONODE
+          expect(rv[:rc]).not_to be_zero
+          expect(rv[:rc]).to eq(Zookeeper::Exceptions::ZNONODE)
         end
       end
     end
@@ -62,15 +62,15 @@ def zk
 
 
   describe do
-    before :all do
-      logger.warn "running before :all"
+    before :each do
+      logger.warn "running before :each"
 
       with_open_zk do |z|
         z.create(:path => chroot_path, :data => '')
       end
     end
 
-    after :all do
+    after :each do
       with_open_zk do |z|
         rm_rf(z, chroot_path)
       end
diff --git a/spec/compatibilty_spec.rb b/spec/compatibilty_spec.rb
index 68bcfce..e34b586 100644
--- a/spec/compatibilty_spec.rb
+++ b/spec/compatibilty_spec.rb
@@ -2,7 +2,7 @@
 
 describe 'Compatibiliy layer' do
   it %[should raise the correct error when a const is missing] do
-    lambda { Zookeeper::THISISANINVALIDCONST }.should raise_error(NameError)
+    expect { Zookeeper::THISISANINVALIDCONST }.to raise_error(NameError)
   end
 end
 
diff --git a/spec/default_watcher_spec.rb b/spec/default_watcher_spec.rb
index 7ae7c23..846437f 100644
--- a/spec/default_watcher_spec.rb
+++ b/spec/default_watcher_spec.rb
@@ -4,7 +4,7 @@
   describe :initialize, 'with watcher block' do
     before do
       @events = []
-      @watch_block = lambda do |hash| 
+      @watch_block = lambda do |hash|
         logger.debug "watch_block: #{hash.inspect}"
         @events << hash
       end
@@ -12,7 +12,7 @@
       @zk = Zookeeper.new(Zookeeper.default_cnx_str, 10, @watch_block)
 
       wait_until(2) { @zk.connected? }
-      @zk.should be_connected
+      expect(@zk).to be_connected
       logger.debug "connected!"
 
       wait_until(2) { !@events.empty? }
@@ -24,9 +24,9 @@
     end
 
     it %[should receive initial connection state events] do
-      @events.should_not be_empty
-      @events.length.should == 1
-      @events.first[:state].should == Zookeeper::ZOO_CONNECTED_STATE
+      expect(@events).not_to be_empty
+      expect(@events.length).to eq(1)
+      expect(@events.first[:state]).to eq(Zookeeper::ZOO_CONNECTED_STATE)
     end
 
     it %[should receive disconnection events] do
@@ -34,7 +34,7 @@
       @events.clear
       @zk.close
       wait_until(2) { !@events.empty? }
-      @events.should_not be_empty
+      expect(@events).not_to be_empty
     end
   end
 end
diff --git a/spec/em_spec.rb b/spec/em_spec.rb
index 1f7e33d..6f67633 100644
--- a/spec/em_spec.rb
+++ b/spec/em_spec.rb
@@ -20,7 +20,7 @@ def setup_zk
     end
 
     def teardown_and_done
-      @zk.close do 
+      @zk.close do
         logger.debug { "TEST: about to call done" }
         EM.next_tick do
           done
@@ -31,7 +31,7 @@ def teardown_and_done
     describe 'callbacks' do
       it %[should be called on the reactor thread] do
         cb = lambda do |h|
-          EM.reactor_thread?.should be_true
+          expect(EM.reactor_thread?).to be_truthy
           logger.debug { "called back on the reactor thread? #{EM.reactor_thread?}" }
           teardown_and_done
         end
@@ -39,7 +39,7 @@ def teardown_and_done
         setup_zk do
           @zk.on_attached do |*|
             logger.debug { "on_attached called" }
-            rv = @zk.get(:path => '/', :callback => cb) 
+            rv = @zk.get(:path => '/', :callback => cb)
             logger.debug { "rv from @zk.get: #{rv.inspect}" }
           end
         end
diff --git a/spec/ext/zookeeper_base_spec.rb b/spec/ext/zookeeper_base_spec.rb
index eb11a20..a305e73 100644
--- a/spec/ext/zookeeper_base_spec.rb
+++ b/spec/ext/zookeeper_base_spec.rb
@@ -11,7 +11,7 @@
     end
 
     it %[should have an original_pid assigned] do
-      @zk.original_pid.should == Process.pid
+      expect(@zk.original_pid).to eq(Process.pid)
     end
   end
 end
diff --git a/spec/forked_connection_spec.rb b/spec/forked_connection_spec.rb
index faae6a9..24aeef7 100644
--- a/spec/forked_connection_spec.rb
+++ b/spec/forked_connection_spec.rb
@@ -112,11 +112,11 @@ def wait_for_child_safely(pid, timeout=5)
       status = wait_for_child_safely(@pid)
       raise "Child process did not exit, likely hung"  unless status
 
-      status.should_not be_signaled
-      status.should be_success
+      expect(status).not_to be_signaled
+      expect(status).to be_success
 
-      event_waiter_th.join(5).should == event_waiter_th
-      @event.should_not be_nil
+      expect(event_waiter_th.join(5)).to eq(event_waiter_th)
+      expect(@event).not_to be_nil
     end
   end
 end
diff --git a/spec/latch_spec.rb b/spec/latch_spec.rb
index e3ea009..38f6576 100644
--- a/spec/latch_spec.rb
+++ b/spec/latch_spec.rb
@@ -16,7 +16,7 @@
         end
 
         other_latch.await
-        th.join(1).should == th
+        expect(th.join(1)).to eq(th)
       end
     end
   end
diff --git a/spec/shared/all_success_return_values.rb b/spec/shared/all_success_return_values.rb
index aa9c4bc..283c79a 100644
--- a/spec/shared/all_success_return_values.rb
+++ b/spec/shared/all_success_return_values.rb
@@ -1,10 +1,10 @@
 shared_examples_for "all success return values" do
   it %[should have a return code of Zookeeper::ZOK] do
-    @rv[:rc].should == Zookeeper::ZOK
+    expect(@rv[:rc]).to eq(Zookeeper::ZOK)
   end
 
   it %[should have a req_id integer] do
-    @rv[:req_id].should be_kind_of(Integer)
+    expect(@rv[:req_id]).to be_kind_of(Integer)
   end
 end
 
diff --git a/spec/shared/connection_examples.rb b/spec/shared/connection_examples.rb
index 0c62e2f..b8f7a9b 100644
--- a/spec/shared/connection_examples.rb
+++ b/spec/shared/connection_examples.rb
@@ -10,14 +10,6 @@
     ensure_node(zk, path, data)
   end
 
-  after :all do
-    logger.warn "running shared examples after :all"
-
-    with_open_zk(connection_string) do |z|
-      rm_rf(z, path)
-    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
@@ -29,12 +21,12 @@
       end
 
       it %[should return the data] do
-        @rv[:data].should == data
+        expect(@rv[:data]).to eq(data)
       end
 
       it %[should return a stat] do
-        @rv[:stat].should_not be_nil
-        @rv[:stat].should be_kind_of(Zookeeper::Stat)
+        expect(@rv[:stat]).not_to be_nil
+        expect(@rv[:stat]).to be_kind_of(Zookeeper::Stat)
       end
     end
 
@@ -45,23 +37,23 @@
         @event = nil
         @watcher = Zookeeper::Callbacks::WatcherCallback.new
 
-        @rv = zk.get(:path => path, :watcher => @watcher, :watcher_context => path) 
+        @rv = zk.get(:path => path, :watcher => @watcher, :watcher_context => path)
       end
 
       it %[should return the data] do
-        @rv[:data].should == data
+        expect(@rv[:data]).to eq(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
+        expect(zk.set(:path => path, :data => 'blah')[:rc]).to 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
+        expect(@watcher.path).to eq(path)
+        expect(@watcher.context).to eq(path)
+        expect(@watcher).to be_completed
+        expect(@watcher.type).to eq(Zookeeper::ZOO_CHANGED_EVENT)
       end
     end
 
@@ -71,22 +63,22 @@
 
         @rv = zk.get(:path => path, :callback => @cb, :callback_context => path)
         wait_until(1.0) { @cb.completed? }
-        @cb.should be_completed
+        expect(@cb).to 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
+        expect(@cb.return_code).to eq(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(Zookeeper::Stat)
+        expect(@cb.stat).not_to be_nil
+        expect(@cb.stat).to be_kind_of(Zookeeper::Stat)
       end
 
       it %[should have the data] do
-        @cb.data.should == data
+        expect(@cb.data).to eq(data)
       end
     end
 
@@ -100,38 +92,38 @@
 
         @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
+        expect(@cb).to be_completed
         logger.debug { "-----------------> ASYNC GET REQUEST WITH WATCH COMPLETE <--------------------" }
       end
 
       it %[should have the stat object in the callback] do
-        @cb.stat.should_not be_nil
-        @cb.stat.should be_kind_of(Zookeeper::Stat)
+        expect(@cb.stat).not_to be_nil
+        expect(@cb.stat).to be_kind_of(Zookeeper::Stat)
       end
 
       it %[should have the data] do
-        @cb.data.should == data
+        expect(@cb.data).to eq(data)
       end
 
       it %[should have a return code of ZOK] do
-        @cb.return_code.should == Zookeeper::ZOK
+        expect(@cb.return_code).to eq(Zookeeper::ZOK)
       end
 
       it %[should set a watcher on the node] do
-        zk.set(:path => path, :data => 'blah')[:rc].should be_zero
+        expect(zk.set(:path => path, :data => 'blah')[:rc]).to be_zero
 
         wait_until(2) { @watcher.completed? }
 
-        @watcher.should be_completed
+        expect(@watcher).to be_completed
 
-        @watcher.path.should == path
-        @watcher.context.should == path
+        expect(@watcher.path).to eq(path)
+        expect(@watcher.context).to eq(path)
       end
     end
 
     describe 'bad arguments' do
       it %[should barf with a BadArguments error] do
-        lambda { zk.get(:bad_arg => 'what!?') }.should raise_error(Zookeeper::Exceptions::BadArguments)
+        expect { zk.get(:bad_arg => 'what!?') }.to raise_error(Zookeeper::Exceptions::BadArguments)
       end
     end
   end   # get
@@ -151,9 +143,9 @@
         end
 
         it %[should return the new stat] do
-          @rv[:stat].should_not be_nil
-          @rv[:stat].should be_kind_of(Zookeeper::Stat)
-          @rv[:stat].version.should > @stat.version
+          expect(@rv[:stat]).not_to be_nil
+          expect(@rv[:stat]).to be_kind_of(Zookeeper::Stat)
+          expect(@rv[:stat].version).to be > @stat.version
         end
       end
 
@@ -165,9 +157,9 @@
         end
 
         it %[should return the new stat] do
-          @rv[:stat].should_not be_nil
-          @rv[:stat].should be_kind_of(Zookeeper::Stat)
-          @rv[:stat].version.should > @stat.version
+          expect(@rv[:stat]).not_to be_nil
+          expect(@rv[:stat]).to be_kind_of(Zookeeper::Stat)
+          expect(@rv[:stat].version).to be > @stat.version
         end
       end
 
@@ -180,11 +172,11 @@
         end
 
         it %[should have a return code of ZBADVERSION] do
-          @rv[:rc].should == Zookeeper::ZBADVERSION
+          expect(@rv[:rc]).to eq(Zookeeper::ZBADVERSION)
         end
 
         it %[should return a stat with !exists] do
-          @rv[:stat].exists.should be_false
+          expect(@rv[:stat].exists).to be_falsey
         end
       end
 
@@ -192,7 +184,7 @@
         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(Zookeeper::Exceptions::DataTooLargeException)
+          expect { zk.set(:path => path, :data => large_data) }.to raise_error(Zookeeper::Exceptions::DataTooLargeException)
         end
       end
     end   # sync
@@ -209,16 +201,16 @@
           @rv = zk.set(:path => path, :data => @new_data, :callback => @cb, :callback_context => path)
 
           wait_until(2) { @cb.completed? }
-          @cb.should be_completed
+          expect(@cb).to be_completed
         end
 
         it %[should have the stat in the callback] do
-          @cb.stat.should_not be_nil
-          @cb.stat.version.should > @stat.version
+          expect(@cb.stat).not_to be_nil
+          expect(@cb.stat.version).to be > @stat.version
         end
 
         it %[should have a return code of ZOK] do
-          @cb.return_code.should == Zookeeper::ZOK
+          expect(@cb.return_code).to eq(Zookeeper::ZOK)
         end
       end
 
@@ -229,16 +221,16 @@
           @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
+          expect(@cb).to be_completed
         end
 
         it %[should have the stat in the callback] do
-          @cb.stat.should_not be_nil
-          @cb.stat.version.should > @stat.version
+          expect(@cb.stat).not_to be_nil
+          expect(@cb.stat.version).to be > @stat.version
         end
 
         it %[should have a return code of ZOK] do
-          @cb.return_code.should == Zookeeper::ZOK
+          expect(@cb.return_code).to eq(Zookeeper::ZOK)
         end
       end
 
@@ -250,15 +242,15 @@
           @rv = zk.set(:path => path, :data => @new_data, :callback => @cb, :callback_context => path, :version => 0)
 
           wait_until(2) { @cb.completed? }
-          @cb.should be_completed
+          expect(@cb).to be_completed
         end
 
         it %[should have a return code of ZBADVERSION] do
-          @cb.return_code.should == Zookeeper::ZBADVERSION
+          expect(@cb.return_code).to eq(Zookeeper::ZBADVERSION)
         end
 
         it %[should return a stat with !exists] do
-          @cb.stat.exists.should be_false
+          expect(@cb.stat.exists).to be_falsey
         end
       end
 
@@ -266,7 +258,7 @@
         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(Zookeeper::Exceptions::DataTooLargeException)
+          expect { zk.set(:path => path, :data => large_data, :callback => @cb, :callback_context => path) }.to raise_error(Zookeeper::Exceptions::DataTooLargeException)
         end
       end
 
@@ -282,7 +274,7 @@
       # gahhh, this shouldn't be like this.... :P
       rv = rv.respond_to?(:intValue) ? rv.intValue : rv
 
-      rv.should == Zookeeper::ZOK
+      expect(rv).to eq(Zookeeper::ZOK)
     end
   end
 
@@ -309,17 +301,17 @@
       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 
+        expect(@rv[:children]).to be_kind_of(Array)
+        expect(@rv[:children].length).to eq(3)
+        expect(@rv[:children].sort).to eq(@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(Zookeeper::Stat)
-        @rv[:stat].num_children.should == 3
+        expect(@rv[:stat]).not_to be_nil
+        expect(@rv[:stat]).to be_kind_of(Zookeeper::Stat)
+        expect(@rv[:stat].num_children).to eq(3)
       end
     end
 
@@ -339,28 +331,28 @@
       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 
+        expect(@rv[:children]).to be_kind_of(Array)
+        expect(@rv[:children].length).to eq(3)
+        expect(@rv[:children].sort).to eq(@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(Zookeeper::Stat)
-        @rv[:stat].num_children.should == 3
+        expect(@rv[:stat]).not_to be_nil
+        expect(@rv[:stat]).to be_kind_of(Zookeeper::Stat)
+        expect(@rv[:stat].num_children).to eq(3)
       end
 
       it %[should set a watcher for children on the node] do
-        @watcher.should_not be_completed
+        expect(@watcher).not_to be_completed
 
-        zk.create(:path => "#{path}/#{@addtl_child}", :data => '')[:rc].should == Zookeeper::ZOK
+        expect(zk.create(:path => "#{path}/#{@addtl_child}", :data => '')[:rc]).to eq(Zookeeper::ZOK)
 
         wait_until { @watcher.completed? }
-        @watcher.should be_completed
+        expect(@watcher).to be_completed
 
-        @watcher.path.should == path
-        @watcher.context.should == path
-        @watcher.type.should == Zookeeper::ZOO_CHILD_EVENT
+        expect(@watcher.path).to eq(path)
+        expect(@watcher.context).to eq(path)
+        expect(@watcher.type).to eq(Zookeeper::ZOO_CHILD_EVENT)
       end
     end
 
@@ -372,23 +364,23 @@
         @rv = zk.get_children(:path => path, :callback => @cb, :callback_context => path)
 
         wait_until { @cb.completed? }
-        @cb.should be_completed
+        expect(@cb).to be_completed
       end
 
       it %[should succeed] do
-        @cb.return_code.should == Zookeeper::ZOK
+        expect(@cb.return_code).to eq(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 
+        expect(@cb.children).to be_kind_of(Array)
+        expect(@cb.children.length).to eq(3)
+        expect(@cb.children.sort).to eq(@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(Zookeeper::Stat)
-        @cb.stat.num_children.should == 3
+        expect(@cb.stat).not_to be_nil
+        expect(@cb.stat).to be_kind_of(Zookeeper::Stat)
+        expect(@cb.stat.num_children).to eq(3)
       end
     end
 
@@ -403,7 +395,7 @@
 
         @rv = zk.get_children(:path => path, :watcher => @watcher, :watcher_context => path, :callback => @cb, :callback_context => path)
         wait_until { @cb.completed? }
-        @cb.should be_completed
+        expect(@cb).to be_completed
       end
 
       after do
@@ -411,32 +403,32 @@
       end
 
       it %[should succeed] do
-        @cb.return_code.should == Zookeeper::ZOK
+        expect(@cb.return_code).to eq(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 
+        expect(@cb.children).to be_kind_of(Array)
+        expect(@cb.children.length).to eq(3)
+        expect(@cb.children.sort).to eq(@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(Zookeeper::Stat)
-        @cb.stat.num_children.should == 3
+        expect(@cb.stat).not_to be_nil
+        expect(@cb.stat).to be_kind_of(Zookeeper::Stat)
+        expect(@cb.stat.num_children).to eq(3)
       end
 
       it %[should set a watcher for children on the node] do
-        @watcher.should_not be_completed
+        expect(@watcher).not_to be_completed
 
-        zk.create(:path => "#{path}/#{@addtl_child}", :data => '')[:rc].should == Zookeeper::ZOK
+        expect(zk.create(:path => "#{path}/#{@addtl_child}", :data => '')[:rc]).to eq(Zookeeper::ZOK)
 
         wait_until { @watcher.completed? }
-        @watcher.should be_completed
+        expect(@watcher).to be_completed
 
-        @watcher.path.should == path
-        @watcher.context.should == path
-        @watcher.type.should == Zookeeper::ZOO_CHILD_EVENT
+        expect(@watcher.path).to eq(path)
+        expect(@watcher.context).to eq(path)
+        expect(@watcher.type).to eq(Zookeeper::ZOO_CHILD_EVENT)
       end
     end
   end
@@ -451,20 +443,20 @@
 
         @rv = zk.get_children(:path => path, :watcher => @watcher, :watcher_context => path, :callback => @cb, :callback_context => path)
         wait_until { @cb.completed? }
-        @cb.should be_completed
+        expect(@cb).to be_completed
       end
 
       it %[should fire the watcher when the node has been deleted] do
-        @watcher.should_not be_completed
+        expect(@watcher).not_to be_completed
 
-        zk.delete(:path => path)[:rc].should == Zookeeper::ZOK
+        expect(zk.delete(:path => path)[:rc]).to eq(Zookeeper::ZOK)
 
         wait_until { @watcher.completed? }
-        @watcher.should be_completed
+        expect(@watcher).to be_completed
 
-        @watcher.path.should == path
-        @watcher.context.should == path
-        @watcher.type.should == Zookeeper::ZOO_DELETED_EVENT
+        expect(@watcher.path).to eq(path)
+        expect(@watcher.context).to eq(path)
+        expect(@watcher.type).to eq(Zookeeper::ZOO_DELETED_EVENT)
       end
     end
   end
@@ -481,7 +473,7 @@
       end
 
       it %[should have a stat object] do
-        @rv[:stat].should be_kind_of(Zookeeper::Stat)
+        expect(@rv[:stat]).to be_kind_of(Zookeeper::Stat)
       end
     end
 
@@ -495,20 +487,20 @@
       end
 
       it %[should have a stat object] do
-        @rv[:stat].should be_kind_of(Zookeeper::Stat)
+        expect(@rv[:stat]).to be_kind_of(Zookeeper::Stat)
       end
 
       it %[should set a watcher for data changes on the node] do
-        @watcher.should_not be_completed
+        expect(@watcher).not_to be_completed
 
-        zk.set(:path => path, :data => 'skunk')[:rc].should == Zookeeper::ZOK
+        expect(zk.set(:path => path, :data => 'skunk')[:rc]).to eq(Zookeeper::ZOK)
 
         wait_until { @watcher.completed? }
-        @watcher.should be_completed
+        expect(@watcher).to be_completed
 
-        @watcher.path.should == path
-        @watcher.context.should == path
-        @watcher.type.should == Zookeeper::ZOO_CHANGED_EVENT
+        expect(@watcher.path).to eq(path)
+        expect(@watcher.context).to eq(path)
+        expect(@watcher.type).to eq(Zookeeper::ZOO_CHANGED_EVENT)
       end
     end
 
@@ -520,15 +512,15 @@
         @rv = zk.stat(:path => path, :callback => @cb, :callback_context => path)
 
         wait_until { @cb.completed? }
-        @cb.should be_completed
+        expect(@cb).to be_completed
       end
 
       it %[should succeed] do
-        @cb.return_code.should == Zookeeper::ZOK
+        expect(@cb.return_code).to eq(Zookeeper::ZOK)
       end
 
       it %[should have a stat object] do
-        @cb.stat.should be_kind_of(Zookeeper::Stat)
+        expect(@cb.stat).to be_kind_of(Zookeeper::Stat)
       end
     end
 
@@ -544,7 +536,7 @@
         @rv = zk.stat(:path => path, :callback => @cb, :callback_context => path, :watcher => @watcher, :watcher_context => path)
 
         wait_until { @cb.completed? }
-        @cb.should be_completed
+        expect(@cb).to be_completed
       end
 
       after do
@@ -552,24 +544,24 @@
       end
 
       it %[should succeed] do
-        @cb.return_code.should == Zookeeper::ZOK
+        expect(@cb.return_code).to eq(Zookeeper::ZOK)
       end
 
       it %[should have a stat object] do
-        @cb.stat.should be_kind_of(Zookeeper::Stat)
+        expect(@cb.stat).to be_kind_of(Zookeeper::Stat)
       end
 
       it %[should set a watcher for data changes on the node] do
-        @watcher.should_not be_completed
+        expect(@watcher).not_to be_completed
 
-        zk.set(:path => path, :data => 'skunk')[:rc].should == Zookeeper::ZOK
+        expect(zk.set(:path => path, :data => 'skunk')[:rc]).to eq(Zookeeper::ZOK)
 
         wait_until { @watcher.completed? }
-        @watcher.should be_completed
+        expect(@watcher).to be_completed
 
-        @watcher.path.should == path
-        @watcher.context.should == path
-        @watcher.type.should == Zookeeper::ZOO_CHANGED_EVENT
+        expect(@watcher.path).to eq(path)
+        expect(@watcher.context).to eq(path)
+        expect(@watcher.type).to eq(Zookeeper::ZOO_CHANGED_EVENT)
       end
     end
   end   # stat
@@ -585,7 +577,7 @@
         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(Zookeeper::Exceptions::DataTooLargeException)
+          expect { zk.create(:path => path, :data => large_data) }.to raise_error(Zookeeper::Exceptions::DataTooLargeException)
         end
       end
 
@@ -597,14 +589,14 @@
         end
 
         it %[should return the path that was set] do
-          @rv[:path].should == path
+          expect(@rv[:path]).to eq(path)
         end
 
         it %[should have created a permanent node] do
           st = zk.stat(:path => path)
-          st[:rc].should == Zookeeper::ZOK
+          expect(st[:rc]).to eq(Zookeeper::ZOK)
 
-          st[:stat].ephemeral_owner.should == 0
+          expect(st[:stat].ephemeral_owner).to eq(0)
         end
       end
 
@@ -616,14 +608,14 @@
         end
 
         it %[should return the path that was set] do
-          @rv[:path].should == path
+          expect(@rv[:path]).to eq(path)
         end
 
         it %[should have created a ephemeral node] do
           st = zk.stat(:path => path)
-          st[:rc].should == Zookeeper::ZOK
+          expect(st[:rc]).to eq(Zookeeper::ZOK)
 
-          st[:stat].ephemeral_owner.should_not be_zero
+          expect(st[:stat].ephemeral_owner).not_to be_zero
         end
       end
 
@@ -641,14 +633,14 @@
         end
 
         it %[should return the path that was set] do
-          @rv[:path].should_not == @orig_path
+          expect(@rv[:path]).not_to eq(@orig_path)
         end
 
         it %[should have created a permanent node] do
           st = zk.stat(:path => @s_path)
-          st[:rc].should == Zookeeper::ZOK
+          expect(st[:rc]).to eq(Zookeeper::ZOK)
 
-          st[:stat].ephemeral_owner.should be_zero
+          expect(st[:stat].ephemeral_owner).to be_zero
         end
       end
 
@@ -666,18 +658,18 @@
         end
 
         it %[should return the path that was set] do
-          @rv[:path].should_not == @orig_path
+          expect(@rv[:path]).not_to eq(@orig_path)
         end
 
         it %[should have created an ephemeral node] do
           st = zk.stat(:path => @s_path)
-          st[:rc].should == Zookeeper::ZOK
+          expect(st[:rc]).to eq(Zookeeper::ZOK)
 
-          st[:stat].ephemeral_owner.should_not be_zero
+          expect(st[:stat].ephemeral_owner).not_to be_zero
         end
       end
 
-      describe :acl do
+      xdescribe :acl do
         it %[should work] do
           pending "need to write acl tests"
         end
@@ -695,22 +687,22 @@
         before do
           @rv = zk.create(:path => path, :callback => @cb, :callback_context => path)
           wait_until(2) { @cb.completed? }
-          @cb.should be_completed
+          expect(@cb).to be_completed
         end
 
         it %[should have a path] do
-          @cb.path.should_not be_nil
+          expect(@cb.path).not_to be_nil
         end
 
         it %[should return the path that was set] do
-          @cb.path.should == path
+          expect(@cb.path).to eq(path)
         end
 
         it %[should have created a permanent node] do
           st = zk.stat(:path => path)
-          st[:rc].should == Zookeeper::ZOK
+          expect(st[:rc]).to eq(Zookeeper::ZOK)
 
-          st[:stat].ephemeral_owner.should == 0
+          expect(st[:stat].ephemeral_owner).to eq(0)
         end
       end
 
@@ -718,9 +710,9 @@
         it %[should barf if the data size is too large], :input_size => true do
           large_data = '0' * (1024 ** 2)
 
-          lambda do
+          expect do
             zk.create(:path => path, :data => large_data, :callback => @cb, :callback_context => path)
-          end.should raise_error(Zookeeper::Exceptions::DataTooLargeException)
+          end.to raise_error(Zookeeper::Exceptions::DataTooLargeException)
         end
       end
 
@@ -731,22 +723,22 @@
         before do
           @rv = zk.create(:path => path, :ephemeral => true, :callback => @cb, :callback_context => path)
           wait_until(2) { @cb.completed? }
-          @cb.should be_completed
+          expect(@cb).to be_completed
         end
 
         it %[should have a path] do
-          @cb.path.should_not be_nil
+          expect(@cb.path).not_to be_nil
         end
 
         it %[should return the path that was set] do
-          @cb.path.should == path
+          expect(@cb.path).to eq(path)
         end
 
         it %[should have created a ephemeral node] do
           st = zk.stat(:path => path)
-          st[:rc].should == Zookeeper::ZOK
+          expect(st[:rc]).to eq(Zookeeper::ZOK)
 
-          st[:stat].ephemeral_owner.should_not be_zero
+          expect(st[:stat].ephemeral_owner).not_to be_zero
         end
       end
 
@@ -758,7 +750,7 @@
           @rv         = zk.create(:path => path, :sequence => true, :callback => @cb, :callback_context => path)
 
           wait_until(2) { @cb.completed? }
-          @cb.should be_completed
+          expect(@cb).to be_completed
 
           @s_path = @cb.path
         end
@@ -768,18 +760,18 @@
         end
 
         it %[should have a path] do
-          @cb.path.should_not be_nil
+          expect(@cb.path).not_to be_nil
         end
 
         it %[should return the path that was set] do
-          @cb.path.should_not == @orig_path
+          expect(@cb.path).not_to eq(@orig_path)
         end
 
         it %[should have created a permanent node] do
           st = zk.stat(:path => @s_path)
-          st[:rc].should == Zookeeper::ZOK
+          expect(st[:rc]).to eq(Zookeeper::ZOK)
 
-          st[:stat].ephemeral_owner.should be_zero
+          expect(st[:stat].ephemeral_owner).to be_zero
         end
       end
 
@@ -792,7 +784,7 @@
           path       = @rv[:path]    # make sure this gets cleaned up
 
           wait_until(2) { @cb.completed? }
-          @cb.should be_completed
+          expect(@cb).to be_completed
           @s_path = @cb.path
         end
 
@@ -801,18 +793,18 @@
         end
 
         it %[should have a path] do
-          @cb.path.should_not be_nil
+          expect(@cb.path).not_to be_nil
         end
 
         it %[should return the path that was set] do
-          @s_path.should_not == @orig_path
+          expect(@s_path).not_to eq(@orig_path)
         end
 
         it %[should have created an ephemeral node] do
           st = zk.stat(:path => @s_path)
-          st[:rc].should == Zookeeper::ZOK
+          expect(st[:rc]).to eq(Zookeeper::ZOK)
 
-          st[:stat].ephemeral_owner.should_not be_zero
+          expect(st[:stat].ephemeral_owner).not_to be_zero
         end
       end # ephemeral_sequence
     end # async
@@ -829,7 +821,7 @@
         end
 
         it %[should have deleted the node] do
-          zk.stat(:path => path)[:stat].exists.should be_false
+          expect(zk.stat(:path => path)[:stat].exists).to be_falsey
         end
       end
 
@@ -840,13 +832,13 @@
           zk.create(:path => path)
 
           @stat = zk.stat(:path => path)[:stat]
-          @stat.exists.should be_true
+          expect(@stat.exists).to be_truthy
 
           @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
+          expect(zk.stat(:path => path)[:stat].exists).to be_falsey
         end
       end
 
@@ -858,7 +850,7 @@
         end
 
         it %[should have a return code of ZBADVERSION] do
-          @rv[:rc].should == Zookeeper::ZBADVERSION
+          expect(@rv[:rc]).to eq(Zookeeper::ZBADVERSION)
         end
       end
     end # sync
@@ -874,15 +866,15 @@
         before do
           @rv = zk.delete(:path => path, :callback => @cb, :callback_context => path)
           wait_until { @cb.completed? }
-          @cb.should be_completed
+          expect(@cb).to be_completed
         end
 
         it %[should have a success return_code] do
-          @cb.return_code.should == Zookeeper::ZOK
+          expect(@cb.return_code).to eq(Zookeeper::ZOK)
         end
 
         it %[should have deleted the node] do
-          zk.stat(:path => path)[:stat].exists.should be_false
+          expect(zk.stat(:path => path)[:stat].exists).to be_falsey
         end
       end
 
@@ -893,15 +885,15 @@
           @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
+          expect(@cb).to be_completed
         end
 
         it %[should have a success return_code] do
-          @cb.return_code.should == Zookeeper::ZOK
+          expect(@cb.return_code).to eq(Zookeeper::ZOK)
         end
 
         it %[should have deleted the node] do
-          zk.stat(:path => path)[:stat].exists.should be_false
+          expect(zk.stat(:path => path)[:stat].exists).to be_falsey
         end
       end
 
@@ -911,11 +903,11 @@
 
           @rv = zk.delete(:path => path, :version => 0, :callback => @cb, :callback_context => path)
           wait_until { @cb.completed? }
-          @cb.should be_completed
+          expect(@cb).to be_completed
         end
 
         it %[should have a return code of ZBADVERSION] do
-          @cb.return_code.should == Zookeeper::ZBADVERSION
+          expect(@cb.return_code).to eq(Zookeeper::ZBADVERSION)
         end
       end
     end # async
@@ -930,19 +922,19 @@
       end
 
       it %[should return a stat for the path] do
-        @rv[:stat].should be_kind_of(Zookeeper::Stat)
+        expect(@rv[:stat]).to be_kind_of(Zookeeper::Stat)
       end
 
       it %[should return the acls] do
         acls = @rv[:acl]
-        acls.should be_kind_of(Array)
+        expect(acls).to be_kind_of(Array)
         h = acls.first
 
-        h.should be_kind_of(Hash)
+        expect(h).to be_kind_of(Hash)
 
-        h[:perms].should == Zookeeper::ZOO_PERM_ALL
-        h[:id][:scheme].should == 'world'
-        h[:id][:id].should == 'anyone'
+        expect(h[:perms]).to eq(Zookeeper::ZOO_PERM_ALL)
+        expect(h[:id][:scheme]).to eq('world')
+        expect(h[:id][:id]).to eq('anyone')
       end
     end
 
@@ -954,29 +946,29 @@
         @rv = zk.get_acl(:path => path, :callback => @cb, :callback_context => path)
 
         wait_until(2) { @cb.completed? }
-        @cb.should be_completed
+        expect(@cb).to be_completed
       end
 
       it %[should return a stat for the path] do
-        @cb.stat.should be_kind_of(Zookeeper::Stat)
+        expect(@cb.stat).to be_kind_of(Zookeeper::Stat)
       end
 
       it %[should return the acls] do
         acls = @cb.acl
-        acls.should be_kind_of(Array)
+        expect(acls).to be_kind_of(Array)
 
         acl = acls.first
-        acl.should be_kind_of(Zookeeper::ACLs::ACL)
+        expect(acl).to be_kind_of(Zookeeper::ACLs::ACL)
 
-        acl.perms.should == Zookeeper::ZOO_PERM_ALL
+        expect(acl.perms).to eq(Zookeeper::ZOO_PERM_ALL)
 
-        acl.id.scheme.should == 'world'
-        acl.id.id.should == 'anyone'
+        expect(acl.id.scheme).to eq('world')
+        expect(acl.id.id).to eq('anyone')
       end
     end
   end
 
-  describe :set_acl do
+  xdescribe :set_acl do
     before do
       @perms = 5
       @new_acl = [Zookeeper::ACLs::ACL.new(:perms => @perms, :id => Zookeeper::Constants::ZOO_ANYONE_ID_UNSAFE)]
@@ -994,13 +986,13 @@
 
   describe :session_id do
     it %[should return the session_id as a Fixnum] do
-      zk.session_id.should be_kind_of(Integer)
+      expect(zk.session_id).to be_kind_of(Integer)
     end
   end
 
   describe :session_passwd do
     it %[should return the session passwd as a String] do
-      zk.session_passwd.should be_kind_of(String)
+      expect(zk.session_passwd).to be_kind_of(String)
     end
   end
 
@@ -1013,13 +1005,13 @@
         @rv = zk.sync(:path => path, :callback => @cb)
 
         wait_until(2) { @cb.completed }
-        @cb.should be_completed
+        expect(@cb).to be_completed
       end
     end
 
     describe :errors do
       it %[should barf with BadArguments if :callback is not given] do
-        lambda { zk.sync(:path => path) }.should raise_error(Zookeeper::Exceptions::BadArguments)
+        expect { zk.sync(:path => path) }.to raise_error(Zookeeper::Exceptions::BadArguments)
       end
     end
   end
@@ -1034,11 +1026,11 @@
 
       @rv = zk.sync(:path => path, :callback => cb)
 
-      wait_until(2) { @result == true }.should be_true
+      expect(wait_until(2) { @result == true }).to be_truthy
     end
 
     it %[should return false when not on the event dispatching thread] do
-      zk.event_dispatch_thread?.should_not be_true
+      expect(zk.event_dispatch_thread?).not_to be_truthy
     end
   end
 
@@ -1058,7 +1050,7 @@
         end
 
         wait_until { zk.closed? }
-        zk.should be_closed
+        expect(zk).to be_closed
       end
     end
   end
@@ -1068,11 +1060,11 @@
       it %[should raise an InheritedConnectionError if the current Process.pid is different from the one that created the client] do
         pid = Process.pid
         begin
-          Process.stub(:pid => -1)
-          lambda { zk.stat(:path => path) }.should raise_error(Zookeeper::Exceptions::InheritedConnectionError)
+          allow(Process).to receive(:pid).and_return(-1)
+          expect { zk.stat(:path => path) }.to raise_error(Zookeeper::Exceptions::InheritedConnectionError)
         ensure
           # ensure we reset this, only want it to fail during the test
-          Process.stub(:pid => pid)
+          allow(Process).to receive(:pid).and_return(pid)
         end
       end
     end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 5a60e1c..77065ad 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -6,7 +6,7 @@
 
 release_ops_path = File.expand_path('../../releaseops/lib', __FILE__)
 
-if File.exists?(release_ops_path)
+if File.exist?(release_ops_path)
   require File.join(release_ops_path, 'releaseops')
   ReleaseOps::SimpleCov.maybe_start
 end
@@ -34,7 +34,7 @@
   if Zookeeper.spawn_zookeeper?
     require 'zk-server'
 
-    config.before(:suite) do 
+    config.before(:suite) do
       SpecGlobalLogger.logger.debug { "Starting zookeeper service" }
       ZK::Server.run do |c|
         c.base_dir    = File.expand_path('../../.zkserver', __FILE__)
diff --git a/zookeeper.gemspec b/zookeeper.gemspec
index 9b9274c..6c96bbc 100644
--- a/zookeeper.gemspec
+++ b/zookeeper.gemspec
@@ -7,10 +7,10 @@ Gem::Specification.new do |s|
   s.version     = Zookeeper::VERSION
 
   s.authors     = [
-    "Phillip Pearson", 
-    "Eric Maland", 
-    "Evan Weaver", 
-    "Brian Wickman", 
+    "Phillip Pearson",
+    "Eric Maland",
+    "Evan Weaver",
+    "Brian Wickman",
     "Neil Conway",
     "Jonathan D. Simms",
     "Mal McKay",
@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
   s.description = <<-EOS
 A low-level multi-Ruby wrapper around the ZooKeeper API bindings. For a
 friendlier interface, see http://github.com/slyphon/zk. Currently supported:
-MRI: {2.5, 2.6, 2.7, 3.0}, JRuby: ~> 9.2.x.x
+MRI: {2.5, 2.6, 2.7, 3.0, 3.1, 3.2}, JRuby: ~> 9.2.x.x
 
 This library uses version #{Zookeeper::DRIVER_VERSION} of zookeeper bindings.