mysql2 0.3.18 → 0.4.9

data/spec/mysql2/error_spec.rb

@@ -2,81 +2,80 @@
 
 require 'spec_helper'
 
-describe Mysql2::Error do
-  let(:client) { Mysql2::Client.new(DatabaseCredentials['root']) }
-
-  let :error do
+RSpec.describe Mysql2::Error do
+  let(:error) do
     begin
-      client.query("HAHAHA")
+      @client.query("HAHAHA")
     rescue Mysql2::Error => e
       error = e
-    ensure
-      client.close
     end
 
     error
   end
 
   it "responds to error_number and sql_state, with aliases" do
-    error.should respond_to(:error_number)
-    error.should respond_to(:sql_state)
+    expect(error).to respond_to(:error_number)
+    expect(error).to respond_to(:sql_state)
 
     # Mysql gem compatibility
-    error.should respond_to(:errno)
-    error.should respond_to(:error)
+    expect(error).to respond_to(:errno)
+    expect(error).to respond_to(:error)
   end
 
-  if "".respond_to? :encoding
-    let :error do
-      client = Mysql2::Client.new(DatabaseCredentials['root'])
+  context 'encoding' do
+    let(:valid_utf8) { '造字' }
+    let(:error) do
       begin
-        client.query("\xE9\x80\xA0\xE5\xAD\x97")
+        @client.query(valid_utf8)
       rescue Mysql2::Error => e
-        error = e
-      ensure
-        client.close
+        e
       end
-
-      error
     end
 
-    let :bad_err do
-      client = Mysql2::Client.new(DatabaseCredentials['root'])
+    let(:invalid_utf8) { ["e5c67d1f"].pack('H*').force_encoding(Encoding::UTF_8) }
+    let(:bad_err) do
       begin
-        client.query("\xE5\xC6\x7D\x1F")
+        @client.query(invalid_utf8)
       rescue Mysql2::Error => e
-        error = e
-      ensure
-        client.close
+        e
       end
+    end
+
+    before do
+      pending('String#encoding is not defined') unless String.public_method_defined?(:encoding)
+
+      # sanity check
+      expect(valid_utf8.encoding).to eql(Encoding::UTF_8)
+      expect(valid_utf8).to be_valid_encoding
 
-      error
+      expect(invalid_utf8.encoding).to eql(Encoding::UTF_8)
+      expect(invalid_utf8).to_not be_valid_encoding
     end
 
     it "returns error messages as UTF-8 by default" do
       with_internal_encoding nil do
-        error.message.encoding.should eql(Encoding::UTF_8)
-        error.message.valid_encoding?
+        expect(error.message.encoding).to eql(Encoding::UTF_8)
+        expect(error.message).to be_valid_encoding
 
-        bad_err.message.encoding.should eql(Encoding::UTF_8)
-        bad_err.message.valid_encoding?
+        expect(bad_err.message.encoding).to eql(Encoding::UTF_8)
+        expect(bad_err.message).to be_valid_encoding
 
-        bad_err.message.should include("??}\u001F")
+        expect(bad_err.message).to include("??}\u001F")
       end
     end
 
     it "returns sql state as ASCII" do
-      error.sql_state.encoding.should eql(Encoding::US_ASCII)
-      error.sql_state.valid_encoding?
+      expect(error.sql_state.encoding).to eql(Encoding::US_ASCII)
+      expect(error.sql_state).to be_valid_encoding
     end
 
     it "returns error messages and sql state in Encoding.default_internal if set" do
-      with_internal_encoding 'UTF-16LE' do
-        error.message.encoding.should eql(Encoding.default_internal)
-        error.message.valid_encoding?
+      with_internal_encoding Encoding::UTF_16LE do
+        expect(error.message.encoding).to eql(Encoding.default_internal)
+        expect(error.message).to be_valid_encoding
 
-        bad_err.message.encoding.should eql(Encoding.default_internal)
-        bad_err.message.valid_encoding?
+        expect(bad_err.message.encoding).to eql(Encoding.default_internal)
+        expect(bad_err.message).to be_valid_encoding
       end
     end
   end