mysql2 0.4.0 → 0.4.1

data/lib/mysql2.rb

@@ -8,16 +8,16 @@ require 'rational' unless RUBY_VERSION >= '1.9.2'
 # Or to bomb out with a clear error message instead of a linker crash
 if RUBY_PLATFORM =~ /mswin|mingw/
   dll_path = if ENV['RUBY_MYSQL2_LIBMYSQL_DLL']
-               # If this environment variable is set, it overrides any other paths
-               # The user is advised to use backslashes not forward slashes
-               ENV['RUBY_MYSQL2_LIBMYSQL_DLL'].dup
-             elsif File.exist?(File.expand_path('../vendor/libmysql.dll', File.dirname(__FILE__)))
-               # Use vendor/libmysql.dll if it exists, convert slashes for Win32 LoadLibrary
-               File.expand_path('../vendor/libmysql.dll', File.dirname(__FILE__)).gsub('/', '\\')
-             else
-               # This will use default / system library paths
-               'libmysql.dll'
-             end
+    # If this environment variable is set, it overrides any other paths
+    # The user is advised to use backslashes not forward slashes
+    ENV['RUBY_MYSQL2_LIBMYSQL_DLL']
+  elsif File.exist?(File.expand_path('../vendor/libmysql.dll', File.dirname(__FILE__)))
+    # Use vendor/libmysql.dll if it exists, convert slashes for Win32 LoadLibrary
+    File.expand_path('../vendor/libmysql.dll', File.dirname(__FILE__)).tr('/', '\\')
+  else
+    # This will use default / system library paths
+    'libmysql.dll'
+  end
 
   require 'Win32API'
   LoadLibrary = Win32API.new('Kernel32', 'LoadLibrary', ['P'], 'I')
@@ -53,14 +53,32 @@ if defined?(ActiveRecord::VERSION::STRING) && ActiveRecord::VERSION::STRING < "3
 end
 
 # For holding utility methods
-module Mysql2::Util
+module Mysql2
+  module Util
+    #
+    # Rekey a string-keyed hash with equivalent symbols.
+    #
+    def self.key_hash_as_symbols(hash)
+      return nil unless hash
+      Hash[hash.map { |k, v| [k.to_sym, v] }]
+    end
 
-  #
-  # Rekey a string-keyed hash with equivalent symbols.
-  #
-  def self.key_hash_as_symbols(hash)
-    return nil unless hash
-    Hash[hash.map { |k,v| [k.to_sym, v] }]
+    #
+    # In Mysql2::Client#query and Mysql2::Statement#execute,
+    # Thread#handle_interrupt is used to prevent Timeout#timeout
+    # from interrupting query execution.
+    #
+    # Timeout::ExitException was removed in Ruby 2.3.0, 2.2.3, and 2.1.8,
+    # but is present in earlier 2.1.x and 2.2.x, so we provide a shim.
+    #
+    if Thread.respond_to?(:handle_interrupt)
+      require 'timeout'
+      # rubocop:disable Style/ConstantName
+      TimeoutError = if defined?(::Timeout::ExitException)
+        ::Timeout::ExitException
+      else
+        ::Timeout::Error
+      end
+    end
   end
-
 end

data/lib/mysql2/client.rb

@@ -1,24 +1,27 @@
 module Mysql2
   class Client
     attr_reader :query_options, :read_timeout
-    @@default_query_options = {
-      :as => :hash,                   # the type of object you want each row back as; also supports :array (an array of values)
-      :async => false,                # don't wait for a result after sending the query, you'll have to monitor the socket yourself then eventually call Mysql2::Client#async_result
-      :cast_booleans => false,        # cast tinyint(1) fields as true/false in ruby
-      :symbolize_keys => false,       # return field names as symbols instead of strings
-      :database_timezone => :local,   # timezone Mysql2 will assume datetime objects are stored in
-      :application_timezone => nil,   # timezone Mysql2 will convert to before handing the object back to the caller
-      :cache_rows => true,            # tells Mysql2 to use it's internal row cache for results
-      :connect_flags => REMEMBER_OPTIONS | LONG_PASSWORD | LONG_FLAG | TRANSACTIONS | PROTOCOL_41 | SECURE_CONNECTION,
-      :cast => true,
-      :default_file => nil,
-      :default_group => nil
-    }
+
+    def self.default_query_options
+      @default_query_options ||= {
+        :as => :hash,                   # the type of object you want each row back as; also supports :array (an array of values)
+        :async => false,                # don't wait for a result after sending the query, you'll have to monitor the socket yourself then eventually call Mysql2::Client#async_result
+        :cast_booleans => false,        # cast tinyint(1) fields as true/false in ruby
+        :symbolize_keys => false,       # return field names as symbols instead of strings
+        :database_timezone => :local,   # timezone Mysql2 will assume datetime objects are stored in
+        :application_timezone => nil,   # timezone Mysql2 will convert to before handing the object back to the caller
+        :cache_rows => true,            # tells Mysql2 to use it's internal row cache for results
+        :connect_flags => REMEMBER_OPTIONS | LONG_PASSWORD | LONG_FLAG | TRANSACTIONS | PROTOCOL_41 | SECURE_CONNECTION,
+        :cast => true,
+        :default_file => nil,
+        :default_group => nil,
+      }
+    end
 
     def initialize(opts = {})
