mysql2 0.3.18 → 0.4.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -1,48 +1,46 @@
1
1
  # encoding: UTF-8
2
2
  require 'spec_helper'
3
3
 
4
- describe Mysql2::Client do
4
+ RSpec.describe Mysql2::Client do
5
5
  context "using defaults file" do
6
6
  let(:cnf_file) { File.expand_path('../../my.cnf', __FILE__) }
7
7
 
8
8
  it "should not raise an exception for valid defaults group" do
9
- lambda {
9
+ expect {
10
10
  opts = DatabaseCredentials['root'].merge(:default_file => cnf_file, :default_group => "test")
11
11
  @client = Mysql2::Client.new(opts)
12
- }.should_not raise_error(Mysql2::Error)
12
+ }.not_to raise_error
13
13
  end
14
14
 
15
15
  it "should not raise an exception without default group" do
16
- lambda {
16
+ expect {
17
17
  @client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:default_file => cnf_file))
18
- }.should_not raise_error(Mysql2::Error)
18
+ }.not_to raise_error
19
19
  end
20
20
  end
21
21
 
22
22
  it "should raise an exception upon connection failure" do
23
- lambda {
23
+ expect {
24
24
  # The odd local host IP address forces the mysql client library to
25
25
  # use a TCP socket rather than a domain socket.
26
26
  Mysql2::Client.new DatabaseCredentials['root'].merge('host' => '127.0.0.2', 'port' => 999999)
27
- }.should raise_error(Mysql2::Error)
27
+ }.to raise_error(Mysql2::Error)
28
28
  end
29
29
 
30
- if defined? Encoding
31
- it "should raise an exception on create for invalid encodings" do
32
- lambda {
33
- Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "fake"))
34
- }.should raise_error(Mysql2::Error)
35
- end
30
+ it "should raise an exception on create for invalid encodings" do
31
+ expect {
32
+ Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "fake"))
33
+ }.to raise_error(Mysql2::Error)
34
+ end
36
35
 
37
- it "should not raise an exception on create for a valid encoding" do
38
- lambda {
39
- Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "utf8"))
40
- }.should_not raise_error(Mysql2::Error)
36
+ it "should not raise an exception on create for a valid encoding" do
37
+ expect {
38
+ Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "utf8"))
39
+ }.not_to raise_error
41
40
 
42
- lambda {
43
- Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "big5"))
44
- }.should_not raise_error(Mysql2::Error)
45
- end
41
+ expect {
42
+ Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "big5"))
43
+ }.not_to raise_error
46
44
  end
47
45
 
48
46
  it "should accept connect flags and pass them to #connect" do
@@ -54,7 +52,7 @@ describe Mysql2::Client do
54
52
  end
55
53
  end
56
54
  client = klient.new :flags => Mysql2::Client::FOUND_ROWS
57
- (client.connect_args.last[6] & Mysql2::Client::FOUND_ROWS).should be_true
55
+ expect(client.connect_args.last[6] & Mysql2::Client::FOUND_ROWS).to be > 0
58
56
  end
59
57
 
60
58
  it "should default flags to (REMEMBER_OPTIONS, LONG_PASSWORD, LONG_FLAG, TRANSACTIONS, PROTOCOL_41, SECURE_CONNECTION)" do
@@ -66,12 +64,13 @@ describe Mysql2::Client do
66
64
  end
67
65
  end
68
66
  client = klient.new
69
- (client.connect_args.last[6] & (Mysql2::Client::REMEMBER_OPTIONS |
70
- Mysql2::Client::LONG_PASSWORD |
71
- Mysql2::Client::LONG_FLAG |
72
- Mysql2::Client::TRANSACTIONS |
73
- Mysql2::Client::PROTOCOL_41 |
74
- Mysql2::Client::SECURE_CONNECTION)).should be_true
67
+ client_flags = Mysql2::Client::REMEMBER_OPTIONS |
68
+ Mysql2::Client::LONG_PASSWORD |
69
+ Mysql2::Client::LONG_FLAG |
70
+ Mysql2::Client::TRANSACTIONS |
71
+ Mysql2::Client::PROTOCOL_41 |
72
+ Mysql2::Client::SECURE_CONNECTION
73
+ expect(client.connect_args.last[6]).to eql(client_flags)
75
74
  end
76
75
 
77
76
  it "should execute init command" do
@@ -79,7 +78,7 @@ describe Mysql2::Client do
79
78
  options[:init_command] = "SET @something = 'setting_value';"
80
79
  client = Mysql2::Client.new(options)
81
80
  result = client.query("SELECT @something;")
82
- result.first['@something'].should eq('setting_value')
81
+ expect(result.first['@something']).to eq('setting_value')
83
82
  end
84
83
 
85
84
  it "should send init_command after reconnect" do
@@ -89,17 +88,14 @@ describe Mysql2::Client do
89
88
  client = Mysql2::Client.new(options)
90
89
 
91
90
  result = client.query("SELECT @something;")
92
- result.first['@something'].should eq('setting_value')
91
+ expect(result.first['@something']).to eq('setting_value')
93
92
 
94
93
  # get the current connection id
95
94
  result = client.query("SELECT CONNECTION_ID()")
96
95
  first_conn_id = result.first['CONNECTION_ID()']
97
96
 
98
97
  # break the current connection
99
- begin
100
- client.query("KILL #{first_conn_id}")
101
- rescue Mysql2::Error
102
- end
98
+ expect { client.query("KILL #{first_conn_id}") }.to raise_error(Mysql2::Error)
103
99
 
104
100
  client.ping # reconnect now
105
101
 
@@ -108,15 +104,15 @@ describe Mysql2::Client do
108
104
  second_conn_id = result.first['CONNECTION_ID()']
109
105
 
110
106
  # confirm reconnect by checking the new connection id
111
- first_conn_id.should_not == second_conn_id
107
+ expect(first_conn_id).not_to eq(second_conn_id)
112
108
 
113
109
  # At last, check that the init command executed
114
110
  result = client.query("SELECT @something;")
115
- result.first['@something'].should eq('setting_value')
111
+ expect(result.first['@something']).to eq('setting_value')
116
112
  end
117
113
 
118
114
  it "should have a global default_query_options hash" do
119
- Mysql2::Client.should respond_to(:default_query_options)
115
+ expect(Mysql2::Client).to respond_to(:default_query_options)
120
116
  end
121
117
 
122
118
  it "should be able to connect via SSL options" do
@@ -128,7 +124,7 @@ describe Mysql2::Client do
128
124
 
129
125
  # You may need to adjust the lines below to match your SSL certificate paths
