Merge pull request #666 from tamird/rspec-better-matcher

cleanup: use rspec's type matcher

Author: sodabrew

spec/mysql2/client_spec.rb

@@ -140,12 +140,12 @@ def connect *args
     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
@@ -382,16 +382,16 @@ def run_gc
     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
@@ -454,7 +454,7 @@ def run_gc
       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
 
@@ -545,7 +545,7 @@ def run_gc
         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
 
@@ -727,11 +727,11 @@ def run_gc
 
   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
@@ -758,11 +758,11 @@ def run_gc
 
   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
@@ -851,7 +851,7 @@ def run_gc
   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

spec/mysql2/result_spec.rb

@@ -53,19 +53,19 @@
   context "#each" do
     it "should yield rows as hash's" do
       @result.each do |row|
-        expect(row.class).to eql(Hash)
+        expect(row).to be_an_instance_of(Hash)
       end
     end
 
     it "should yield rows as hash's with symbol keys if :symbolize_keys was set to true" do
       @result.each(:symbolize_keys => true) do |row|
-        expect(row.keys.first.class).to eql(Symbol)
+        expect(row.keys.first).to be_an_instance_of(Symbol)
       end
     end
 
     it "should be able to return results as an array" do
       @result.each(:as => :array) do |row|
-        expect(row.class).to eql(Array)
+        expect(row).to be_an_instance_of(Array)
       end
     end
 
@@ -182,17 +182,17 @@
     end
 
     it "should return nil for a NULL value" do
-      expect(@test_result['null_test'].class).to eql(NilClass)
+      expect(@test_result['null_test']).to be_an_instance_of(NilClass)
       expect(@test_result['null_test']).to eql(nil)
     end
 
     it "should return String for a BIT(64) value" do
-      expect(@test_result['bit_test'].class).to eql(String)
+      expect(@test_result['bit_test']).to be_an_instance_of(String)
       expect(@test_result['bit_test']).to eql("\000\000\000\000\000\000\000\005")
     end
 
     it "should return String for a BIT(1) value" do
-      expect(@test_result['single_bit_test'].class).to eql(String)
+      expect(@test_result['single_bit_test']).to be_an_instance_of(String)
       expect(@test_result['single_bit_test']).to eql("\001")
     end
 
@@ -259,22 +259,22 @@
     end
 
     it "should return BigDecimal for a DECIMAL value" do
-      expect(@test_result['decimal_test'].class).to eql(BigDecimal)
+      expect(@test_result['decimal_test']).to be_an_instance_of(BigDecimal)
       expect(@test_result['decimal_test']).to eql(10.3)
     end
 
     it "should return Float for a FLOAT value" do
-      expect(@test_result['float_test'].class).to eql(Float)
+      expect(@test_result['float_test']).to be_an_instance_of(Float)
       expect(@test_result['float_test']).to eql(10.3)
     end
 
     it "should return Float for a DOUBLE value" do
-      expect(@test_result['double_test'].class).to eql(Float)
+      expect(@test_result['double_test']).to be_an_instance_of(Float)
       expect(@test_result['double_test']).to eql(10.3)
     end
 
     it "should return Time for a DATETIME value when within the supported range" do
-      expect(@test_result['date_time_test'].class).to eql(Time)
+      expect(@test_result['date_time_test']).to be_an_instance_of(Time)
       expect(@test_result['date_time_test'].strftime("%Y-%m-%d %H:%M:%S")).to eql('2010-04-04 11:44:00')
     end
 
@@ -288,60 +288,60 @@
       it "should return DateTime when timestamp is < 1901-12-13 20:45:52" do
                                       # 1901-12-13T20:45:52 is the min for 32bit Ruby 1.8
         r = @client.query("SELECT CAST('1901-12-13 20:45:51' AS DATETIME) as test")
-        expect(r.first['test'].class).to eql(klass)
+        expect(r.first['test']).to be_an_instance_of(klass)
       end
 
       it "should return DateTime when timestamp is > 2038-01-19T03:14:07" do
                                       # 2038-01-19T03:14:07 is the max for 32bit Ruby 1.8
         r = @client.query("SELECT CAST('2038-01-19 03:14:08' AS DATETIME) as test")
