[DRE-commits] [ruby-mysql2] 03/05: Drop upstream applied patches

zeha at debian.org zeha at debian.org
Wed Jan 6 01:16:17 UTC 2016


This is an automated email from the git hooks/post-receive script.

zeha pushed a commit to branch master
in repository ruby-mysql2.

commit 57024725cb68946cb1fecbc6d9771a2abaab50ed
Author: Christian Hofstaedtler <zeha at debian.org>
Date:   Wed Jan 6 01:01:56 2016 +0000

    Drop upstream applied patches
---
 debian/patches/cleanup_fork.patch   |   31 -
 debian/patches/port_to_rspec3.patch | 1605 -----------------------------------
 debian/patches/series               |    3 -
 3 files changed, 1639 deletions(-)

diff --git a/debian/patches/cleanup_fork.patch b/debian/patches/cleanup_fork.patch
deleted file mode 100644
index 87261ad..0000000
--- a/debian/patches/cleanup_fork.patch
+++ /dev/null
@@ -1,31 +0,0 @@
-Description: Cleanup rspec child process on test failure
-Author: Christian Hofstaedtler <zeha at debian.org>
-Origin: vendor
-Forwarded: yes
-Bug: https://github.com/brianmario/mysql2/issues/611
-
---- a/spec/mysql2/client_spec.rb
-+++ b/spec/mysql2/client_spec.rb
-@@ -426,6 +426,7 @@ describe Mysql2::Client do
-         it "should run signal handlers while waiting for a response" do
-           mark = {}
-           trap(:USR1) { mark[:USR1] = Time.now }
-+          pid = nil
-           begin
-             mark[:START] = Time.now
-             pid = fork do
-@@ -441,10 +442,12 @@ describe Mysql2::Client do
-             (mark[:END] - mark[:USR1]).should > 0.9
-             (mark[:END] - mark[:START]).should >= 2
-             (mark[:END] - mark[:START]).should < 2.3
--            Process.kill(:TERM, pid)
--            Process.waitpid2(pid)
-           ensure
-             trap(:USR1, 'DEFAULT')
-+            if !pid.nil?
-+              Process.kill(:TERM, pid)
-+              Process.waitpid2(pid)
-+            end
-           end
-         end
-       end
diff --git a/debian/patches/port_to_rspec3.patch b/debian/patches/port_to_rspec3.patch
deleted file mode 100644
index 7260938..0000000
--- a/debian/patches/port_to_rspec3.patch
+++ /dev/null
@@ -1,1605 +0,0 @@
---- a/spec/em/em_spec.rb
-+++ b/spec/em/em_spec.rb
-@@ -24,8 +24,8 @@ begin
-         end
-       end
- 
--      results[0].keys.should include("second_query")
--      results[1].keys.should include("first_query")
-+      expect(results[0].keys).to include("second_query")
-+      expect(results[1].keys).to include("first_query")
-     end
- 
-     it "should support queries in callbacks" do
-@@ -44,12 +44,12 @@ begin
-         end
-       end
- 
--      results[0].keys.should include("first_query")
--      results[1].keys.should include("second_query")
-+      expect(results[0].keys).to include("first_query")
-+      expect(results[1].keys).to include("second_query")
-     end
- 
-     it "should not swallow exceptions raised in callbacks" do
--      lambda {
-+      expect {
-         EM.run do
-           client = Mysql2::EM::Client.new DatabaseCredentials['root']
-           defer = client.query "SELECT sleep(0.1) as first_query"
-@@ -63,13 +63,13 @@ begin
-             EM.stop_event_loop
-           end
-         end
--      }.should raise_error
-+      }.to raise_error
-     end
- 
-     context 'when an exception is raised by the client' do
-       let(:client) { Mysql2::EM::Client.new DatabaseCredentials['root'] }
-       let(:error) { StandardError.new('some error') }
--      before { client.stub(:async_result).and_raise(error) }
-+      before { allow(client).to receive(:async_result).and_raise(error) }
- 
-       it "should swallow exceptions raised in by the client" do
-         errors = []
-@@ -85,7 +85,7 @@ begin
-             EM.stop_event_loop
-           end
-         end
--        errors.should == [error]
-+        expect(errors).to eq([error])
-       end
- 
-       it "should fail the deferrable" do
-@@ -105,7 +105,7 @@ begin
-             end
-           end
-         end
--        callbacks_run.should == [:errback]
-+        expect(callbacks_run).to eq([:errback])
-       end
-     end
- 
-@@ -121,10 +121,10 @@ begin
-           callbacks_run << :errback
-         end
-         EM.add_timer(0.1) do
--          callbacks_run.should == [:callback]
--          lambda {
-+          expect(callbacks_run).to eq([:callback])
-+          expect {
-             client.close
--          }.should_not raise_error(/invalid binding to detach/)
-+          }.not_to raise_error
-           EM.stop_event_loop
-         end
-       end
---- a/spec/mysql2/client_spec.rb
-+++ b/spec/mysql2/client_spec.rb
-@@ -6,42 +6,42 @@ describe Mysql2::Client do
-     let(:cnf_file) { File.expand_path('../../my.cnf', __FILE__) }
- 
-     it "should not raise an exception for valid defaults group" do
--      lambda {
-+      expect {
-         opts = DatabaseCredentials['root'].merge(:default_file => cnf_file, :default_group => "test")
-         @client = Mysql2::Client.new(opts)
--      }.should_not raise_error(Mysql2::Error)
-+      }.not_to raise_error
-     end
- 
-     it "should not raise an exception without default group" do
--      lambda {
-+      expect {
-         @client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:default_file => cnf_file))
--      }.should_not raise_error(Mysql2::Error)
-+      }.not_to raise_error
-     end
-   end
- 
-   it "should raise an exception upon connection failure" do
--    lambda {
-+    expect {
-       # The odd local host IP address forces the mysql client library to
-       # use a TCP socket rather than a domain socket.
-       Mysql2::Client.new DatabaseCredentials['root'].merge('host' => '127.0.0.2', 'port' => 999999)
--    }.should raise_error(Mysql2::Error)
-+    }.to raise_error(Mysql2::Error)
-   end
- 
-   if defined? Encoding
-     it "should raise an exception on create for invalid encodings" do
--      lambda {
-+      expect {
-         Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "fake"))
--      }.should raise_error(Mysql2::Error)
-+      }.to raise_error(Mysql2::Error)
-     end
- 
-     it "should not raise an exception on create for a valid encoding" do
--      lambda {
-+      expect {
-         Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "utf8"))
--      }.should_not raise_error(Mysql2::Error)
-+      }.not_to raise_error
- 
--      lambda {
-+      expect {
-         Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "big5"))
--      }.should_not raise_error(Mysql2::Error)
-+      }.not_to raise_error
-     end
-   end
- 
-@@ -54,7 +54,7 @@ describe Mysql2::Client do
-       end
-     end
-     client = klient.new :flags => Mysql2::Client::FOUND_ROWS
--    (client.connect_args.last[6] & Mysql2::Client::FOUND_ROWS).should be_true
-+    expect(client.connect_args.last[6] & Mysql2::Client::FOUND_ROWS).to be_truthy
-   end
- 
-   it "should default flags to (REMEMBER_OPTIONS, LONG_PASSWORD, LONG_FLAG, TRANSACTIONS, PROTOCOL_41, SECURE_CONNECTION)" do
-@@ -66,12 +66,12 @@ describe Mysql2::Client do
-       end
-     end
-     client = klient.new
--    (client.connect_args.last[6] & (Mysql2::Client::REMEMBER_OPTIONS |
-+    expect(client.connect_args.last[6] & (Mysql2::Client::REMEMBER_OPTIONS |
-                                      Mysql2::Client::LONG_PASSWORD |
-                                      Mysql2::Client::LONG_FLAG |
-                                      Mysql2::Client::TRANSACTIONS |
-                                      Mysql2::Client::PROTOCOL_41 |
--                                     Mysql2::Client::SECURE_CONNECTION)).should be_true
-+                                     Mysql2::Client::SECURE_CONNECTION)).to be_truthy
-   end
- 
-   it "should execute init command" do
-@@ -79,7 +79,7 @@ describe Mysql2::Client do
-     options[:init_command] = "SET @something = 'setting_value';"
-     client = Mysql2::Client.new(options)
-     result = client.query("SELECT @something;")
--    result.first['@something'].should eq('setting_value')
-+    expect(result.first['@something']).to eq('setting_value')
-   end
- 
-   it "should send init_command after reconnect" do
-@@ -89,7 +89,7 @@ describe Mysql2::Client do
-     client = Mysql2::Client.new(options)
- 
-     result = client.query("SELECT @something;")
--    result.first['@something'].should eq('setting_value')
-+    expect(result.first['@something']).to eq('setting_value')
- 
-     # get the current connection id
-     result = client.query("SELECT CONNECTION_ID()")
-@@ -108,15 +108,15 @@ describe Mysql2::Client do
-     second_conn_id = result.first['CONNECTION_ID()']
- 
-     # confirm reconnect by checking the new connection id
--    first_conn_id.should_not == second_conn_id
-+    expect(first_conn_id).not_to eq(second_conn_id)
- 
-     # At last, check that the init command executed
-     result = client.query("SELECT @something;")
--    result.first['@something'].should eq('setting_value')
-+    expect(result.first['@something']).to eq('setting_value')
-   end
- 
-   it "should have a global default_query_options hash" do
--    Mysql2::Client.should respond_to(:default_query_options)
-+    expect(Mysql2::Client).to respond_to(:default_query_options)
-   end
- 
-   it "should be able to connect via SSL options" do
-@@ -128,7 +128,7 @@ describe Mysql2::Client do
- 
-     # You may need to adjust the lines below to match your SSL certificate paths
-     ssl_client = nil
--    lambda {
-+    expect {
-       ssl_client = Mysql2::Client.new(
-         :sslkey    => '/etc/mysql/client-key.pem',
-         :sslcert   => '/etc/mysql/client-cert.pem',
-@@ -136,18 +136,18 @@ describe Mysql2::Client do
-         :sslcapath => '/etc/mysql/',
-         :sslcipher => 'DHE-RSA-AES256-SHA'
-       )
--    }.should_not raise_error(Mysql2::Error)
-+    }.not_to raise_error
- 
-     results = ssl_client.query("SHOW STATUS WHERE Variable_name = \"Ssl_version\" OR Variable_name = \"Ssl_cipher\"").to_a
--    results[0]['Variable_name'].should eql('Ssl_cipher')
--    results[0]['Value'].should_not be_nil
--    results[0]['Value'].should be_kind_of(String)
--    results[0]['Value'].should_not be_empty
--
--    results[1]['Variable_name'].should eql('Ssl_version')
--    results[1]['Value'].should_not be_nil
--    results[1]['Value'].should be_kind_of(String)
--    results[1]['Value'].should_not be_empty
-+    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']).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']).not_to be_empty
- 
-     ssl_client.close
-   end
-@@ -162,12 +162,12 @@ describe Mysql2::Client do
-       Mysql2::Client.new(DatabaseCredentials['root']).query('SELECT 1')
-     end
-     after_count = client.query("SHOW STATUS LIKE 'Threads_connected'").first['Value'].to_i
--    after_count.should == before_count + 10
-+    expect(after_count).to eq(before_count + 10)
- 
-     GC.start
-     sleep 0.300 # Let GC do its work
-     final_count = client.query("SHOW STATUS LIKE 'Threads_connected'").first['Value'].to_i
--    final_count.should == before_count
-+    expect(final_count).to eq(before_count)
-   end
- 
-   if Process.respond_to?(:fork)
-@@ -192,39 +192,39 @@ describe Mysql2::Client do
-   end
- 
-   it "should be able to connect to database with numeric-only name" do
--    lambda {
-+    expect {
-       creds = DatabaseCredentials['numericuser']
-       @client.query "CREATE DATABASE IF NOT EXISTS `#{creds['database']}`"
-       @client.query "GRANT ALL ON `#{creds['database']}`.* TO #{creds['username']}@`#{creds['host']}`"
-       client = Mysql2::Client.new creds
-       @client.query "DROP DATABASE IF EXISTS `#{creds['database']}`"
--    }.should_not raise_error
-+    }.not_to raise_error
-   end
- 
-   it "should respond to #close" do
--    @client.should respond_to(:close)
-+    expect(@client).to respond_to(:close)
-   end
- 
-   it "should be able to close properly" do
--    @client.close.should be_nil
--    lambda {
-+    expect(@client.close).to be_nil
-+    expect {
-       @client.query "SELECT 1"
--    }.should raise_error(Mysql2::Error)
-+    }.to raise_error(Mysql2::Error)
-   end
- 
-   it "should respond to #query" do
--    @client.should respond_to(:query)
-+    expect(@client).to respond_to(:query)
-   end
- 
-   it "should respond to #warning_count" do
--    @client.should respond_to(:warning_count)
-+    expect(@client).to respond_to(:warning_count)
-   end
- 
-   context "#warning_count" do
-     context "when no warnings" do
-       it "should 0" do
-         @client.query('select 1')
--        @client.warning_count.should == 0
-+        expect(@client.warning_count).to eq(0)
-       end
-     end
-     context "when has a warnings" do
-@@ -232,21 +232,21 @@ describe Mysql2::Client do
-         # "the statement produces extra information that can be viewed by issuing a SHOW WARNINGS"
-         # http://dev.mysql.com/doc/refman/5.0/en/explain-extended.html
-         @client.query("explain extended select 1")
--        @client.warning_count.should > 0
-+        expect(@client.warning_count).to be > 0
-       end
-     end
-   end
- 
-   it "should respond to #query_info" do
--    @client.should respond_to(:query_info)
-+    expect(@client).to respond_to(:query_info)
-   end
- 
-   context "#query_info" do
-     context "when no info present" do
-       it "should 0" do
-         @client.query('select 1')
--        @client.query_info.should be_empty
--        @client.query_info_string.should be_nil
-+        expect(@client.query_info).to be_empty
-+        expect(@client.query_info_string).to be_nil
-       end
-     end
-     context "when has some info" do
-@@ -258,8 +258,8 @@ 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)")
- 
--        @client.query_info.should  eql({:records => 2, :duplicates => 0, :warnings => 0})
--        @client.query_info_string.should eq('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"
-       end
-@@ -288,43 +288,43 @@ describe Mysql2::Client do
- 
-     it "should raise an error when local_infile is disabled" do
-       client = Mysql2::Client.new DatabaseCredentials['root'].merge(:local_infile => false)
--      lambda {
-+      expect {
-         client.query "LOAD DATA LOCAL INFILE 'spec/test_data' INTO TABLE infileTest"
--      }.should raise_error(Mysql2::Error, %r{command is not allowed})
-+      }.to raise_error(Mysql2::Error, %r{command is not allowed})
-     end
- 
-     it "should raise an error when a non-existent file is loaded" do
--      lambda {
-+      expect {
-         @client_i.query "LOAD DATA LOCAL INFILE 'this/file/is/not/here' INTO TABLE infileTest"
--      }.should_not raise_error(Mysql2::Error, %r{file not found: this/file/is/not/here})
-+      }.to raise_error(Mysql2::Error)
-     end
- 
-     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
--      info.should 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"
--      result.first.should eql({'id' => 1, 'foo' => 'Hello', 'bar' => 'World'})
-+      expect(result.first).to eql({'id' => 1, 'foo' => 'Hello', 'bar' => 'World'})
-     end
-   end
- 
-   it "should expect connect_timeout to be a positive integer" do
--    lambda {
-+    expect {
-       Mysql2::Client.new(:connect_timeout => -1)
--    }.should raise_error(Mysql2::Error)
-+    }.to raise_error(Mysql2::Error)
-   end
- 
-   it "should expect read_timeout to be a positive integer" do
--    lambda {
-+    expect {
-       Mysql2::Client.new(:read_timeout => -1)
--    }.should raise_error(Mysql2::Error)
-+    }.to raise_error(Mysql2::Error)
-   end
- 
-   it "should expect write_timeout to be a positive integer" do
--    lambda {
-+    expect {
-       Mysql2::Client.new(:write_timeout => -1)
--    }.should raise_error(Mysql2::Error)
-+    }.to raise_error(Mysql2::Error)
-   end
- 
-   context "#query" do
-@@ -333,7 +333,7 @@ describe Mysql2::Client do
- 
-       expect {
-         @client.query("SELECT 1 UNION SELECT 2", :stream => true, :cache_rows => false)
--      }.to_not raise_exception(Mysql2::Error)
-+      }.to_not raise_error
-     end
- 
-     it "should not let you query again if iterating is not finished when streaming" do
-@@ -345,59 +345,59 @@ describe Mysql2::Client do
-     end
- 
-     it "should only accept strings as the query parameter" do
--      lambda {
-+      expect {
-         @client.query ["SELECT 'not right'"]
--      }.should raise_error(TypeError)
-+      }.to raise_error(TypeError)
-     end
- 
-     it "should not retain query options set on a query for subsequent queries, but should retain it in the result" do
-       result = @client.query "SELECT 1", :something => :else
--      @client.query_options[:something].should be_nil
--      result.instance_variable_get('@query_options').should eql(@client.query_options.merge(:something => :else))
--      @client.instance_variable_get('@current_query_options').should eql(@client.query_options.merge(:something => :else))
-+      expect(@client.query_options[:something]).to be_nil
-+      expect(result.instance_variable_get('@query_options')).to eql(@client.query_options.merge(:something => :else))
-+      expect(@client.instance_variable_get('@current_query_options')).to eql(@client.query_options.merge(:something => :else))
- 
-       result = @client.query "SELECT 1"
--      result.instance_variable_get('@query_options').should eql(@client.query_options)
--      @client.instance_variable_get('@current_query_options').should eql(@client.query_options)
-+      expect(result.instance_variable_get('@query_options')).to eql(@client.query_options)
-+      expect(@client.instance_variable_get('@current_query_options')).to eql(@client.query_options)
-     end
- 
-     it "should allow changing query options for subsequent queries" do
-       @client.query_options.merge!(:something => :else)
-       result = @client.query "SELECT 1"
--      @client.query_options[:something].should eql(:else)
--      result.instance_variable_get('@query_options')[:something].should eql(:else)
-+      expect(@client.query_options[:something]).to eql(:else)
-+      expect(result.instance_variable_get('@query_options')[:something]).to eql(:else)
- 
-       # Clean up after this test
-       @client.query_options.delete(:something)
--      @client.query_options[:something].should be_nil
-+      expect(@client.query_options[:something]).to be_nil
-     end
- 
-     it "should return results as a hash by default" do
--      @client.query("SELECT 1").first.class.should eql(Hash)
-+      expect(@client.query("SELECT 1").first.class).to eql(Hash)
-     end
- 
-     it "should be able to return results as an array" do
--      @client.query("SELECT 1", :as => :array).first.class.should eql(Array)
-+      expect(@client.query("SELECT 1", :as => :array).first.class).to eql(Array)
-       @client.query("SELECT 1").each(:as => :array)
-     end
- 
-     it "should be able to return results with symbolized keys" do
--      @client.query("SELECT 1", :symbolize_keys => true).first.keys[0].class.should eql(Symbol)
-+      expect(@client.query("SELECT 1", :symbolize_keys => true).first.keys[0].class).to eql(Symbol)
-     end
- 
-     it "should require an open connection" do
-       @client.close
--      lambda {
-+      expect {
-         @client.query "SELECT 1"
--      }.should raise_error(Mysql2::Error)
-+      }.to raise_error(Mysql2::Error)
-     end
- 
-     if RUBY_PLATFORM !~ /mingw|mswin/
-       it "should not allow another query to be sent without fetching a result first" do
-         @client.query("SELECT 1", :async => true)
--        lambda {
-+        expect {
-           @client.query("SELECT 1")
--        }.should raise_error(Mysql2::Error)
-+        }.to raise_error(Mysql2::Error)
-       end
- 
-       it "should describe the thread holding the active query" do
-@@ -410,14 +410,14 @@ describe Mysql2::Client do
-           message = e.message
-         end
-         re = Regexp.escape(thr.inspect)
--        message.should match(Regexp.new(re))
-+        expect(message).to match(Regexp.new(re))
-       end
- 
-       it "should timeout if we wait longer than :read_timeout" do
-         client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:read_timeout => 1))
--        lambda {
-+        expect {
-           client.query("SELECT sleep(2)")
--        }.should raise_error(Mysql2::Error)
-+        }.to raise_error(Mysql2::Error)
-       end
- 
-       if !defined? Rubinius
-@@ -436,12 +436,12 @@ describe Mysql2::Client do
-             end
-             @client.query("SELECT sleep(2)")
-             mark[:END] = Time.now
--            mark.include?(:USR1).should be_true
--            (mark[:USR1] - mark[:START]).should >= 1
--            (mark[:USR1] - mark[:START]).should < 1.3
--            (mark[:END] - mark[:USR1]).should > 0.9
--            (mark[:END] - mark[:START]).should >= 2
--            (mark[:END] - mark[:START]).should < 2.3
-+            expect(mark.include?(:USR1)).to be_truthy
-+            expect(mark[:USR1] - mark[:START]).to be >= 1
-+            expect(mark[:USR1] - mark[:START]).to be < 1.3
-+            expect(mark[:END] - mark[:USR1]).to be > 0.9
-+            expect(mark[:END] - mark[:START]).to be >= 2
-+            expect(mark[:END] - mark[:START]).to be < 2.3
-           ensure
-             trap(:USR1, 'DEFAULT')
-             if !pid.nil?
-@@ -453,15 +453,15 @@ describe Mysql2::Client do
-       end
- 
-       it "#socket should return a Fixnum (file descriptor from C)" do
--        @client.socket.class.should eql(Fixnum)
--        @client.socket.should_not eql(0)
-+        expect(@client.socket.class).to eql(Fixnum)
-+        expect(@client.socket).not_to eql(0)
-       end
- 
-       it "#socket should require an open connection" do
-         @client.close
--        lambda {
-+        expect {
-           @client.socket
--        }.should raise_error(Mysql2::Error)
-+        }.to raise_error(Mysql2::Error)
-       end
- 
-       it "should close the connection when an exception is raised" do
-@@ -472,9 +472,9 @@ describe Mysql2::Client do
-         rescue Timeout::Error
-         end
- 
--        lambda {
-+        expect {
-           @client.query("SELECT 1")
--        }.should raise_error(Mysql2::Error, 'closed MySQL connection')
-+        }.to raise_error(Mysql2::Error, 'closed MySQL connection')
-       end
- 
-       it "should handle Timeouts without leaving the connection hanging if reconnect is true" do
-@@ -486,9 +486,9 @@ describe Mysql2::Client do
-         rescue Timeout::Error
-         end
- 
--        lambda {
-+        expect {
-           client.query("SELECT 1")
--        }.should_not raise_error(Mysql2::Error)
-+        }.not_to raise_error
-       end
- 
-       it "should handle Timeouts without leaving the connection hanging if reconnect is set to true after construction true" do
-@@ -500,9 +500,9 @@ describe Mysql2::Client do
-         rescue Timeout::Error
-         end
- 
--        lambda {
-+        expect {
-           client.query("SELECT 1")
--        }.should raise_error(Mysql2::Error)
-+        }.to raise_error(Mysql2::Error)
- 
-         client.reconnect = true
- 
-@@ -513,9 +513,9 @@ describe Mysql2::Client do
-         rescue Timeout::Error
-         end
- 
--        lambda {
-+        expect {
-           client.query("SELECT 1")
--        }.should_not raise_error(Mysql2::Error)
-+        }.not_to raise_error
- 
-       end
- 
-@@ -536,12 +536,12 @@ describe Mysql2::Client do
-           }
-         end
-         threads.each{|t| t.join }
--        results.keys.sort.should eql(threads.map{|t| t.object_id }.sort)
-+        expect(results.keys.sort).to eql(threads.map{|t| t.object_id }.sort)
-       end
- 
-       it "evented async queries should be supported" do
-         # should immediately return nil
--        @client.query("SELECT sleep(0.1)", :async => true).should eql(nil)
-+        expect(@client.query("SELECT sleep(0.1)", :async => true)).to eql(nil)
- 
-         io_wrapper = IO.for_fd(@client.socket)
-         loops = 0
-@@ -554,10 +554,10 @@ describe Mysql2::Client do
-         end
- 
-         # make sure we waited some period of time
--        (loops >= 1).should be_true
-+        expect(loops >= 1).to be_truthy
- 
-         result = @client.async_result
--        result.class.should eql(Mysql2::Result)
-+        expect(result.class).to eql(Mysql2::Result)
-       end
-     end
- 
-@@ -568,20 +568,20 @@ describe Mysql2::Client do
- 
-       it "should raise an exception when one of multiple statements fails" do
-         result = @multi_client.query("SELECT 1 AS 'set_1'; SELECT * FROM invalid_table_name; SELECT 2 AS 'set_2';")
--        result.first['set_1'].should be(1)
--        lambda {
-+        expect(result.first['set_1']).to be(1)
-+        expect {
-           @multi_client.next_result
--        }.should raise_error(Mysql2::Error)
--        @multi_client.next_result.should be_false
-+        }.to raise_error(Mysql2::Error)
-+        expect(@multi_client.next_result).to be_falsey
-       end
- 
-       it "returns multiple result sets" do
--        @multi_client.query("SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'").first.should eql({ 'set_1' => 1 })
-+        expect(@multi_client.query("SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'").first).to eql({ 'set_1' => 1 })
- 
--        @multi_client.next_result.should be_true
--        @multi_client.store_result.first.should eql({ 'set_2' => 2 })
-+        expect(@multi_client.next_result).to be_truthy
-+        expect(@multi_client.store_result.first).to eql({ 'set_2' => 2 })
- 
--        @multi_client.next_result.should be_false
-+        expect(@multi_client.next_result).to be_falsey
-       end
- 
-       it "does not interfere with other statements" do
-@@ -590,208 +590,208 @@ describe Mysql2::Client do
-           @multi_client.store_result
-         end
- 
--        @multi_client.query("SELECT 3 AS 'next'").first.should == { '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
-         @multi_client.query("SELECT 1; SELECT 2; SELECT 3")
--        lambda {
-+        expect {
-           @multi_client.query("SELECT 4")
--        }.should raise_error(Mysql2::Error)
-+        }.to raise_error(Mysql2::Error)
-       end
- 
-       it "#abandon_results! should work" do
-         @multi_client.query("SELECT 1; SELECT 2; SELECT 3")
-         @multi_client.abandon_results!
--        lambda {
-+        expect {
-           @multi_client.query("SELECT 4")
--        }.should_not raise_error(Mysql2::Error)
-+        }.not_to raise_error
-       end
- 
-       it "#more_results? should work" do
-         @multi_client.query("SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'")
--        @multi_client.more_results?.should be_true
-+        expect(@multi_client.more_results?).to be_truthy
- 
-         @multi_client.next_result
-         @multi_client.store_result
- 
--        @multi_client.more_results?.should be_false
-+        expect(@multi_client.more_results?).to be_falsey
-       end
-     end
-   end
- 
-   it "should respond to #socket" do
--    @client.should respond_to(:socket)
-+    expect(@client).to respond_to(:socket)
-   end
- 
-   if RUBY_PLATFORM =~ /mingw|mswin/
-     it "#socket should raise as it's not supported" do
--      lambda {
-+      expect {
-         @client.socket
--      }.should raise_error(Mysql2::Error)
-+      }.to raise_error(Mysql2::Error)
-     end
-   end
- 
-   it "should respond to escape" do
--    Mysql2::Client.should respond_to(:escape)
-+    expect(Mysql2::Client).to respond_to(:escape)
-   end
- 
-   context "escape" do
-     it "should return a new SQL-escape version of the passed string" do
--      Mysql2::Client.escape("abc'def\"ghi\0jkl%mno").should eql("abc\\'def\\\"ghi\\0jkl%mno")
-+      expect(Mysql2::Client.escape("abc'def\"ghi\0jkl%mno")).to eql("abc\\'def\\\"ghi\\0jkl%mno")
-     end
- 
-     it "should return the passed string if nothing was escaped" do
-       str = "plain"
--      Mysql2::Client.escape(str).object_id.should eql(str.object_id)
-+      expect(Mysql2::Client.escape(str).object_id).to eql(str.object_id)
-     end
- 
-     it "should not overflow the thread stack" do
--      lambda {
-+      expect {
-         Thread.new { Mysql2::Client.escape("'" * 256 * 1024) }.join
--      }.should_not raise_error(SystemStackError)
-+      }.not_to raise_error
-     end
- 
-     it "should not overflow the process stack" do
--      lambda {
-+      expect {
-         Thread.new { Mysql2::Client.escape("'" * 1024 * 1024 * 4) }.join
--      }.should_not raise_error(SystemStackError)
-+      }.not_to raise_error
-     end
- 
-     unless RUBY_VERSION =~ /1.8/
-       it "should carry over the original string's encoding" do
-         str = "abc'def\"ghi\0jkl%mno"
-         escaped = Mysql2::Client.escape(str)
--        escaped.encoding.should eql(str.encoding)
-+        expect(escaped.encoding).to eql(str.encoding)
- 
-         str.encode!('us-ascii')
-         escaped = Mysql2::Client.escape(str)
--        escaped.encoding.should eql(str.encoding)
-+        expect(escaped.encoding).to eql(str.encoding)
-       end
-     end
-   end
- 
-   it "should respond to #escape" do
--    @client.should respond_to(:escape)
-+    expect(@client).to respond_to(:escape)
-   end
- 
-   context "#escape" do
-     it "should return a new SQL-escape version of the passed string" do
--      @client.escape("abc'def\"ghi\0jkl%mno").should eql("abc\\'def\\\"ghi\\0jkl%mno")
-+      expect(@client.escape("abc'def\"ghi\0jkl%mno")).to eql("abc\\'def\\\"ghi\\0jkl%mno")
-     end
- 
-     it "should return the passed string if nothing was escaped" do
-       str = "plain"
--      @client.escape(str).object_id.should eql(str.object_id)
-+      expect(@client.escape(str).object_id).to eql(str.object_id)
-     end
- 
-     it "should not overflow the thread stack" do
--      lambda {
-+      expect {
-         Thread.new { @client.escape("'" * 256 * 1024) }.join
--      }.should_not raise_error(SystemStackError)
-+      }.not_to raise_error
-     end
- 
-     it "should not overflow the process stack" do
--      lambda {
-+      expect {
-         Thread.new { @client.escape("'" * 1024 * 1024 * 4) }.join
--      }.should_not raise_error(SystemStackError)
-+      }.not_to raise_error
-     end
- 
-     it "should require an open connection" do
-       @client.close
--      lambda {
-+      expect {
-         @client.escape ""
--      }.should raise_error(Mysql2::Error)
-+      }.to raise_error(Mysql2::Error)
-     end
-   end
- 
-   it "should respond to #info" do
--    @client.should respond_to(:info)
-+    expect(@client).to respond_to(:info)
-   end
- 
-   it "#info should return a hash containing the client version ID and String" do
-     info = @client.info
--    info.class.should eql(Hash)
--    info.should have_key(:id)
--    info[:id].class.should eql(Fixnum)
--    info.should have_key(:version)
--    info[:version].class.should eql(String)
-+    expect(info.class).to eql(Hash)
-+    expect(info).to have_key(:id)
-+    expect(info[:id].class).to eql(Fixnum)
-+    expect(info).to have_key(:version)
-+    expect(info[:version].class).to eql(String)
-   end
- 
-   if defined? Encoding
-     context "strings returned by #info" do
-       it "should default to the connection's encoding if Encoding.default_internal is nil" do
-         with_internal_encoding nil do
--          @client.info[:version].encoding.should eql(Encoding.find('utf-8'))
-+          expect(@client.info[:version].encoding).to eql(Encoding.find('utf-8'))
- 
-           client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
--          client2.info[:version].encoding.should eql(Encoding.find('us-ascii'))
-+          expect(client2.info[:version].encoding).to eql(Encoding.find('us-ascii'))
-         end
-       end
- 
-       it "should use Encoding.default_internal" do
-         with_internal_encoding 'utf-8' do
--          @client.info[:version].encoding.should eql(Encoding.default_internal)
-+          expect(@client.info[:version].encoding).to eql(Encoding.default_internal)
-         end
- 
-         with_internal_encoding 'us-ascii' do
--          @client.info[:version].encoding.should eql(Encoding.default_internal)
-+          expect(@client.info[:version].encoding).to eql(Encoding.default_internal)
-         end
-       end
-     end
-   end
- 
-   it "should respond to #server_info" do
--    @client.should respond_to(:server_info)
-+    expect(@client).to respond_to(:server_info)
-   end
- 
-   it "#server_info should return a hash containing the client version ID and String" do
-     server_info = @client.server_info
--    server_info.class.should eql(Hash)
--    server_info.should have_key(:id)
--    server_info[:id].class.should eql(Fixnum)
--    server_info.should have_key(:version)
--    server_info[:version].class.should eql(String)
-+    expect(server_info.class).to eql(Hash)
-+    expect(server_info).to have_key(:id)
-+    expect(server_info[:id].class).to eql(Fixnum)
-+    expect(server_info).to have_key(:version)
-+    expect(server_info[:version].class).to eql(String)
-   end
- 
-   it "#server_info should require an open connection" do
-     @client.close
--    lambda {
-+    expect {
-       @client.server_info
--    }.should raise_error(Mysql2::Error)
-+    }.to raise_error(Mysql2::Error)
-   end
- 
-   if defined? Encoding
-     context "strings returned by #server_info" do
-       it "should default to the connection's encoding if Encoding.default_internal is nil" do
-         with_internal_encoding nil do
--          @client.server_info[:version].encoding.should eql(Encoding.find('utf-8'))
-+          expect(@client.server_info[:version].encoding).to eql(Encoding.find('utf-8'))
- 
-           client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
--          client2.server_info[:version].encoding.should eql(Encoding.find('us-ascii'))
-+          expect(client2.server_info[:version].encoding).to eql(Encoding.find('us-ascii'))
-         end
-       end
- 
-       it "should use Encoding.default_internal" do
-         with_internal_encoding 'utf-8' do
--          @client.server_info[:version].encoding.should eql(Encoding.default_internal)
-+          expect(@client.server_info[:version].encoding).to eql(Encoding.default_internal)
-         end
- 
-         with_internal_encoding 'us-ascii' do
--          @client.server_info[:version].encoding.should eql(Encoding.default_internal)
-+          expect(@client.server_info[:version].encoding).to eql(Encoding.default_internal)
-         end
-       end
-     end
-   end
- 
-   it "should raise a Mysql2::Error exception upon connection failure" do
--    lambda {
-+    expect {
-       Mysql2::Client.new :host => "localhost", :username => 'asdfasdf8d2h', :password => 'asdfasdfw42'
--    }.should raise_error(Mysql2::Error)
-+    }.to raise_error(Mysql2::Error)
- 
--    lambda {
-+    expect {
-       Mysql2::Client.new DatabaseCredentials['root']
--    }.should_not raise_error(Mysql2::Error)
-+    }.not_to raise_error
-   end
- 
-   context 'write operations api' do
-@@ -805,46 +805,46 @@ describe Mysql2::Client do
-     end
- 
-     it "should respond to #last_id" do
--      @client.should respond_to(:last_id)
-+      expect(@client).to respond_to(:last_id)
-     end
- 
-     it "#last_id should return a Fixnum, the from the last INSERT/UPDATE" do
--      @client.last_id.should eql(0)
-+      expect(@client.last_id).to eql(0)
-       @client.query "INSERT INTO lastIdTest (blah) VALUES (1234)"
--      @client.last_id.should eql(1)
-+      expect(@client.last_id).to eql(1)
-     end
- 
-     it "should respond to #last_id" do
--      @client.should respond_to(:last_id)
-+      expect(@client).to respond_to(:last_id)
-     end
- 
-     it "#last_id should return a Fixnum, the from the last INSERT/UPDATE" do
-       @client.query "INSERT INTO lastIdTest (blah) VALUES (1234)"
--      @client.affected_rows.should eql(1)
-+      expect(@client.affected_rows).to eql(1)
-       @client.query "UPDATE lastIdTest SET blah=4321 WHERE id=1"
--      @client.affected_rows.should eql(1)
-+      expect(@client.affected_rows).to eql(1)
-     end
- 
-     it "#last_id should handle BIGINT auto-increment ids above 32 bits" do
-       # The id column type must be BIGINT. Surprise: INT(x) is limited to 32-bits for all values of x.
-       # Insert a row with a given ID, this should raise the auto-increment state
-       @client.query "INSERT INTO lastIdTest (id, blah) VALUES (5000000000, 5000)"
--      @client.last_id.should eql(5000000000)
-+      expect(@client.last_id).to eql(5000000000)
-       @client.query "INSERT INTO lastIdTest (blah) VALUES (5001)"
--      @client.last_id.should eql(5000000001)
-+      expect(@client.last_id).to eql(5000000001)
-     end
-   end
- 
-   it "should respond to #thread_id" do
--    @client.should respond_to(:thread_id)
-+    expect(@client).to respond_to(:thread_id)
-   end
- 
-   it "#thread_id should be a Fixnum" do
--    @client.thread_id.class.should eql(Fixnum)
-+    expect(@client.thread_id.class).to eql(Fixnum)
-   end
- 
-   it "should respond to #ping" do
--    @client.should respond_to(:ping)
-+    expect(@client).to respond_to(:ping)
-   end
- 
-   context "select_db" do
-@@ -863,38 +863,38 @@ describe Mysql2::Client do
-     end
- 
-     it "should respond to #select_db" do
--      @client.should respond_to(:select_db)
-+      expect(@client).to respond_to(:select_db)
-     end
- 
-     it "should switch databases" do
-       @client.select_db("test_selectdb_0")
--      @client.query("SHOW TABLES").first.values.first.should eql("test0")
-+      expect(@client.query("SHOW TABLES").first.values.first).to eql("test0")
-       @client.select_db("test_selectdb_1")
--      @client.query("SHOW TABLES").first.values.first.should eql("test1")
-+      expect(@client.query("SHOW TABLES").first.values.first).to eql("test1")
-       @client.select_db("test_selectdb_0")
--      @client.query("SHOW TABLES").first.values.first.should eql("test0")
-+      expect(@client.query("SHOW TABLES").first.values.first).to eql("test0")
-     end
- 
-     it "should raise a Mysql2::Error when the database doesn't exist" do
--      lambda {
-+      expect {
-         @client.select_db("nopenothere")
--      }.should raise_error(Mysql2::Error)
-+      }.to raise_error(Mysql2::Error)
-     end
- 
-     it "should return the database switched to" do
--      @client.select_db("test_selectdb_1").should eq("test_selectdb_1")
-+      expect(@client.select_db("test_selectdb_1")).to eq("test_selectdb_1")
-     end
-   end
- 
-   it "#thread_id should return a boolean" do
--    @client.ping.should eql(true)
-+    expect(@client.ping).to eql(true)
-     @client.close
--    @client.ping.should eql(false)
-+    expect(@client.ping).to eql(false)
-   end
- 
-   unless RUBY_VERSION =~ /1.8/
-     it "should respond to #encoding" do
--      @client.should respond_to(:encoding)
-+      expect(@client).to respond_to(:encoding)
-     end
-   end
- end
---- a/spec/mysql2/error_spec.rb
-+++ b/spec/mysql2/error_spec.rb
-@@ -18,12 +18,12 @@ describe Mysql2::Error do
-   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
-@@ -55,27 +55,27 @@ describe Mysql2::Error do
- 
-     it "returns error messages as UTF-8 by default" do
-       with_internal_encoding nil do
--        error.message.encoding.should eql(Encoding::UTF_8)
-+        expect(error.message.encoding).to eql(Encoding::UTF_8)
-         error.message.valid_encoding?
- 
--        bad_err.message.encoding.should eql(Encoding::UTF_8)
-+        expect(bad_err.message.encoding).to eql(Encoding::UTF_8)
-         bad_err.message.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)
-+      expect(error.sql_state.encoding).to eql(Encoding::US_ASCII)
-       error.sql_state.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)
-+        expect(error.message.encoding).to eql(Encoding.default_internal)
-         error.message.valid_encoding?
- 
--        bad_err.message.encoding.should eql(Encoding.default_internal)
-+        expect(bad_err.message.encoding).to eql(Encoding.default_internal)
-         bad_err.message.valid_encoding?
-       end
-     end
---- a/spec/mysql2/result_spec.rb
-+++ b/spec/mysql2/result_spec.rb
-@@ -7,33 +7,33 @@ describe Mysql2::Result do
-   end
- 
-   it "should have included Enumerable" do
--    Mysql2::Result.ancestors.include?(Enumerable).should be_true
-+    expect(Mysql2::Result.ancestors.include?(Enumerable)).to be_truthy
-   end
- 
-   it "should respond to #each" do
--    @result.should respond_to(:each)
-+    expect(@result).to respond_to(:each)
-   end
- 
-   it "should raise a Mysql2::Error exception upon a bad query" do
--    lambda {
-+    expect {
-       @client.query "bad sql"
--    }.should raise_error(Mysql2::Error)
-+    }.to raise_error(Mysql2::Error)
- 
--    lambda {
-+    expect {
-       @client.query "SELECT 1"
--    }.should_not raise_error(Mysql2::Error)
-+    }.not_to raise_error
-   end
- 
-   it "should respond to #count, which is aliased as #size" do
-     r = @client.query "SELECT 1"
--    r.should respond_to :count
--    r.should respond_to :size
-+    expect(r).to respond_to :count
-+    expect(r).to respond_to :size
-   end
- 
-   it "should be able to return the number of rows in the result set" do
-     r = @client.query "SELECT 1"
--    r.count.should eql(1)
--    r.size.should eql(1)
-+    expect(r.count).to eql(1)
-+    expect(r.size).to eql(1)
-   end
- 
-   context "metadata queries" do
-@@ -45,39 +45,39 @@ describe Mysql2::Result do
-   context "#each" do
-     it "should yield rows as hash's" do
-       @result.each do |row|
--        row.class.should eql(Hash)
-+        expect(row.class).to eql(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|
--        row.keys.first.class.should eql(Symbol)
-+        expect(row.keys.first.class).to eql(Symbol)
-       end
-     end
- 
-     it "should be able to return results as an array" do
-       @result.each(:as => :array) do |row|
--        row.class.should eql(Array)
-+        expect(row.class).to eql(Array)
-       end
-     end
- 
-     it "should cache previously yielded results by default" do
--      @result.first.object_id.should eql(@result.first.object_id)
-+      expect(@result.first.object_id).to eql(@result.first.object_id)
-     end
- 
-     it "should not cache previously yielded results if cache_rows is disabled" do
-       result = @client.query "SELECT 1", :cache_rows => false
--      result.first.object_id.should_not eql(result.first.object_id)
-+      expect(result.first.object_id).not_to eql(result.first.object_id)
-     end
- 
-     it "should yield different value for #first if streaming" do
-       result = @client.query "SELECT 1 UNION SELECT 2", :stream => true, :cache_rows => false
--      result.first.should_not eql(result.first)
-+      expect(result.first).not_to eql(result.first)
-     end
- 
-     it "should yield the same value for #first if streaming is disabled" do
-       result = @client.query "SELECT 1 UNION SELECT 2", :stream => false
--      result.first.should eql(result.first)
-+      expect(result.first).to eql(result.first)
-     end
- 
-     it "should throw an exception if we try to iterate twice when streaming is enabled" do
-@@ -96,12 +96,12 @@ describe Mysql2::Result do
-     end
- 
-     it "method should exist" do
--      @test_result.should respond_to(:fields)
-+      expect(@test_result).to respond_to(:fields)
-     end
- 
-     it "should return an array of field names in proper order" do
-       result = @client.query "SELECT 'a', 'b', 'c'"
--      result.fields.should eql(['a', 'b', 'c'])
-+      expect(result.fields).to eql(['a', 'b', 'c'])
-     end
-   end
- 
-@@ -109,28 +109,28 @@ describe Mysql2::Result do
-     it "should maintain a count while streaming" do
-       result = @client.query('SELECT 1')
- 
--      result.count.should eql(1)
-+      expect(result.count).to eql(1)
-       result.each.to_a
--      result.count.should eql(1)
-+      expect(result.count).to eql(1)
-     end
- 
-     it "should set the actual count of rows after streaming" do
-       result = @client.query("SELECT * FROM mysql2_test", :stream => true, :cache_rows => false)
--      result.count.should eql(0)
-+      expect(result.count).to eql(0)
-       result.each {|r|  }
--      result.count.should eql(1)
-+      expect(result.count).to eql(1)
-     end
- 
-     it "should not yield nil at the end of streaming" do
-       result = @client.query('SELECT * FROM mysql2_test', :stream => true, :cache_rows => false)
--      result.each { |r| r.should_not be_nil}
-+      result.each { |r| expect(r).not_to be_nil}
-     end
- 
-     it "#count should be zero for rows after streaming when there were no results" do
-       result = @client.query("SELECT * FROM mysql2_test WHERE null_test IS NOT NULL", :stream => true, :cache_rows => false)
--      result.count.should eql(0)
-+      expect(result.count).to eql(0)
-       result.each.to_a
--      result.count.should eql(0)
-+      expect(result.count).to eql(0)
-     end
- 
-     it "should raise an exception if streaming ended due to a timeout" do
-@@ -147,12 +147,12 @@ describe Mysql2::Result do
-       client.query "SET net_write_timeout = 1"
-       res = client.query "SELECT * FROM streamingTest", :stream => true, :cache_rows => false
- 
--      lambda {
-+      expect {
-         res.each_with_index do |row, i|
-           # Exhaust the first result packet then trigger a timeout
-           sleep 2 if i > 0 && i % 1000 == 0
-         end
--      }.should raise_error(Mysql2::Error, /Lost connection/)
-+      }.to raise_error(Mysql2::Error, /Lost connection/)
-     end
-   end
- 
-@@ -163,32 +163,32 @@ describe Mysql2::Result do
- 
-     it "should return nil values for NULL and strings for everything else when :cast is false" do
-       result = @client.query('SELECT null_test, tiny_int_test, bool_cast_test, int_test, date_test, enum_test FROM mysql2_test WHERE bool_cast_test = 1 LIMIT 1', :cast => false).first
--      result["null_test"].should be_nil
--      result["tiny_int_test"].should  eql("1")
--      result["bool_cast_test"].should eql("1")
--      result["int_test"].should       eql("10")
--      result["date_test"].should      eql("2010-04-04")
--      result["enum_test"].should      eql("val1")
-+      expect(result["null_test"]).to be_nil
-+      expect(result["tiny_int_test"]).to  eql("1")
-+      expect(result["bool_cast_test"]).to eql("1")
-+      expect(result["int_test"]).to       eql("10")
-+      expect(result["date_test"]).to      eql("2010-04-04")
-+      expect(result["enum_test"]).to      eql("val1")
-     end
- 
-     it "should return nil for a NULL value" do
--      @test_result['null_test'].class.should eql(NilClass)
--      @test_result['null_test'].should eql(nil)
-+      expect(@test_result['null_test'].class).to eql(NilClass)
-+      expect(@test_result['null_test']).to eql(nil)
-     end
- 
-     it "should return String for a BIT(64) value" do
--      @test_result['bit_test'].class.should eql(String)
--      @test_result['bit_test'].should eql("\000\000\000\000\000\000\000\005")
-+      expect(@test_result['bit_test'].class).to eql(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
--      @test_result['single_bit_test'].class.should eql(String)
--      @test_result['single_bit_test'].should eql("\001")
-+      expect(@test_result['single_bit_test'].class).to eql(String)
-+      expect(@test_result['single_bit_test']).to eql("\001")
-     end
- 
-     it "should return Fixnum for a TINYINT value" do
--      [Fixnum, Bignum].should include(@test_result['tiny_int_test'].class)
--      @test_result['tiny_int_test'].should eql(1)
-+      expect([Fixnum, Bignum]).to include(@test_result['tiny_int_test'].class)
-+      expect(@test_result['tiny_int_test']).to eql(1)
-     end
- 
-     it "should return TrueClass or FalseClass for a TINYINT value if :cast_booleans is enabled" do
-@@ -202,9 +202,9 @@ describe Mysql2::Result do
-       result1 = @client.query 'SELECT bool_cast_test FROM mysql2_test WHERE bool_cast_test = 1 LIMIT 1', :cast_booleans => true
-       result2 = @client.query 'SELECT bool_cast_test FROM mysql2_test WHERE bool_cast_test = 0 LIMIT 1', :cast_booleans => true
-       result3 = @client.query 'SELECT bool_cast_test FROM mysql2_test WHERE bool_cast_test = -1 LIMIT 1', :cast_booleans => true
--      result1.first['bool_cast_test'].should be_true
--      result2.first['bool_cast_test'].should be_false
--      result3.first['bool_cast_test'].should be_true
-+      expect(result1.first['bool_cast_test']).to be_truthy
-+      expect(result2.first['bool_cast_test']).to be_falsey
-+      expect(result3.first['bool_cast_test']).to be_truthy
- 
-       @client.query "DELETE from mysql2_test WHERE id IN(#{id1},#{id2},#{id3})"
-     end
-@@ -217,55 +217,55 @@ describe Mysql2::Result do
- 
-       result1 = @client.query "SELECT single_bit_test FROM mysql2_test WHERE id = #{id1}", :cast_booleans => true
-       result2 = @client.query "SELECT single_bit_test FROM mysql2_test WHERE id = #{id2}", :cast_booleans => true
--      result1.first['single_bit_test'].should be_true
--      result2.first['single_bit_test'].should be_false
-+      expect(result1.first['single_bit_test']).to be_truthy
-+      expect(result2.first['single_bit_test']).to be_falsey
- 
-       @client.query "DELETE from mysql2_test WHERE id IN(#{id1},#{id2})"
-     end
- 
-     it "should return Fixnum for a SMALLINT value" do
--      [Fixnum, Bignum].should include(@test_result['small_int_test'].class)
--      @test_result['small_int_test'].should eql(10)
-+      expect([Fixnum, Bignum]).to include(@test_result['small_int_test'].class)
-+      expect(@test_result['small_int_test']).to eql(10)
-     end
- 
-     it "should return Fixnum for a MEDIUMINT value" do
--      [Fixnum, Bignum].should include(@test_result['medium_int_test'].class)
--      @test_result['medium_int_test'].should eql(10)
-+      expect([Fixnum, Bignum]).to include(@test_result['medium_int_test'].class)
-+      expect(@test_result['medium_int_test']).to eql(10)
-     end
- 
-     it "should return Fixnum for an INT value" do
--      [Fixnum, Bignum].should include(@test_result['int_test'].class)
--      @test_result['int_test'].should eql(10)
-+      expect([Fixnum, Bignum]).to include(@test_result['int_test'].class)
-+      expect(@test_result['int_test']).to eql(10)
-     end
- 
-     it "should return Fixnum for a BIGINT value" do
--      [Fixnum, Bignum].should include(@test_result['big_int_test'].class)
--      @test_result['big_int_test'].should eql(10)
-+      expect([Fixnum, Bignum]).to include(@test_result['big_int_test'].class)
-+      expect(@test_result['big_int_test']).to eql(10)
-     end
- 
-     it "should return Fixnum for a YEAR value" do
--      [Fixnum, Bignum].should include(@test_result['year_test'].class)
--      @test_result['year_test'].should eql(2009)
-+      expect([Fixnum, Bignum]).to include(@test_result['year_test'].class)
-+      expect(@test_result['year_test']).to eql(2009)
-     end
- 
-     it "should return BigDecimal for a DECIMAL value" do
--      @test_result['decimal_test'].class.should eql(BigDecimal)
--      @test_result['decimal_test'].should eql(10.3)
-+      expect(@test_result['decimal_test'].class).to eql(BigDecimal)
-+      expect(@test_result['decimal_test']).to eql(10.3)
-     end
- 
-     it "should return Float for a FLOAT value" do
--      @test_result['float_test'].class.should eql(Float)
--      @test_result['float_test'].should eql(10.3)
-+      expect(@test_result['float_test'].class).to eql(Float)
-+      expect(@test_result['float_test']).to eql(10.3)
-     end
- 
-     it "should return Float for a DOUBLE value" do
--      @test_result['double_test'].class.should eql(Float)
--      @test_result['double_test'].should eql(10.3)
-+      expect(@test_result['double_test'].class).to eql(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
--      @test_result['date_time_test'].class.should eql(Time)
--      @test_result['date_time_test'].strftime("%Y-%m-%d %H:%M:%S").should eql('2010-04-04 11:44:00')
-+      expect(@test_result['date_time_test'].class).to eql(Time)
-+      expect(@test_result['date_time_test'].strftime("%Y-%m-%d %H:%M:%S")).to eql('2010-04-04 11:44:00')
-     end
- 
-     if 1.size == 4 # 32bit
-@@ -278,61 +278,61 @@ describe Mysql2::Result do
-       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")
--        r.first['test'].class.should eql(klass)
-+        expect(r.first['test'].class).to eql(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")
--        r.first['test'].class.should eql(klass)
-+        expect(r.first['test'].class).to eql(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")
--          r.first['test'].class.should eql(Time)
-+          expect(r.first['test'].class).to eql(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")
--          r.first['test'].class.should eql(Time)
-+          expect(r.first['test'].class).to eql(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")
--          r.first['test'].class.should eql(Time)
-+          expect(r.first['test'].class).to eql(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")
--          r.first['test'].class.should eql(DateTime)
-+          expect(r.first['test'].class).to eql(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")
--          r.first['test'].class.should eql(Time)
-+          expect(r.first['test'].class).to eql(Time)
-         end
-       end
-     end
- 
-     it "should return Time for a TIMESTAMP value when within the supported range" do
--      @test_result['timestamp_test'].class.should eql(Time)
--      @test_result['timestamp_test'].strftime("%Y-%m-%d %H:%M:%S").should eql('2010-04-04 11:44:00')
-+      expect(@test_result['timestamp_test'].class).to eql(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
--      @test_result['time_test'].class.should eql(Time)
--      @test_result['time_test'].strftime("%Y-%m-%d %H:%M:%S").should eql('2000-01-01 11:44:00')
-+      expect(@test_result['time_test'].class).to eql(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
--      @test_result['date_test'].class.should eql(Date)
--      @test_result['date_test'].strftime("%Y-%m-%d").should eql('2010-04-04')
-+      expect(@test_result['date_test'].class).to eql(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
--      @test_result['enum_test'].class.should eql(String)
--      @test_result['enum_test'].should eql('val1')
-+      expect(@test_result['enum_test'].class).to eql(String)
-+      expect(@test_result['enum_test']).to eql('val1')
-     end
- 
-     it "should raise an error given an invalid DATETIME" do
-@@ -342,7 +342,7 @@ describe Mysql2::Result do
-         error = e
-       end
- 
--      error.message.should eql("Invalid date in field 'bad_datetime': 1972-00-27 00:00:00")
-+      expect(error.message).to eql("Invalid date in field 'bad_datetime': 1972-00-27 00:00:00")
-     end
- 
-     if defined? Encoding
-@@ -350,11 +350,11 @@ describe Mysql2::Result do
-         it "should default to the connection's encoding if Encoding.default_internal is nil" do
-           with_internal_encoding nil do
-             result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--            result['enum_test'].encoding.should eql(Encoding.find('utf-8'))
-+            expect(result['enum_test'].encoding).to eql(Encoding.find('utf-8'))
- 
-             client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
-             result = client2.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--            result['enum_test'].encoding.should eql(Encoding.find('us-ascii'))
-+            expect(result['enum_test'].encoding).to eql(Encoding.find('us-ascii'))
-             client2.close
-           end
-         end
-@@ -362,20 +362,20 @@ describe Mysql2::Result do
-         it "should use Encoding.default_internal" do
-           with_internal_encoding 'utf-8' do
-             result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--            result['enum_test'].encoding.should eql(Encoding.default_internal)
-+            expect(result['enum_test'].encoding).to eql(Encoding.default_internal)
-           end
- 
-           with_internal_encoding 'us-ascii' do
-             result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--            result['enum_test'].encoding.should eql(Encoding.default_internal)
-+            expect(result['enum_test'].encoding).to eql(Encoding.default_internal)
-           end
-         end
-       end
-     end
- 
-     it "should return String for a SET value" do
--      @test_result['set_test'].class.should eql(String)
--      @test_result['set_test'].should eql('val1,val2')
-+      expect(@test_result['set_test'].class).to eql(String)
-+      expect(@test_result['set_test']).to eql('val1,val2')
-     end
- 
-     if defined? Encoding
-@@ -383,11 +383,11 @@ describe Mysql2::Result do
-         it "should default to the connection's encoding if Encoding.default_internal is nil" do
-           with_internal_encoding nil do
-             result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--            result['set_test'].encoding.should eql(Encoding.find('utf-8'))
-+            expect(result['set_test'].encoding).to eql(Encoding.find('utf-8'))
- 
-             client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
-             result = client2.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--            result['set_test'].encoding.should eql(Encoding.find('us-ascii'))
-+            expect(result['set_test'].encoding).to eql(Encoding.find('us-ascii'))
-             client2.close
-           end
-         end
-@@ -395,20 +395,20 @@ describe Mysql2::Result do
-         it "should use Encoding.default_internal" do
-           with_internal_encoding 'utf-8' do
-             result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--            result['set_test'].encoding.should eql(Encoding.default_internal)
-+            expect(result['set_test'].encoding).to eql(Encoding.default_internal)
-           end
- 
-           with_internal_encoding 'us-ascii' do
-             result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--            result['set_test'].encoding.should eql(Encoding.default_internal)
-+            expect(result['set_test'].encoding).to eql(Encoding.default_internal)
-           end
-         end
-       end
-     end
- 
-     it "should return String for a BINARY value" do
--      @test_result['binary_test'].class.should eql(String)
--      @test_result['binary_test'].should eql("test#{"\000"*6}")
-+      expect(@test_result['binary_test'].class).to eql(String)
-+      expect(@test_result['binary_test']).to eql("test#{"\000"*6}")
-     end
- 
-     if defined? Encoding
-@@ -416,19 +416,19 @@ describe Mysql2::Result do
-         it "should default to binary if Encoding.default_internal is nil" do
-           with_internal_encoding nil do
-             result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--            result['binary_test'].encoding.should eql(Encoding.find('binary'))
-+            expect(result['binary_test'].encoding).to eql(Encoding.find('binary'))
-           end
-         end
- 
-         it "should not use Encoding.default_internal" do
-           with_internal_encoding 'utf-8' do
-             result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--            result['binary_test'].encoding.should eql(Encoding.find('binary'))
-+            expect(result['binary_test'].encoding).to eql(Encoding.find('binary'))
-           end
- 
-           with_internal_encoding 'us-ascii' do
-             result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--            result['binary_test'].encoding.should eql(Encoding.find('binary'))
-+            expect(result['binary_test'].encoding).to eql(Encoding.find('binary'))
-           end
-         end
-       end
-@@ -448,8 +448,8 @@ describe Mysql2::Result do
-       'long_text_test' => 'LONGTEXT'
-     }.each do |field, type|
-       it "should return a String for #{type}" do
--        @test_result[field].class.should eql(String)
--        @test_result[field].should eql("test")
-+        expect(@test_result[field].class).to eql(String)
-+        expect(@test_result[field]).to eql("test")
-       end
- 
-       if defined? Encoding
-@@ -458,30 +458,30 @@ describe Mysql2::Result do
-             it "should default to binary if Encoding.default_internal is nil" do
-               with_internal_encoding nil do
-                 result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--                result['binary_test'].encoding.should eql(Encoding.find('binary'))
-+                expect(result['binary_test'].encoding).to eql(Encoding.find('binary'))
-               end
-             end
- 
-             it "should not use Encoding.default_internal" do
-               with_internal_encoding 'utf-8' do
-                 result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--                result['binary_test'].encoding.should eql(Encoding.find('binary'))
-+                expect(result['binary_test'].encoding).to eql(Encoding.find('binary'))
-               end
- 
-               with_internal_encoding 'us-ascii' do
-                 result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--                result['binary_test'].encoding.should eql(Encoding.find('binary'))
-+                expect(result['binary_test'].encoding).to eql(Encoding.find('binary'))
-               end
-             end
-           else
-             it "should default to utf-8 if Encoding.default_internal is nil" do
-               with_internal_encoding nil do
-                 result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--                result[field].encoding.should eql(Encoding.find('utf-8'))
-+                expect(result[field].encoding).to eql(Encoding.find('utf-8'))
- 
-                 client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
-                 result = client2.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--                result[field].encoding.should eql(Encoding.find('us-ascii'))
-+                expect(result[field].encoding).to eql(Encoding.find('us-ascii'))
-                 client2.close
-               end
-             end
-@@ -489,12 +489,12 @@ describe Mysql2::Result do
-             it "should use Encoding.default_internal" do
-               with_internal_encoding 'utf-8' do
-                 result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--                result[field].encoding.should eql(Encoding.default_internal)
-+                expect(result[field].encoding).to eql(Encoding.default_internal)
-               end
- 
-               with_internal_encoding 'us-ascii' do
-                 result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
--                result[field].encoding.should eql(Encoding.default_internal)
-+                expect(result[field].encoding).to eql(Encoding.default_internal)
-               end
-             end
-           end
diff --git a/debian/patches/series b/debian/patches/series
index 5c6feb9..d2a8947 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,5 +1,2 @@
 remove_rpath_compilation_flag.patch
 remove_rubygems_from_examples.patch
-#deactivate_failing_specs.patch
-cleanup_fork.patch
-port_to_rspec3.patch

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-ruby-extras/ruby-mysql2.git



More information about the Pkg-ruby-extras-commits mailing list