130
126
  ssl_client = nil
131
- lambda {
127
+ expect {
132
128
  ssl_client = Mysql2::Client.new(
133
129
  :sslkey => '/etc/mysql/client-key.pem',
134
130
  :sslcert => '/etc/mysql/client-cert.pem',
@@ -136,25 +132,34 @@ describe Mysql2::Client do
136
132
  :sslcapath => '/etc/mysql/',
137
133
  :sslcipher => 'DHE-RSA-AES256-SHA'
138
134
  )
139
- }.should_not raise_error(Mysql2::Error)
135
+ }.not_to raise_error
140
136
 
141
137
  results = ssl_client.query("SHOW STATUS WHERE Variable_name = \"Ssl_version\" OR Variable_name = \"Ssl_cipher\"").to_a
142
- results[0]['Variable_name'].should eql('Ssl_cipher')
143
- results[0]['Value'].should_not be_nil
144
- results[0]['Value'].should be_kind_of(String)
145
- results[0]['Value'].should_not be_empty
138
+ expect(results[0]['Variable_name']).to eql('Ssl_cipher')
139
+ expect(results[0]['Value']).not_to be_nil
140
+ expect(results[0]['Value']).to be_kind_of(String)
141
+ expect(results[0]['Value']).not_to be_empty
146
142
 
147
- results[1]['Variable_name'].should eql('Ssl_version')
148
- results[1]['Value'].should_not be_nil
149
- results[1]['Value'].should be_kind_of(String)
150
- results[1]['Value'].should_not be_empty
143
+ expect(results[1]['Variable_name']).to eql('Ssl_version')
144
+ expect(results[1]['Value']).not_to be_nil
145
+ expect(results[1]['Value']).to be_kind_of(String)
146
+ expect(results[1]['Value']).not_to be_empty
151
147
 
152
148
  ssl_client.close
153
149
  end
154
150
 
151
+ def run_gc
152
+ if defined?(Rubinius)
153
+ GC.run(true)
154
+ else
155
+ GC.start
156
+ end
157
+ sleep(0.5)
158
+ end
159
+
155
160
  it "should not leave dangling connections after garbage collection" do
156
- GC.start
157
- sleep 0.300 # Let GC do its work
161
+ run_gc
162
+
158
163
  client = Mysql2::Client.new(DatabaseCredentials['root'])
159
164
  before_count = client.query("SHOW STATUS LIKE 'Threads_connected'").first['Value'].to_i
160
165
 
@@ -162,69 +167,70 @@ describe Mysql2::Client do
162
167
  Mysql2::Client.new(DatabaseCredentials['root']).query('SELECT 1')
163
168
  end
164
169
  after_count = client.query("SHOW STATUS LIKE 'Threads_connected'").first['Value'].to_i
165
- after_count.should == before_count + 10
170
+ expect(after_count).to eq(before_count + 10)
166
171
 
167
- GC.start
168
- sleep 0.300 # Let GC do its work
172
+ run_gc
169
173
  final_count = client.query("SHOW STATUS LIKE 'Threads_connected'").first['Value'].to_i
170
- final_count.should == before_count
174
+ expect(final_count).to eq(before_count)
171
175
  end
172
176
 
173
- if Process.respond_to?(:fork)
174
- it "should not close connections when running in a child process" do
175
- GC.start
176
- sleep 1 if defined? Rubinius # Let the rbx GC thread do its work
177
- client = Mysql2::Client.new(DatabaseCredentials['root'])
178
-
179
- fork do
180
- client.query('SELECT 1')
181
- client = nil
182
- GC.start
183
- sleep 1 if defined? Rubinius # Let the rbx GC thread do its work
184
- end
177
+ it "should not close connections when running in a child process" do
178
+ pending("fork is not available on this platform") unless Process.respond_to?(:fork)
185
179
 
186
- Process.wait
180
+ run_gc
181
+ client = Mysql2::Client.new(DatabaseCredentials['root'])
187
182
 
188
- # this will throw an error if the underlying socket was shutdown by the
189
- # child's GC
190
- expect { client.query('SELECT 1') }.to_not raise_exception
183
+ # this empty `fork` call fixes this tests on RBX; without it, the next
184
+ # `fork` call hangs forever. WTF?
185
+ fork { }
186
+
187
+ fork do
188
+ client.query('SELECT 1')
189
+ client = nil
190
+ run_gc
191
191
  end
192
+
193
+ Process.wait
194
+
195
+ # this will throw an error if the underlying socket was shutdown by the
196
+ # child's GC
197
+ expect { client.query('SELECT 1') }.to_not raise_exception
192
198
  end
193
199
 
194
200
  it "should be able to connect to database with numeric-only name" do
195
- lambda {
196
- creds = DatabaseCredentials['numericuser']
197
- @client.query "CREATE DATABASE IF NOT EXISTS `#{creds['database']}`"
198
- @client.query "GRANT ALL ON `#{creds['database']}`.* TO #{creds['username']}@`#{creds['host']}`"
199
- client = Mysql2::Client.new creds
200
- @client.query "DROP DATABASE IF EXISTS `#{creds['database']}`"
201
- }.should_not raise_error
201
+ creds = DatabaseCredentials['numericuser']
202
+ @client.query "CREATE DATABASE IF NOT EXISTS `#{creds['database']}`"
203
+ @client.query "GRANT ALL ON `#{creds['database']}`.* TO #{creds['username']}@`#{creds['host']}`"
204
+
205
+ expect { Mysql2::Client.new(creds) }.not_to raise_error
206
+
207
+ @client.query "DROP DATABASE IF EXISTS `#{creds['database']}`"
202
208
  end
203
209
 
204
210
  it "should respond to #close" do
205
- @client.should respond_to(:close)
211
+ expect(@client).to respond_to(:close)
206
212
  end
207
213
 
208
214
  it "should be able to close properly" do
209
- @client.close.should be_nil
210
- lambda {
215
+ expect(@client.close).to be_nil
216
+ expect {
211
217
  @client.query "SELECT 1"
212
- }.should raise_error(Mysql2::Error)
218
+ }.to raise_error(Mysql2::Error)
213
219
  end
214
220
 
215
221
  it "should respond to #query" do
216
- @client.should respond_to(:query)
222
+ expect(@client).to respond_to(:query)
217
223
  end
218
224
 
219
225
  it "should respond to #warning_count" do
220
- @client.should respond_to(:warning_count)
226
+ expect(@client).to respond_to(:warning_count)
221
227
  end
222
228
 
223
229
  context "#warning_count" do
224
230
  context "when no warnings" do