-      opts = Mysql2::Util.key_hash_as_symbols( opts )
+      opts = Mysql2::Util.key_hash_as_symbols(opts)
       @read_timeout = nil
-      @query_options = @@default_query_options.dup
+      @query_options = self.class.default_query_options.dup
       @query_options.merge! opts
 
       initialize_ext
@@ -26,11 +29,12 @@ module Mysql2
       # Set default connect_timeout to avoid unlimited retries from signal interruption
       opts[:connect_timeout] = 120 unless opts.key?(:connect_timeout)
 
+      # TODO: stricter validation rather than silent massaging
       [:reconnect, :connect_timeout, :local_infile, :read_timeout, :write_timeout, :default_file, :default_group, :secure_auth, :init_command].each do |key|
         next unless opts.key?(key)
         case key
         when :reconnect, :local_infile, :secure_auth
-          send(:"#{key}=", !!opts[key])
+          send(:"#{key}=", !!opts[key]) # rubocop:disable Style/DoubleNegation
         when :connect_timeout, :read_timeout, :write_timeout
           send(:"#{key}=", opts[key].to_i)
         else
@@ -48,9 +52,9 @@ module Mysql2
       flags = 0
       flags |= @query_options[:connect_flags]
       flags |= opts[:flags] if opts[:flags]
-      flags |= SSL_VERIFY_SERVER_CERT if opts[:sslverify] and ssl_options.any?
+      flags |= SSL_VERIFY_SERVER_CERT if opts[:sslverify] && ssl_options.any?
 
-      if [:user,:pass,:hostname,:dbname,:db,:sock].any?{|k| @query_options.has_key?(k) }
+      if [:user, :pass, :hostname, :dbname, :db, :sock].any? { |k| @query_options.key?(k) }
         warn "============= WARNING FROM mysql2 ============="
         warn "The options :user, :pass, :hostname, :dbname, :db, and :sock will be deprecated at some point in the future."
         warn "Instead, please use :username, :password, :host, :port, :database, :socket, :flags for the options."
@@ -75,15 +79,9 @@ module Mysql2
       connect user, pass, host, port, database, socket, flags
     end
 
-    def self.default_query_options
-      @@default_query_options
-    end
-
     if Thread.respond_to?(:handle_interrupt)
-      require 'timeout'
-
       def query(sql, options = {})
-        Thread.handle_interrupt(::Timeout::ExitException => :never) do
+        Thread.handle_interrupt(::Mysql2::Util::TimeoutError => :never) do
           _query(sql, @query_options.merge(options))
         end
       end
@@ -105,9 +103,12 @@ module Mysql2
       self.class.info
     end
 
-    private
-      def self.local_offset
+    class << self
+      private
+
+      def local_offset
         ::Time.local(2010).utc_offset.to_r / 86400
       end
+    end
   end
 end

data/lib/mysql2/console.rb

@@ -1,5 +1,5 @@
 # Loaded by script/console. Land helpers here.
 
-Pry.config.prompt = lambda do |context, nesting, pry|
+Pry.config.prompt = lambda do |context, *|
   "[mysql2] #{context}> "
 end

data/lib/mysql2/em.rb

@@ -17,7 +17,7 @@ module Mysql2
           detach
           begin
             result = @client.async_result
-          rescue Exception => e
+          rescue => e
             @deferable.fail(e)
           else
             @deferable.succeed(result)
@@ -34,17 +34,16 @@ module Mysql2
       end
 
       def close(*args)
