[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