225
231
  it "should 0" do
226
232
  @client.query('select 1')
227
- @client.warning_count.should == 0
233
+ expect(@client.warning_count).to eq(0)
228
234
  end
229
235
  end
230
236
  context "when has a warnings" do
@@ -232,21 +238,21 @@ describe Mysql2::Client do
232
238
  # "the statement produces extra information that can be viewed by issuing a SHOW WARNINGS"
233
239
  # http://dev.mysql.com/doc/refman/5.0/en/explain-extended.html
234
240
  @client.query("explain extended select 1")
235
- @client.warning_count.should > 0
241
+ expect(@client.warning_count).to be > 0
236
242
  end
237
243
  end
238
244
  end
239
245
 
240
246
  it "should respond to #query_info" do
241
- @client.should respond_to(:query_info)
247
+ expect(@client).to respond_to(:query_info)
242
248
  end
243
249
 
244
250
  context "#query_info" do
245
251
  context "when no info present" do
246
252
  it "should 0" do
247
253
  @client.query('select 1')
248
- @client.query_info.should be_empty
249
- @client.query_info_string.should be_nil
254
+ expect(@client.query_info).to be_empty
255
+ expect(@client.query_info_string).to be_nil
250
256
  end
251
257
  end
252
258
  context "when has some info" do
@@ -258,8 +264,8 @@ describe Mysql2::Client do
258
264
  # # 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).
259
265
  @client.query("INSERT INTO infoTest (blah) VALUES (1234),(4535)")
260
266
 
261
- @client.query_info.should eql({:records => 2, :duplicates => 0, :warnings => 0})
262
- @client.query_info_string.should eq('Records: 2 Duplicates: 0 Warnings: 0')
267
+ expect(@client.query_info).to eql({:records => 2, :duplicates => 0, :warnings => 0})
268
+ expect(@client.query_info_string).to eq('Records: 2 Duplicates: 0 Warnings: 0')
263
269
 
264
270
  @client.query "DROP TABLE infoTest"
265
271
  end
@@ -288,43 +294,43 @@ describe Mysql2::Client do
288
294
 
289
295
  it "should raise an error when local_infile is disabled" do
290
296
  client = Mysql2::Client.new DatabaseCredentials['root'].merge(:local_infile => false)
291
- lambda {
297
+ expect {
292
298
  client.query "LOAD DATA LOCAL INFILE 'spec/test_data' INTO TABLE infileTest"
293
- }.should raise_error(Mysql2::Error, %r{command is not allowed})
299
+ }.to raise_error(Mysql2::Error, /command is not allowed/)
294
300
  end
295
301
 
296
302
  it "should raise an error when a non-existent file is loaded" do
297
- lambda {
303
+ expect {
298
304
  @client_i.query "LOAD DATA LOCAL INFILE 'this/file/is/not/here' INTO TABLE infileTest"
299
- }.should_not raise_error(Mysql2::Error, %r{file not found: this/file/is/not/here})
305
+ }.to raise_error(Mysql2::Error, 'No such file or directory: this/file/is/not/here')
300
306
  end
301
307
 
302
308
  it "should LOAD DATA LOCAL INFILE" do
303
309
  @client_i.query "LOAD DATA LOCAL INFILE 'spec/test_data' INTO TABLE infileTest"
304
310
  info = @client_i.query_info
305
- info.should eql({:records => 1, :deleted => 0, :skipped => 0, :warnings => 0})
311
+ expect(info).to eql({:records => 1, :deleted => 0, :skipped => 0, :warnings => 0})
306
312
 
307
313
  result = @client_i.query "SELECT * FROM infileTest"
308
- result.first.should eql({'id' => 1, 'foo' => 'Hello', 'bar' => 'World'})
314
+ expect(result.first).to eql({'id' => 1, 'foo' => 'Hello', 'bar' => 'World'})
309
315
  end
310
316
  end
311
317
 
312
318
  it "should expect connect_timeout to be a positive integer" do
313
- lambda {
319
+ expect {
314
320
  Mysql2::Client.new(:connect_timeout => -1)
315
- }.should raise_error(Mysql2::Error)
321
+ }.to raise_error(Mysql2::Error)
316
322
  end
317
323
 
318
324
  it "should expect read_timeout to be a positive integer" do
319
- lambda {
325
+ expect {
320
326
  Mysql2::Client.new(:read_timeout => -1)
321
- }.should raise_error(Mysql2::Error)
327
+ }.to raise_error(Mysql2::Error)
322
328
  end
323
329
 
324
330
  it "should expect write_timeout to be a positive integer" do
325
- lambda {
331
+ expect {
326
332
  Mysql2::Client.new(:write_timeout => -1)
327
- }.should raise_error(Mysql2::Error)
333
+ }.to raise_error(Mysql2::Error)
328
334
  end
329
335
 
330
336
  context "#query" do
@@ -333,7 +339,7 @@ describe Mysql2::Client do
333
339
 
334
340
  expect {
335
341
  @client.query("SELECT 1 UNION SELECT 2", :stream => true, :cache_rows => false)
336
- }.to_not raise_exception(Mysql2::Error)
342
+ }.to_not raise_error
337
343
  end
338
344
 
339
345
  it "should not let you query again if iterating is not finished when streaming" do
@@ -345,200 +351,182 @@ describe Mysql2::Client do
345
351
  end
346
352
 
347
353
  it "should only accept strings as the query parameter" do
348
- lambda {
354
+ expect {
349
355
  @client.query ["SELECT 'not right'"]
350
- }.should raise_error(TypeError)
356
+ }.to raise_error(TypeError)
351
357
  end
352
358
 
353
359
  it "should not retain query options set on a query for subsequent queries, but should retain it in the result" do
354
360
  result = @client.query "SELECT 1", :something => :else
355
- @client.query_options[:something].should be_nil
356
- result.instance_variable_get('@query_options').should eql(@client.query_options.merge(:something => :else))
357
- @client.instance_variable_get('@current_query_options').should eql(@client.query_options.merge(:something => :else))
361
+ expect(@client.query_options[:something]).to be_nil
362
+ expect(result.instance_variable_get('@query_options')).to eql(@client.query_options.merge(:something => :else))
363
+ expect(@client.instance_variable_get('@current_query_options')).to eql(@client.query_options.merge(:something => :else))
358
364
 
359
365
  result = @client.query "SELECT 1"
360
- result.instance_variable_get('@query_options').should eql(@client.query_options)
361
- @client.instance_variable_get('@current_query_options').should eql(@client.query_options)
366
+ expect(result.instance_variable_get('@query_options')).to eql(@client.query_options)
367
+ expect(@client.instance_variable_get('@current_query_options')).to eql(@client.query_options)
362
368
  end