-        if @watch
-          @watch.detach if @watch.watching?
-        end
+        @watch.detach if @watch && @watch.watching?
+
         super(*args)
       end
 
-      def query(sql, opts={})
+      def query(sql, opts = {})
         if ::EM.reactor_running?
           super(sql, opts.merge(:async => true))
           deferable = ::EM::DefaultDeferrable.new
-          @watch = ::EM.watch(self.socket, Watcher, self, deferable)
+          @watch = ::EM.watch(socket, Watcher, self, deferable)
           @watch.notify_readable = true
           deferable
         else

data/lib/mysql2/error.rb

@@ -8,22 +8,25 @@ module Mysql2
       :replace => '?'.freeze,
     }.freeze
 
-    attr_accessor :error_number
-    attr_reader   :sql_state
-    attr_writer   :server_version
+    attr_reader :error_number, :sql_state
 
     # Mysql gem compatibility
     alias_method :errno, :error_number
     alias_method :error, :message
 
-    def initialize(msg, server_version=nil)
-      self.server_version = server_version
+    def initialize(msg)
+      @server_version ||= nil
 
       super(clean_message(msg))
     end
 
-    def sql_state=(state)
-      @sql_state = state.respond_to?(:encode) ? state.encode(ENCODE_OPTS) : state
+    def self.new_with_args(msg, server_version, error_number, sql_state)
+      err = allocate
+      err.instance_variable_set('@server_version', server_version)
+      err.instance_variable_set('@error_number', error_number)
+      err.instance_variable_set('@sql_state', sql_state.respond_to?(:encode) ? sql_state.encode(ENCODE_OPTS) : sql_state)
+      err.send(:initialize, msg)
+      err
     end
 
     private

data/lib/mysql2/field.rb

@@ -1,4 +1,3 @@
 module Mysql2
-  class Field < Struct.new(:name, :type)
-  end
+  Field = Struct.new(:name, :type)
 end

data/lib/mysql2/statement.rb

@@ -1,5 +1,17 @@
 module Mysql2
   class Statement
     include Enumerable
+
+    if Thread.respond_to?(:handle_interrupt)
+      def execute(*args)
+        Thread.handle_interrupt(::Mysql2::Util::TimeoutError => :never) do
+          _execute(*args)
+        end
+      end
+    else
+      def execute(*args)
+        _execute(*args)
+      end
+    end
   end
 end

data/lib/mysql2/version.rb

@@ -1,3 +1,3 @@
 module Mysql2
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/spec/em/em_spec.rb

@@ -53,11 +53,11 @@ begin
         EM.run do
           client = Mysql2::EM::Client.new DatabaseCredentials['root']
           defer = client.query "SELECT sleep(0.1) as first_query"
-          defer.callback do |result|
+          defer.callback do
             client.close
-            raise 'some error'
+            fail 'some error'
           end
-          defer.errback do |err|
+          defer.errback do
             # This _shouldn't_ be run, but it needed to prevent the specs from
             # freezing if this test fails.
             EM.stop_event_loop
@@ -75,7 +75,7 @@ begin
         errors = []
         EM.run do
           defer = client.query "SELECT sleep(0.1) as first_query"
-          defer.callback do |result|
+          defer.callback do
             # This _shouldn't_ be run, but it is needed to prevent the specs from
             # freezing if this test fails.
             EM.stop_event_loop
@@ -93,13 +93,13 @@ begin
         EM.run do
           defer = client.query "SELECT sleep(0.025) as first_query"
           EM.add_timer(0.1) do
-            defer.callback do |result|
+            defer.callback do
               callbacks_run << :callback
               # This _shouldn't_ be run, but it is needed to prevent the specs from
               # freezing if this test fails.
               EM.stop_event_loop
             end
-            defer.errback do |err|
+            defer.errback do
               callbacks_run << :errback
               EM.stop_event_loop
             end
@@ -114,10 +114,10 @@ begin
       EM.run do
         client = Mysql2::EM::Client.new DatabaseCredentials['root']
         defer = client.query("select sleep(0.025)")
-        defer.callback do |result|
+        defer.callback do
           callbacks_run << :callback
         end
-        defer.errback do |err|
+        defer.errback do
           callbacks_run << :errback
         end
         EM.add_timer(0.1) do

data/spec/mysql2/client_spec.rb