-        expect(r.first['test'].class).to eql(klass)
+        expect(r.first['test']).to be_an_instance_of(klass)
       end
     elsif 1.size == 8 # 64bit
       unless RUBY_VERSION =~ /1.8/
         it "should return Time when timestamp is < 1901-12-13 20:45:52" do
           r = @client.query("SELECT CAST('1901-12-13 20:45:51' AS DATETIME) as test")
-          expect(r.first['test'].class).to eql(Time)
+          expect(r.first['test']).to be_an_instance_of(Time)
         end
 
         it "should return Time when timestamp is > 2038-01-19T03:14:07" do
           r = @client.query("SELECT CAST('2038-01-19 03:14:08' AS DATETIME) as test")
-          expect(r.first['test'].class).to eql(Time)
+          expect(r.first['test']).to be_an_instance_of(Time)
         end
       else
         it "should return Time when timestamp is > 0138-12-31 11:59:59" do
           r = @client.query("SELECT CAST('0139-1-1 00:00:00' AS DATETIME) as test")
-          expect(r.first['test'].class).to eql(Time)
+          expect(r.first['test']).to be_an_instance_of(Time)
         end
 
         it "should return DateTime when timestamp is < 0139-1-1T00:00:00" do
           r = @client.query("SELECT CAST('0138-12-31 11:59:59' AS DATETIME) as test")
-          expect(r.first['test'].class).to eql(DateTime)
+          expect(r.first['test']).to be_an_instance_of(DateTime)
         end
 
         it "should return Time when timestamp is > 2038-01-19T03:14:07" do
           r = @client.query("SELECT CAST('2038-01-19 03:14:08' AS DATETIME) as test")
-          expect(r.first['test'].class).to eql(Time)
+          expect(r.first['test']).to be_an_instance_of(Time)
         end
       end
     end
 
     it "should return Time for a TIMESTAMP value when within the supported range" do
-      expect(@test_result['timestamp_test'].class).to eql(Time)
+      expect(@test_result['timestamp_test']).to be_an_instance_of(Time)
       expect(@test_result['timestamp_test'].strftime("%Y-%m-%d %H:%M:%S")).to eql('2010-04-04 11:44:00')
     end
 
     it "should return Time for a TIME value" do
-      expect(@test_result['time_test'].class).to eql(Time)
+      expect(@test_result['time_test']).to be_an_instance_of(Time)
       expect(@test_result['time_test'].strftime("%Y-%m-%d %H:%M:%S")).to eql('2000-01-01 11:44:00')
     end
 
     it "should return Date for a DATE value" do
-      expect(@test_result['date_test'].class).to eql(Date)
+      expect(@test_result['date_test']).to be_an_instance_of(Date)
       expect(@test_result['date_test'].strftime("%Y-%m-%d")).to eql('2010-04-04')
     end
 
     it "should return String for an ENUM value" do
-      expect(@test_result['enum_test'].class).to eql(String)
+      expect(@test_result['enum_test']).to be_an_instance_of(String)
       expect(@test_result['enum_test']).to eql('val1')
     end
 
@@ -379,7 +379,7 @@
     end
 
     it "should return String for a SET value" do
-      expect(@test_result['set_test'].class).to eql(String)
+      expect(@test_result['set_test']).to be_an_instance_of(String)
       expect(@test_result['set_test']).to eql('val1,val2')
     end
 
@@ -412,7 +412,7 @@
     end
 
     it "should return String for a BINARY value" do
-      expect(@test_result['binary_test'].class).to eql(String)
+      expect(@test_result['binary_test']).to be_an_instance_of(String)
       expect(@test_result['binary_test']).to eql("test#{"\000"*6}")
     end
 
@@ -453,7 +453,7 @@
       'long_text_test' => 'LONGTEXT'
     }.each do |field, type|
       it "should return a String for #{type}" do
-        expect(@test_result[field].class).to eql(String)
+        expect(@test_result[field]).to be_an_instance_of(String)
         expect(@test_result[field]).to eql("test")
       end