363
369
 
364
370
  it "should allow changing query options for subsequent queries" do
365
371
  @client.query_options.merge!(:something => :else)
366
372
  result = @client.query "SELECT 1"
367
- @client.query_options[:something].should eql(:else)
368
- result.instance_variable_get('@query_options')[:something].should eql(:else)
373
+ expect(@client.query_options[:something]).to eql(:else)
374
+ expect(result.instance_variable_get('@query_options')[:something]).to eql(:else)
369
375
 
370
376
  # Clean up after this test
371
377
  @client.query_options.delete(:something)
372
- @client.query_options[:something].should be_nil
378
+ expect(@client.query_options[:something]).to be_nil
373
379
  end
374
380
 
375
381
  it "should return results as a hash by default" do
376
- @client.query("SELECT 1").first.class.should eql(Hash)
382
+ expect(@client.query("SELECT 1").first.class).to eql(Hash)
377
383
  end
378
384
 
379
385
  it "should be able to return results as an array" do
380
- @client.query("SELECT 1", :as => :array).first.class.should eql(Array)
386
+ expect(@client.query("SELECT 1", :as => :array).first.class).to eql(Array)
381
387
  @client.query("SELECT 1").each(:as => :array)
382
388
  end
383
389
 
384
390
  it "should be able to return results with symbolized keys" do
385
- @client.query("SELECT 1", :symbolize_keys => true).first.keys[0].class.should eql(Symbol)
391
+ expect(@client.query("SELECT 1", :symbolize_keys => true).first.keys[0].class).to eql(Symbol)
386
392
  end
387
393
 
388
394
  it "should require an open connection" do
389
395
  @client.close
390
- lambda {
396
+ expect {
391
397
  @client.query "SELECT 1"
392
- }.should raise_error(Mysql2::Error)
398
+ }.to raise_error(Mysql2::Error)
393
399
  end
394
400
 
395
401
  if RUBY_PLATFORM !~ /mingw|mswin/
396
402
  it "should not allow another query to be sent without fetching a result first" do
397
403
  @client.query("SELECT 1", :async => true)
398
- lambda {
404
+ expect {
399
405
  @client.query("SELECT 1")
400
- }.should raise_error(Mysql2::Error)
406
+ }.to raise_error(Mysql2::Error)
401
407
  end
402
408
 
403
409
  it "should describe the thread holding the active query" do
404
410
  thr = Thread.new { @client.query("SELECT 1", :async => true) }
405
411
 
406
412
  thr.join
407
- begin
408
- @client.query("SELECT 1")
409
- rescue Mysql2::Error => e
410
- message = e.message
411
- end
412
- re = Regexp.escape(thr.inspect)
413
- message.should match(Regexp.new(re))
413
+ expect { @client.query('SELECT 1') }.to raise_error(Mysql2::Error, Regexp.new(Regexp.escape(thr.inspect)))
414
414
  end
415
415
 
416
416
  it "should timeout if we wait longer than :read_timeout" do
417
- client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:read_timeout => 1))
418
- lambda {
419
- client.query("SELECT sleep(2)")
420
- }.should raise_error(Mysql2::Error)
417
+ client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:read_timeout => 0))
418
+ expect {
419
+ client.query('SELECT SLEEP(0.1)')
420
+ }.to raise_error(Mysql2::Error)
421
421
  end
422
422
 
423
- if !defined? Rubinius
424
- # XXX this test is not deterministic (because Unix signal handling is not)
425
- # and may fail on a loaded system
426
- it "should run signal handlers while waiting for a response" do
427
- mark = {}
428
- trap(:USR1) { mark[:USR1] = Time.now }
429
- begin
430
- mark[:START] = Time.now
431
- pid = fork do
432
- sleep 1 # wait for client "SELECT sleep(2)" query to start
433
- Process.kill(:USR1, Process.ppid)
434
- sleep # wait for explicit kill to prevent GC disconnect
435
- end
436
- @client.query("SELECT sleep(2)")
437
- mark[:END] = Time.now
438
- mark.include?(:USR1).should be_true
439
- (mark[:USR1] - mark[:START]).should >= 1
440
- (mark[:USR1] - mark[:START]).should < 1.3
441
- (mark[:END] - mark[:USR1]).should > 0.9
442
- (mark[:END] - mark[:START]).should >= 2
443
- (mark[:END] - mark[:START]).should < 2.3
444
- Process.kill(:TERM, pid)
445
- Process.waitpid2(pid)
446
- ensure
447
- trap(:USR1, 'DEFAULT')
423
+ # XXX this test is not deterministic (because Unix signal handling is not)
424
+ # and may fail on a loaded system
425
+ it "should run signal handlers while waiting for a response" do
426
+ kill_time = 0.1
427
+ query_time = 2 * kill_time
428
+
429
+ mark = {}
430
+
431
+ begin
432
+ trap(:USR1) { mark.store(:USR1, Time.now) }
433
+ pid = fork do
434
+ sleep kill_time # wait for client query to start
435
+ Process.kill(:USR1, Process.ppid)
436
+ sleep # wait for explicit kill to prevent GC disconnect
448
437
  end
438
+ mark.store(:QUERY_START, Time.now)
439
+ @client.query("SELECT SLEEP(#{query_time})")
440
+ mark.store(:QUERY_END, Time.now)
441
+ ensure
442
+ Process.kill(:TERM, pid)
443
+ Process.waitpid2(pid)
444
+ trap(:USR1, 'DEFAULT')
449
445
  end
446
+
447
+ # the query ran uninterrupted
448
+ expect(mark.fetch(:QUERY_END) - mark.fetch(:QUERY_START)).to be_within(0.02).of(query_time)
449
+ # signals fired while the query was running
450
+ expect(mark.fetch(:USR1)).to be_between(mark.fetch(:QUERY_START), mark.fetch(:QUERY_END))
450
451
  end
451
452
 
452
453
  it "#socket should return a Fixnum (file descriptor from C)" do
453
- @client.socket.class.should eql(Fixnum)
454
- @client.socket.should_not eql(0)
454
+ expect(@client.socket.class).to eql(Fixnum)
455
+ expect(@client.socket).not_to eql(0)
455
456
  end
456
457
 
457
458
  it "#socket should require an open connection" do
458
459
  @client.close
459
- lambda {
460
+ expect {
460
461
  @client.socket
461
- }.should raise_error(Mysql2::Error)
462
+ }.to raise_error(Mysql2::Error)
462
463
  end