@@ -46,7 +46,7 @@ RSpec.describe Mysql2::Client do
   it "should accept connect flags and pass them to #connect" do
     klient = Class.new(Mysql2::Client) do
       attr_reader :connect_args
-      def connect *args
+      def connect(*args)
         @connect_args ||= []
         @connect_args << args
       end
@@ -58,7 +58,7 @@ RSpec.describe Mysql2::Client do
   it "should default flags to (REMEMBER_OPTIONS, LONG_PASSWORD, LONG_FLAG, TRANSACTIONS, PROTOCOL_41, SECURE_CONNECTION)" do
     klient = Class.new(Mysql2::Client) do
       attr_reader :connect_args
-      def connect *args
+      def connect(*args)
         @connect_args ||= []
         @connect_args << args
       end
@@ -117,32 +117,37 @@ RSpec.describe Mysql2::Client do
 
   it "should be able to connect via SSL options" do
     ssl = @client.query "SHOW VARIABLES LIKE 'have_ssl'"
-    ssl_uncompiled = ssl.any? {|x| x['Value'] == 'OFF'}
+    ssl_uncompiled = ssl.any? { |x| x['Value'] == 'OFF' }
     pending("DON'T WORRY, THIS TEST PASSES - but SSL is not compiled into your MySQL daemon.") if ssl_uncompiled
-    ssl_disabled = ssl.any? {|x| x['Value'] == 'DISABLED'}
+    ssl_disabled = ssl.any? { |x| x['Value'] == 'DISABLED' }
     pending("DON'T WORRY, THIS TEST PASSES - but SSL is not enabled in your MySQL daemon.") if ssl_disabled
 
     # You may need to adjust the lines below to match your SSL certificate paths
     ssl_client = nil
     expect {
+      # rubocop:disable Style/TrailingComma
       ssl_client = Mysql2::Client.new(
-        :sslkey    => '/etc/mysql/client-key.pem',
-        :sslcert   => '/etc/mysql/client-cert.pem',
-        :sslca     => '/etc/mysql/ca-cert.pem',
-        :sslcapath => '/etc/mysql/',
-        :sslcipher => 'DHE-RSA-AES256-SHA'
+        DatabaseCredentials['root'].merge(
+          'host'     => 'mysql2gem.example.com', # must match the certificates
+          :sslkey    => '/etc/mysql/client-key.pem',
+          :sslcert   => '/etc/mysql/client-cert.pem',
+          :sslca     => '/etc/mysql/ca-cert.pem',
+          :sslcipher => 'DHE-RSA-AES256-SHA',
+          :sslverify => true
+        )
       )
+      # rubocop:enable Style/TrailingComma
     }.not_to raise_error
 
     results = ssl_client.query("SHOW STATUS WHERE Variable_name = \"Ssl_version\" OR Variable_name = \"Ssl_cipher\"").to_a
     expect(results[0]['Variable_name']).to eql('Ssl_cipher')
     expect(results[0]['Value']).not_to be_nil
-    expect(results[0]['Value']).to be_kind_of(String)
+    expect(results[0]['Value']).to be_an_instance_of(String)
     expect(results[0]['Value']).not_to be_empty
 
     expect(results[1]['Variable_name']).to eql('Ssl_version')
     expect(results[1]['Value']).not_to be_nil
-    expect(results[1]['Value']).to be_kind_of(String)
+    expect(results[1]['Value']).to be_an_instance_of(String)
     expect(results[1]['Value']).not_to be_empty
 
     ssl_client.close
@@ -157,6 +162,14 @@ RSpec.describe Mysql2::Client do
     sleep(0.5)
   end
 
+  it "should terminate connections when calling close" do
+    expect {
+      Mysql2::Client.new(DatabaseCredentials['root']).close
+    }.to_not change {
+      @client.query("SHOW STATUS LIKE 'Aborted_clients'").first['Value'].to_i
+    }
+  end
+
   it "should not leave dangling connections after garbage collection" do
     run_gc
 
@@ -182,7 +195,7 @@ RSpec.describe Mysql2::Client do
 
     # this empty `fork` call fixes this tests on RBX; without it, the next
     # `fork` call hangs forever. WTF?
-    fork { }
+    fork {}
 
     fork do
       client.query('SELECT 1')