463
464
 
464
- it "should close the connection when an exception is raised" do
465
- begin
466
- Timeout.timeout(1, Timeout::Error) do
467
- @client.query("SELECT sleep(2)")
468
- end
469
- rescue Timeout::Error
470
- end
465
+ it 'should be impervious to connection-corrupting timeouts ' do
466
+ pending('`Thread.handle_interrupt` is not defined') unless Thread.respond_to?(:handle_interrupt)
467
+ # attempt to break the connection
468
+ expect { Timeout.timeout(0.1) { @client.query('SELECT SLEEP(0.2)') } }.to raise_error(Timeout::Error)
471
469
 
472
- lambda {
473
- @client.query("SELECT 1")
474
- }.should raise_error(Mysql2::Error, 'closed MySQL connection')
470
+ # expect the connection to not be broken
471
+ expect { @client.query('SELECT 1') }.to_not raise_error
475
472
  end
476
473
 
477
- it "should handle Timeouts without leaving the connection hanging if reconnect is true" do
478
- client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:reconnect => true))
479
- begin
480
- Timeout.timeout(1, Timeout::Error) do
481
- client.query("SELECT sleep(2)")
482
- end
483
- rescue Timeout::Error
474
+ context 'when a non-standard exception class is raised' do
475
+ it "should close the connection when an exception is raised" do
476
+ expect { Timeout.timeout(0.1, ArgumentError) { @client.query('SELECT SLEEP(1)') } }.to raise_error(ArgumentError)
477
+ expect { @client.query('SELECT 1') }.to raise_error(Mysql2::Error, 'closed MySQL connection')
484
478
  end
485
479
 
486
- lambda {
487
- client.query("SELECT 1")
488
- }.should_not raise_error(Mysql2::Error)
489
- end
490
-
491
- it "should handle Timeouts without leaving the connection hanging if reconnect is set to true after construction true" do
492
- client = Mysql2::Client.new(DatabaseCredentials['root'])
493
- begin
494
- Timeout.timeout(1, Timeout::Error) do
495
- client.query("SELECT sleep(2)")
480
+ it "should handle Timeouts without leaving the connection hanging if reconnect is true" do
481
+ if RUBY_PLATFORM.include?('darwin') && Mysql2::Client.info.fetch(:version).start_with?('5.5')
482
+ pending('libmysqlclient 5.5 on OSX is afflicted by an unknown bug that breaks this test. See #633 and #634.')
496
483
  end
497
- rescue Timeout::Error
498
- end
499
484
 
500
- lambda {
501
- client.query("SELECT 1")
502
- }.should raise_error(Mysql2::Error)
485
+ client = Mysql2::Client.new(DatabaseCredentials['root'].merge(:reconnect => true))
503
486
 
504
- client.reconnect = true
487
+ expect { Timeout.timeout(0.1, ArgumentError) { client.query('SELECT SLEEP(1)') } }.to raise_error(ArgumentError)
488
+ expect { client.query('SELECT 1') }.to_not raise_error
489
+ end
505
490
 
506
- begin
507
- Timeout.timeout(1, Timeout::Error) do
508
- client.query("SELECT sleep(2)")
491
+ it "should handle Timeouts without leaving the connection hanging if reconnect is set to true after construction" do
492
+ if RUBY_PLATFORM.include?('darwin') && Mysql2::Client.info.fetch(:version).start_with?('5.5')
493
+ pending('libmysqlclient 5.5 on OSX is afflicted by an unknown bug that breaks this test. See #633 and #634.')
509
494
  end
510
- rescue Timeout::Error
511
- end
512
495
 
513
- lambda {
514
- client.query("SELECT 1")
515
- }.should_not raise_error(Mysql2::Error)
496
+ client = Mysql2::Client.new(DatabaseCredentials['root'])
497
+
498
+ expect { Timeout.timeout(0.1, ArgumentError) { client.query('SELECT SLEEP(1)') } }.to raise_error(ArgumentError)
499
+ expect { client.query('SELECT 1') }.to raise_error(Mysql2::Error)
516
500
 
501
+ client.reconnect = true
502
+
503
+ expect { Timeout.timeout(0.1, ArgumentError) { client.query('SELECT SLEEP(1)') } }.to raise_error(ArgumentError)
504
+ expect { client.query('SELECT 1') }.to_not raise_error
505
+ end
517
506
  end
518
507
 
519
508
  it "threaded queries should be supported" do
520
- threads, results = [], {}
521
- lock = Mutex.new
522
- connect = lambda{
523
- Mysql2::Client.new(DatabaseCredentials['root'])
524
- }
525
- Timeout.timeout(0.7) do
526
- 5.times {
527
- threads << Thread.new do
528
- result = connect.call.query("SELECT sleep(0.5) as result")
529
- lock.synchronize do
530
- results[Thread.current.object_id] = result
531
- end
532
- end
533
- }
509
+ sleep_time = 0.5
510
+
511
+ # Note that each thread opens its own database connection
512
+ threads = 5.times.map do
513
+ Thread.new do
514
+ client = Mysql2::Client.new(DatabaseCredentials.fetch('root'))
515
+ client.query("SELECT SLEEP(#{sleep_time})")
516
+ Thread.current.object_id
517
+ end
534
518
  end
535
- threads.each{|t| t.join }
536
- results.keys.sort.should eql(threads.map{|t| t.object_id }.sort)
519
+
520
+ # This timeout demonstrates that the threads are sleeping concurrently:
521
+ # In the serial case, the timeout would fire and the test would fail
522
+ values = Timeout.timeout(sleep_time * 1.1) { threads.map(&:value) }
523
+
524
+ expect(values).to match_array(threads.map(&:object_id))
537
525
  end
538
526
 
539
527
  it "evented async queries should be supported" do
540
528
  # should immediately return nil
541
- @client.query("SELECT sleep(0.1)", :async => true).should eql(nil)
529
+ expect(@client.query("SELECT sleep(0.1)", :async => true)).to eql(nil)
542
530
 
543
531
  io_wrapper = IO.for_fd(@client.socket)
544
532
  loops = 0
@@ -551,10 +539,10 @@ describe Mysql2::Client do
551
539
  end
552
540
 
553
541
  # make sure we waited some period of time
554
- (loops >= 1).should be_true
542
+ expect(loops >= 1).to be true
555
543
 
556
544
  result = @client.async_result
557
- result.class.should eql(Mysql2::Result)
545
+ expect(result.class).to eql(Mysql2::Result)
558
546
  end
559
547
  end
560
548
 
@@ -565,20 +553,20 @@ describe Mysql2::Client do
565
553
 
566
554
  it "should raise an exception when one of multiple statements fails" do
567
555
  result = @multi_client.query("SELECT 1 AS 'set_1'; SELECT * FROM invalid_table_name; SELECT 2 AS 'set_2';")
568
- result.first['set_1'].should be(1)
569
- lambda {
556
+ expect(result.first['set_1']).to be(1)
557
+ expect {
570
558
  @multi_client.next_result
571
- }.should raise_error(Mysql2::Error)
572
- @multi_client.next_result.should be_false
559
+ }.to raise_error(Mysql2::Error)
560
+ expect(@multi_client.next_result).to be false
573
561
  end
574
562
 
575
563
  it "returns multiple result sets" do
576
- @multi_client.query("SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'").first.should eql({ 'set_1' => 1 })
564
+ expect(@multi_client.query("SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'").first).to eql({ 'set_1' => 1 })
577
565
 
578
- @multi_client.next_result.should be_true
579
- @multi_client.store_result.first.should eql({ 'set_2' => 2 })
566
+ expect(@multi_client.next_result).to be true
567
+ expect(@multi_client.store_result.first).to eql({ 'set_2' => 2 })
580
568
 
581
- @multi_client.next_result.should be_false
569
+ expect(@multi_client.next_result).to be false
582
570
  end
583
571
 
584
572
  it "does not interfere with other statements" do
@@ -587,208 +575,231 @@ describe Mysql2::Client do
587
575
  @multi_client.store_result
588
576
  end
589
577
 
590
- @multi_client.query("SELECT 3 AS 'next'").first.should == { 'next' => 3 }
578
+ expect(@multi_client.query("SELECT 3 AS 'next'").first).to eq({ 'next' => 3 })
591
579
  end
592
580
 
593
581
  it "will raise on query if there are outstanding results to read" do
594
582
  @multi_client.query("SELECT 1; SELECT 2; SELECT 3")
595
- lambda {
583
+ expect {
596
584
  @multi_client.query("SELECT 4")
597
- }.should raise_error(Mysql2::Error)
585
+ }.to raise_error(Mysql2::Error)
598
586
  end
599
587
 
600
588
  it "#abandon_results! should work" do
601
589
  @multi_client.query("SELECT 1; SELECT 2; SELECT 3")
602
590
  @multi_client.abandon_results!
603
- lambda {
591
+ expect {
604
592
  @multi_client.query("SELECT 4")
605
- }.should_not raise_error(Mysql2::Error)
593
+ }.not_to raise_error
606
594
  end
607
595
 
608
596
  it "#more_results? should work" do
609
597
  @multi_client.query("SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'")
610
- @multi_client.more_results?.should be_true
598
+ expect(@multi_client.more_results?).to be true
611
599
 
612
600
  @multi_client.next_result
613
601
  @multi_client.store_result
614
602
 
615
- @multi_client.more_results?.should be_false
603
+ expect(@multi_client.more_results?).to be false
604
+ end
605
+
606
+ it "#more_results? should work with stored procedures" do
607
+ @multi_client.query("DROP PROCEDURE IF EXISTS test_proc")
608
+ @multi_client.query("CREATE PROCEDURE test_proc() BEGIN SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'; END")
609
+ expect(@multi_client.query("CALL test_proc()").first).to eql({ 'set_1' => 1 })
610
+ expect(@multi_client.more_results?).to be true
611
+
612
+ @multi_client.next_result
613
+ expect(@multi_client.store_result.first).to eql({ 'set_2' => 2 })
614
+
615
+ @multi_client.next_result
616
+ expect(@multi_client.store_result).to be_nil # this is the result from CALL itself
617
+
618
+ expect(@multi_client.more_results?).to be false
616
619
  end
617
620
  end
618
621
  end
619
622
 
620
623
  it "should respond to #socket" do
621
- @client.should respond_to(:socket)
624
+ expect(@client).to respond_to(:socket)
622
625
  end
623
626
 
624
627
  if RUBY_PLATFORM =~ /mingw|mswin/
625
628
  it "#socket should raise as it's not supported" do
626
- lambda {
629
+ expect {
627
630
  @client.socket
628
- }.should raise_error(Mysql2::Error)
631
+ }.to raise_error(Mysql2::Error)
629
632
  end
630
633
  end
631
634
 
632
635
  it "should respond to escape" do
633
- Mysql2::Client.should respond_to(:escape)
636
+ expect(Mysql2::Client).to respond_to(:escape)
634
637
  end
635
638
 
636
639
  context "escape" do
637
640
  it "should return a new SQL-escape version of the passed string" do
638
- Mysql2::Client.escape("abc'def\"ghi\0jkl%mno").should eql("abc\\'def\\\"ghi\\0jkl%mno")
641
+ expect(Mysql2::Client.escape("abc'def\"ghi\0jkl%mno")).to eql("abc\\'def\\\"ghi\\0jkl%mno")
639
642
  end
640
643
 
641
644
  it "should return the passed string if nothing was escaped" do
642
645
  str = "plain"
643
- Mysql2::Client.escape(str).object_id.should eql(str.object_id)
646
+ expect(Mysql2::Client.escape(str).object_id).to eql(str.object_id)
644
647
  end
645
648
 
646
649
  it "should not overflow the thread stack" do
647
- lambda {
650
+ expect {
648
651
  Thread.new { Mysql2::Client.escape("'" * 256 * 1024) }.join
649
- }.should_not raise_error(SystemStackError)
652
+ }.not_to raise_error
650
653
  end
651
654
 
652
655
  it "should not overflow the process stack" do
653
- lambda {
656
+ expect {
654
657
  Thread.new { Mysql2::Client.escape("'" * 1024 * 1024 * 4) }.join
655
- }.should_not raise_error(SystemStackError)
658
+ }.not_to raise_error
656
659
  end
657
660
 
658
661
  unless RUBY_VERSION =~ /1.8/
659
662
  it "should carry over the original string's encoding" do
660
663
  str = "abc'def\"ghi\0jkl%mno"
661
664
  escaped = Mysql2::Client.escape(str)
662
- escaped.encoding.should eql(str.encoding)
665
+ expect(escaped.encoding).to eql(str.encoding)
663
666
 
664
667
  str.encode!('us-ascii')
665
668
  escaped = Mysql2::Client.escape(str)
666
- escaped.encoding.should eql(str.encoding)
669
+ expect(escaped.encoding).to eql(str.encoding)
667
670
  end
668
671
  end
669
672
  end