@@ -264,7 +277,7 @@ RSpec.describe Mysql2::Client do
         # # Note that mysql_info() returns a non-NULL value for INSERT ... VALUES only for the multiple-row form of the statement (that is, only if multiple value lists are specified).
         @client.query("INSERT INTO infoTest (blah) VALUES (1234),(4535)")
 
-        expect(@client.query_info).to  eql({:records => 2, :duplicates => 0, :warnings => 0})
+        expect(@client.query_info).to eql(:records => 2, :duplicates => 0, :warnings => 0)
         expect(@client.query_info_string).to eq('Records: 2  Duplicates: 0  Warnings: 0')
 
         @client.query "DROP TABLE infoTest"
@@ -276,7 +289,7 @@ RSpec.describe Mysql2::Client do
     before(:all) do
       @client_i = Mysql2::Client.new DatabaseCredentials['root'].merge(:local_infile => true)
       local = @client_i.query "SHOW VARIABLES LIKE 'local_infile'"
-      local_enabled = local.any? {|x| x['Value'] == 'ON'}
+      local_enabled = local.any? { |x| x['Value'] == 'ON' }
       pending("DON'T WORRY, THIS TEST PASSES - but LOCAL INFILE is not enabled in your MySQL daemon.") unless local_enabled
 
       @client_i.query %[
@@ -308,10 +321,10 @@ RSpec.describe Mysql2::Client do
     it "should LOAD DATA LOCAL INFILE" do
       @client_i.query "LOAD DATA LOCAL INFILE 'spec/test_data' INTO TABLE infileTest"
       info = @client_i.query_info
-      expect(info).to eql({:records => 1, :deleted => 0, :skipped => 0, :warnings => 0})
+      expect(info).to eql(:records => 1, :deleted => 0, :skipped => 0, :warnings => 0)
 
       result = @client_i.query "SELECT * FROM infileTest"
-      expect(result.first).to eql({'id' => 1, 'foo' => 'Hello', 'bar' => 'World'})
+      expect(result.first).to eql('id' => 1, 'foo' => 'Hello', 'bar' => 'World')
     end
   end
 
@@ -379,16 +392,16 @@ RSpec.describe Mysql2::Client do
     end
 
     it "should return results as a hash by default" do
-      expect(@client.query("SELECT 1").first.class).to eql(Hash)
+      expect(@client.query("SELECT 1").first).to be_an_instance_of(Hash)
     end
 
     it "should be able to return results as an array" do
-      expect(@client.query("SELECT 1", :as => :array).first.class).to eql(Array)
+      expect(@client.query("SELECT 1", :as => :array).first).to be_an_instance_of(Array)
       @client.query("SELECT 1").each(:as => :array)
     end
 
     it "should be able to return results with symbolized keys" do
-      expect(@client.query("SELECT 1", :symbolize_keys => true).first.keys[0].class).to eql(Symbol)
+      expect(@client.query("SELECT 1", :symbolize_keys => true).first.keys[0]).to be_an_instance_of(Symbol)
     end
 
     it "should require an open connection" do
@@ -451,7 +464,7 @@ RSpec.describe Mysql2::Client do
       end
 
       it "#socket should return a Fixnum (file descriptor from C)" do
-        expect(@client.socket.class).to eql(Fixnum)
+        expect(@client.socket).to be_an_instance_of(Fixnum)
         expect(@client.socket).not_to eql(0)
       end
 
@@ -462,7 +475,7 @@ RSpec.describe Mysql2::Client do
         }.to raise_error(Mysql2::Error)
       end
 
-      it 'should be impervious to connection-corrupting timeouts ' do
+      it 'should be impervious to connection-corrupting timeouts in #query' do
         pending('`Thread.handle_interrupt` is not defined') unless Thread.respond_to?(:handle_interrupt)
         # attempt to break the connection
         expect { Timeout.timeout(0.1) { @client.query('SELECT SLEEP(0.2)') } }.to raise_error(Timeout::Error)
@@ -471,6 +484,20 @@ RSpec.describe Mysql2::Client do
         expect { @client.query('SELECT 1') }.to_not raise_error
       end
 