670
673
 
671
674
  it "should respond to #escape" do
672
- @client.should respond_to(:escape)
675
+ expect(@client).to respond_to(:escape)
673
676
  end
674
677
 
675
678
  context "#escape" do
676
679
  it "should return a new SQL-escape version of the passed string" do
677
- @client.escape("abc'def\"ghi\0jkl%mno").should eql("abc\\'def\\\"ghi\\0jkl%mno")
680
+ expect(@client.escape("abc'def\"ghi\0jkl%mno")).to eql("abc\\'def\\\"ghi\\0jkl%mno")
678
681
  end
679
682
 
680
683
  it "should return the passed string if nothing was escaped" do
681
684
  str = "plain"
682
- @client.escape(str).object_id.should eql(str.object_id)
685
+ expect(@client.escape(str).object_id).to eql(str.object_id)
683
686
  end
684
687
 
685
688
  it "should not overflow the thread stack" do
686
- lambda {
689
+ expect {
687
690
  Thread.new { @client.escape("'" * 256 * 1024) }.join
688
- }.should_not raise_error(SystemStackError)
691
+ }.not_to raise_error
689
692
  end
690
693
 
691
694
  it "should not overflow the process stack" do
692
- lambda {
695
+ expect {
693
696
  Thread.new { @client.escape("'" * 1024 * 1024 * 4) }.join
694
- }.should_not raise_error(SystemStackError)
697
+ }.not_to raise_error
695
698
  end
696
699
 
697
700
  it "should require an open connection" do
698
701
  @client.close
699
- lambda {
702
+ expect {
700
703
  @client.escape ""
701
- }.should raise_error(Mysql2::Error)
704
+ }.to raise_error(Mysql2::Error)
705
+ end
706
+
707
+ context 'when mysql encoding is not utf8' do
708
+ before { pending('Encoding is undefined') unless defined?(Encoding) }
709
+
710
+ let(:client) { Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "ujis")) }
711
+
712
+ it 'should return a internal encoding string if Encoding.default_internal is set' do
713
+ with_internal_encoding Encoding::UTF_8 do
714
+ expect(client.escape("\u{30C6}\u{30B9}\u{30C8}")).to eq "\u{30C6}\u{30B9}\u{30C8}"
715
+ expect(client.escape("\u{30C6}'\u{30B9}\"\u{30C8}")).to eq "\u{30C6}\\'\u{30B9}\\\"\u{30C8}"
716
+ end
717
+ end
702
718
  end
703
719
  end
704
720
 
705
721
  it "should respond to #info" do
706
- @client.should respond_to(:info)
722
+ expect(@client).to respond_to(:info)
707
723
  end
708
724
 
709
725
  it "#info should return a hash containing the client version ID and String" do
710
726
  info = @client.info
711
- info.class.should eql(Hash)
712
- info.should have_key(:id)
713
- info[:id].class.should eql(Fixnum)
714
- info.should have_key(:version)
715
- info[:version].class.should eql(String)
727
+ expect(info.class).to eql(Hash)
728
+ expect(info).to have_key(:id)
729
+ expect(info[:id].class).to eql(Fixnum)
730
+ expect(info).to have_key(:version)
731
+ expect(info[:version].class).to eql(String)
716
732
  end
717
733
 
718
- if defined? Encoding
719
- context "strings returned by #info" do
720
- it "should default to the connection's encoding if Encoding.default_internal is nil" do
721
- with_internal_encoding nil do
722
- @client.info[:version].encoding.should eql(Encoding.find('utf-8'))
734
+ context "strings returned by #info" do
735
+ before { pending('Encoding is undefined') unless defined?(Encoding) }
723
736
 
724
- client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
725
- client2.info[:version].encoding.should eql(Encoding.find('us-ascii'))
726
- end
727
- end
737
+ it "should be tagged as ascii" do
738
+ expect(@client.info[:version].encoding).to eql(Encoding::US_ASCII)
739
+ expect(@client.info[:header_version].encoding).to eql(Encoding::US_ASCII)
740
+ end
741
+ end
728
742
 
729
- it "should use Encoding.default_internal" do
730
- with_internal_encoding 'utf-8' do
731
- @client.info[:version].encoding.should eql(Encoding.default_internal)
732
- end
743
+ context "strings returned by .info" do
744
+ before { pending('Encoding is undefined') unless defined?(Encoding) }
733
745
 
734
- with_internal_encoding 'us-ascii' do
735
- @client.info[:version].encoding.should eql(Encoding.default_internal)
736
- end
737
- end
746
+ it "should be tagged as ascii" do
747
+ expect(Mysql2::Client.info[:version].encoding).to eql(Encoding::US_ASCII)
748
+ expect(Mysql2::Client.info[:header_version].encoding).to eql(Encoding::US_ASCII)
738
749
  end
739
750
  end
740
751
 
741
752
  it "should respond to #server_info" do
742
- @client.should respond_to(:server_info)
753
+ expect(@client).to respond_to(:server_info)
743
754
  end
744
755
 
745
756
  it "#server_info should return a hash containing the client version ID and String" do
746
757
  server_info = @client.server_info
747
- server_info.class.should eql(Hash)
748
- server_info.should have_key(:id)
749
- server_info[:id].class.should eql(Fixnum)
750
- server_info.should have_key(:version)
751
- server_info[:version].class.should eql(String)
758
+ expect(server_info.class).to eql(Hash)
759
+ expect(server_info).to have_key(:id)
760
+ expect(server_info[:id].class).to eql(Fixnum)
761
+ expect(server_info).to have_key(:version)
762
+ expect(server_info[:version].class).to eql(String)
752
763
  end
753
764
 
754
765
  it "#server_info should require an open connection" do
755
766
  @client.close
756
- lambda {
767
+ expect {
757
768
  @client.server_info
758
- }.should raise_error(Mysql2::Error)
769
+ }.to raise_error(Mysql2::Error)
759
770
  end
760
771
 
761
- if defined? Encoding
762
- context "strings returned by #server_info" do
763
- it "should default to the connection's encoding if Encoding.default_internal is nil" do
764
- with_internal_encoding nil do
765
- @client.server_info[:version].encoding.should eql(Encoding.find('utf-8'))
772
+ context "strings returned by #server_info" do
773
+ before { pending('Encoding is undefined') unless defined?(Encoding) }
766
774
 
767
- client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
768
- client2.server_info[:version].encoding.should eql(Encoding.find('us-ascii'))
769
- end
775
+ it "should default to the connection's encoding if Encoding.default_internal is nil" do
776
+ with_internal_encoding nil do
777
+ expect(@client.server_info[:version].encoding).to eql(Encoding::UTF_8)
778
+
779
+ client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
780
+ expect(client2.server_info[:version].encoding).to eql(Encoding::ASCII)
770
781
  end
782
+ end
771
783
 
772
- it "should use Encoding.default_internal" do
773
- with_internal_encoding 'utf-8' do
774
- @client.server_info[:version].encoding.should eql(Encoding.default_internal)
775
- end
784
+ it "should use Encoding.default_internal" do
785
+ with_internal_encoding Encoding::UTF_8 do
786
+ expect(@client.server_info[:version].encoding).to eql(Encoding.default_internal)
787
+ end
776
788
 
777
- with_internal_encoding 'us-ascii' do
778
- @client.server_info[:version].encoding.should eql(Encoding.default_internal)
779
- end
789
+ with_internal_encoding Encoding::ASCII do
790
+ expect(@client.server_info[:version].encoding).to eql(Encoding.default_internal)
780
791
  end
781
792
  end
782
793
  end
783
794
 
784
795
  it "should raise a Mysql2::Error exception upon connection failure" do
785
- lambda {
796
+ expect {
786
797
  Mysql2::Client.new :host => "localhost", :username => 'asdfasdf8d2h', :password => 'asdfasdfw42'
787
- }.should raise_error(Mysql2::Error)
798
+ }.to raise_error(Mysql2::Error)
788
799
 
789
- lambda {
800
+ expect {
790
801
  Mysql2::Client.new DatabaseCredentials['root']
791
- }.should_not raise_error(Mysql2::Error)
802
+ }.not_to raise_error
792
803
  end
793
804
 
794
805
  context 'write operations api' do
@@ -802,46 +813,46 @@ describe Mysql2::Client do
802
813
  end
803
814
 
804
815
  it "should respond to #last_id" do
805
- @client.should respond_to(:last_id)
816
+ expect(@client).to respond_to(:last_id)
806
817
  end
807
818
 
808
819
  it "#last_id should return a Fixnum, the from the last INSERT/UPDATE" do
809
- @client.last_id.should eql(0)
820
+ expect(@client.last_id).to eql(0)
810
821
  @client.query "INSERT INTO lastIdTest (blah) VALUES (1234)"
811
- @client.last_id.should eql(1)
822
+ expect(@client.last_id).to eql(1)
812
823
  end
813
824
 
814
825
  it "should respond to #last_id" do
815
- @client.should respond_to(:last_id)
826
+ expect(@client).to respond_to(:last_id)
816
827
  end
817
828
 
818
829
  it "#last_id should return a Fixnum, the from the last INSERT/UPDATE" do
819
830
  @client.query "INSERT INTO lastIdTest (blah) VALUES (1234)"
820
- @client.affected_rows.should eql(1)
831
+ expect(@client.affected_rows).to eql(1)
821
832
  @client.query "UPDATE lastIdTest SET blah=4321 WHERE id=1"
822
- @client.affected_rows.should eql(1)
833
+ expect(@client.affected_rows).to eql(1)
823
834
  end
824
835
 
825
836
  it "#last_id should handle BIGINT auto-increment ids above 32 bits" do
826
837
  # The id column type must be BIGINT. Surprise: INT(x) is limited to 32-bits for all values of x.
827
838
  # Insert a row with a given ID, this should raise the auto-increment state
828
839
  @client.query "INSERT INTO lastIdTest (id, blah) VALUES (5000000000, 5000)"
829
- @client.last_id.should eql(5000000000)
840
+ expect(@client.last_id).to eql(5000000000)
830
841
  @client.query "INSERT INTO lastIdTest (blah) VALUES (5001)"
831
- @client.last_id.should eql(5000000001)
842
+ expect(@client.last_id).to eql(5000000001)
832
843
  end
833
844
  end
834
845
 
835
846
  it "should respond to #thread_id" do
836
- @client.should respond_to(:thread_id)
847
+ expect(@client).to respond_to(:thread_id)
837
848
  end
838
849
 
839
850
  it "#thread_id should be a Fixnum" do
840
- @client.thread_id.class.should eql(Fixnum)
851
+ expect(@client.thread_id.class).to eql(Fixnum)
841
852
  end
842
853
 
843
854
  it "should respond to #ping" do
844
- @client.should respond_to(:ping)
855
+ expect(@client).to respond_to(:ping)
845
856
  end
846
857
 
847
858
  context "select_db" do
@@ -860,38 +871,38 @@ describe Mysql2::Client do
860
871
  end
861
872
 
862
873
  it "should respond to #select_db" do
863
- @client.should respond_to(:select_db)
874
+ expect(@client).to respond_to(:select_db)
864
875
  end
865
876
 
866
877
  it "should switch databases" do
867
878
  @client.select_db("test_selectdb_0")
868
- @client.query("SHOW TABLES").first.values.first.should eql("test0")
879
+ expect(@client.query("SHOW TABLES").first.values.first).to eql("test0")
869
880
  @client.select_db("test_selectdb_1")
870
- @client.query("SHOW TABLES").first.values.first.should eql("test1")
881
+ expect(@client.query("SHOW TABLES").first.values.first).to eql("test1")
871
882
  @client.select_db("test_selectdb_0")
872
- @client.query("SHOW TABLES").first.values.first.should eql("test0")
883
+ expect(@client.query("SHOW TABLES").first.values.first).to eql("test0")
873
884
  end
874
885
 
875
886
  it "should raise a Mysql2::Error when the database doesn't exist" do
876
- lambda {
887
+ expect {
877
888
  @client.select_db("nopenothere")
878
- }.should raise_error(Mysql2::Error)
889
+ }.to raise_error(Mysql2::Error)
879
890
  end
880
891
 
881
892
  it "should return the database switched to" do
882
- @client.select_db("test_selectdb_1").should eq("test_selectdb_1")
893
+ expect(@client.select_db("test_selectdb_1")).to eq("test_selectdb_1")
883
894
  end
884
895
  end
885
896
 
886
897
  it "#thread_id should return a boolean" do
887
- @client.ping.should eql(true)
898
+ expect(@client.ping).to eql(true)
888
899
  @client.close
889
- @client.ping.should eql(false)
900
+ expect(@client.ping).to eql(false)
890
901
  end
891
902
 
892
903
  unless RUBY_VERSION =~ /1.8/
893
904
  it "should respond to #encoding" do
894
- @client.should respond_to(:encoding)
905
+ expect(@client).to respond_to(:encoding)
895
906
  end
896
907
  end
897
908
  end