+      it 'should be impervious to connection-corrupting timeouts in #execute' do
+        # the statement handle gets corrupted and will segfault the tests if interrupted,
+        # so we can't even use pending on this test, really have to skip it on older Rubies.
+        skip('`Thread.handle_interrupt` is not defined') unless Thread.respond_to?(:handle_interrupt)
+
+        # attempt to break the connection
+        stmt = @client.prepare('SELECT SLEEP(?)')
+        expect { Timeout.timeout(0.1) { stmt.execute(0.2) } }.to raise_error(Timeout::Error)
+        stmt.close
+
+        # expect the connection to not be broken
+        expect { @client.query('SELECT 1') }.to_not raise_error
+      end
+
       context 'when a non-standard exception class is raised' do
         it "should close the connection when an exception is raised" do
           expect { Timeout.timeout(0.1, ArgumentError) { @client.query('SELECT SLEEP(1)') } }.to raise_error(ArgumentError)
@@ -542,7 +569,7 @@ RSpec.describe Mysql2::Client do
         expect(loops >= 1).to be true
 
         result = @client.async_result
-        expect(result.class).to eql(Mysql2::Result)
+        expect(result).to be_an_instance_of(Mysql2::Result)
       end
     end
 
@@ -561,21 +588,19 @@ RSpec.describe Mysql2::Client do
       end
 
       it "returns multiple result sets" do
-        expect(@multi_client.query("SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'").first).to eql({ 'set_1' => 1 })
+        expect(@multi_client.query("SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'").first).to eql('set_1' => 1)
 
         expect(@multi_client.next_result).to be true
-        expect(@multi_client.store_result.first).to eql({ 'set_2' => 2 })
+        expect(@multi_client.store_result.first).to eql('set_2' => 2)
 
         expect(@multi_client.next_result).to be false
       end
 
       it "does not interfere with other statements" do
         @multi_client.query("SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'")
-        while( @multi_client.next_result )
-          @multi_client.store_result
-        end
+        @multi_client.store_result while @multi_client.next_result
 
-        expect(@multi_client.query("SELECT 3 AS 'next'").first).to eq({ 'next' => 3 })
+        expect(@multi_client.query("SELECT 3 AS 'next'").first).to eq('next' => 3)
       end
 
       it "will raise on query if there are outstanding results to read" do
@@ -606,11 +631,11 @@ RSpec.describe Mysql2::Client do
       it "#more_results? should work with stored procedures" do
         @multi_client.query("DROP PROCEDURE IF EXISTS test_proc")
         @multi_client.query("CREATE PROCEDURE test_proc() BEGIN SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'; END")
-        expect(@multi_client.query("CALL test_proc()").first).to eql({ 'set_1' => 1 })
+        expect(@multi_client.query("CALL test_proc()").first).to eql('set_1' => 1)
         expect(@multi_client.more_results?).to be true
 
         @multi_client.next_result
-        expect(@multi_client.store_result.first).to eql({ 'set_2' => 2 })
+        expect(@multi_client.store_result.first).to eql('set_2' => 2)
 
         @multi_client.next_result
         expect(@multi_client.store_result).to be_nil # this is the result from CALL itself
@@ -724,11 +749,11 @@ RSpec.describe Mysql2::Client do
 
   it "#info should return a hash containing the client version ID and String" do
     info = @client.info
-    expect(info.class).to eql(Hash)
+    expect(info).to be_an_instance_of(Hash)
     expect(info).to have_key(:id)
-    expect(info[:id].class).to eql(Fixnum)
+    expect(info[:id]).to be_an_instance_of(Fixnum)
     expect(info).to have_key(:version)
-    expect(info[:version].class).to eql(String)
+    expect(info[:version]).to be_an_instance_of(String)
   end
 
   context "strings returned by #info" do
@@ -755,11 +780,11 @@ RSpec.describe Mysql2::Client do
 
   it "#server_info should return a hash containing the client version ID and String" do
     server_info = @client.server_info
-    expect(server_info.class).to eql(Hash)
+    expect(server_info).to be_an_instance_of(Hash)
     expect(server_info).to have_key(:id)
-    expect(server_info[:id].class).to eql(Fixnum)
+    expect(server_info[:id]).to be_an_instance_of(Fixnum)
     expect(server_info).to have_key(:version)
-    expect(server_info[:version].class).to eql(String)
+    expect(server_info[:version]).to be_an_instance_of(String)
   end
 
   it "#server_info should require an open connection" do
@@ -848,7 +873,7 @@ RSpec.describe Mysql2::Client do
   end
 
   it "#thread_id should be a Fixnum" do
-    expect(@client.thread_id.class).to eql(Fixnum)
+    expect(@client.thread_id).to be_an_instance_of(Fixnum)
   end
 
   it "should respond to #ping" do