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,39 +1,47 @@
1
1
  # encoding: UTF-8
2
2
  require 'spec_helper'
3
3
 
4
- describe Mysql2::Result do
4
+ RSpec.describe Mysql2::Result do
5
5
  before(:each) do
6
6
  @result = @client.query "SELECT 1"
7
7
  end
8
8
 
9
+ it "should raise a TypeError exception when it doesn't wrap a result set" do
10
+ r = Mysql2::Result.new
11
+ expect { r.count }.to raise_error(TypeError)
12
+ expect { r.fields }.to raise_error(TypeError)
13
+ expect { r.size }.to raise_error(TypeError)
14
+ expect { r.each }.to raise_error(TypeError)
15
+ end
16
+
9
17
  it "should have included Enumerable" do
10
- Mysql2::Result.ancestors.include?(Enumerable).should be_true
18
+ expect(Mysql2::Result.ancestors.include?(Enumerable)).to be true
11
19
  end
12
20
 
13
21
  it "should respond to #each" do
14
- @result.should respond_to(:each)
22
+ expect(@result).to respond_to(:each)
15
23
  end
16
24
 
17
25
  it "should raise a Mysql2::Error exception upon a bad query" do
18
- lambda {
26
+ expect {
19
27
  @client.query "bad sql"
20
- }.should raise_error(Mysql2::Error)
28
+ }.to raise_error(Mysql2::Error)
21
29
 
22
- lambda {
30
+ expect {
23
31
  @client.query "SELECT 1"
24
- }.should_not raise_error(Mysql2::Error)
32
+ }.not_to raise_error
25
33
  end
26
34
 
27
35
  it "should respond to #count, which is aliased as #size" do
28
36
  r = @client.query "SELECT 1"
29
- r.should respond_to :count
30
- r.should respond_to :size
37
+ expect(r).to respond_to :count
38
+ expect(r).to respond_to :size
31
39
  end
32
40
 
33
41
  it "should be able to return the number of rows in the result set" do
34
42
  r = @client.query "SELECT 1"
35
- r.count.should eql(1)
36
- r.size.should eql(1)
43
+ expect(r.count).to eql(1)
44
+ expect(r.size).to eql(1)
37
45
  end
38
46
 
39
47
  context "metadata queries" do
@@ -45,39 +53,39 @@ describe Mysql2::Result do
45
53
  context "#each" do
46
54
  it "should yield rows as hash's" do
47
55
  @result.each do |row|
48
- row.class.should eql(Hash)
56
+ expect(row.class).to eql(Hash)
49
57
  end
50
58
  end
51
59
 
52
60
  it "should yield rows as hash's with symbol keys if :symbolize_keys was set to true" do
53
61
  @result.each(:symbolize_keys => true) do |row|
54
- row.keys.first.class.should eql(Symbol)
62
+ expect(row.keys.first.class).to eql(Symbol)
55
63
  end
56
64
  end
57
65
 
58
66
  it "should be able to return results as an array" do
59
67
  @result.each(:as => :array) do |row|
60
- row.class.should eql(Array)
68
+ expect(row.class).to eql(Array)
61
69
  end
62
70
  end
63
71
 
64
72
  it "should cache previously yielded results by default" do
65
- @result.first.object_id.should eql(@result.first.object_id)
73
+ expect(@result.first.object_id).to eql(@result.first.object_id)
66
74
  end
67
75
 
68
76
  it "should not cache previously yielded results if cache_rows is disabled" do
69
77
  result = @client.query "SELECT 1", :cache_rows => false
70
- result.first.object_id.should_not eql(result.first.object_id)
78
+ expect(result.first.object_id).not_to eql(result.first.object_id)
71
79
  end
72
80
 
73
81
  it "should yield different value for #first if streaming" do
74
82
  result = @client.query "SELECT 1 UNION SELECT 2", :stream => true, :cache_rows => false
75
- result.first.should_not eql(result.first)
83
+ expect(result.first).not_to eql(result.first)
76
84
  end
77
85
 
78
86
  it "should yield the same value for #first if streaming is disabled" do
79
87
  result = @client.query "SELECT 1 UNION SELECT 2", :stream => false
80
- result.first.should eql(result.first)
88
+ expect(result.first).to eql(result.first)
81
89
  end
82
90
 
83
91
  it "should throw an exception if we try to iterate twice when streaming is enabled" do
@@ -96,41 +104,43 @@ describe Mysql2::Result do
96
104
  end
97
105
 
98
106
  it "method should exist" do
99
- @test_result.should respond_to(:fields)
107
+ expect(@test_result).to respond_to(:fields)
100
108
  end
101
109
 
102
110
  it "should return an array of field names in proper order" do
103
111
  result = @client.query "SELECT 'a', 'b', 'c'"
104
- result.fields.should eql(['a', 'b', 'c'])
112
+ expect(result.fields).to eql(['a', 'b', 'c'])
105
113
  end
106
114
  end
107
115
 
108
116
  context "streaming" do
109
117
  it "should maintain a count while streaming" do
110
- result = @client.query('SELECT 1')
111
-
112
- result.count.should eql(1)
118
+ result = @client.query('SELECT 1', :stream => true, :cache_rows => false)
119
+ expect(result.count).to eql(0)
113
120
  result.each.to_a
114
- result.count.should eql(1)
121
+ expect(result.count).to eql(1)
115
122
  end
116
123
 
117
- it "should set the actual count of rows after streaming" do
118
- result = @client.query("SELECT * FROM mysql2_test", :stream => true, :cache_rows => false)
119
- result.count.should eql(0)
120
- result.each {|r| }
121
- result.count.should eql(1)
124
+ it "should retain the count when mixing first and each" do
125
+ result = @client.query("SELECT 1 UNION SELECT 2", :stream => true, :cache_rows => false)
126
+ expect(result.count).to eql(0)
127
+ result.first
128
+ expect(result.count).to eql(1)
129
+ result.each.to_a
130
+ expect(result.count).to eql(2)
122
131
  end
123
132
 
124
133
  it "should not yield nil at the end of streaming" do
125
134
  result = @client.query('SELECT * FROM mysql2_test', :stream => true, :cache_rows => false)
126
- result.each { |r| r.should_not be_nil}
135
+ result.each { |r| expect(r).not_to be_nil}
127
136
  end
128
137
 
129
138
  it "#count should be zero for rows after streaming when there were no results" do
139
+ @client.query "USE test"
130
140
  result = @client.query("SELECT * FROM mysql2_test WHERE null_test IS NOT NULL", :stream => true, :cache_rows => false)
131
- result.count.should eql(0)
141
+ expect(result.count).to eql(0)
132
142
  result.each.to_a
133
- result.count.should eql(0)
143
+ expect(result.count).to eql(0)
134
144
  end
135
145
 
136
146
  it "should raise an exception if streaming ended due to a timeout" do
@@ -147,12 +157,12 @@ describe Mysql2::Result do
147
157
  client.query "SET net_write_timeout = 1"
148
158
  res = client.query "SELECT * FROM streamingTest", :stream => true, :cache_rows => false
149
159
 
150
- lambda {
160
+ expect {
151
161
  res.each_with_index do |row, i|
152
162
  # Exhaust the first result packet then trigger a timeout
153
163
  sleep 2 if i > 0 && i % 1000 == 0
154
164
  end
155
- }.should raise_error(Mysql2::Error, /Lost connection/)
165
+ }.to raise_error(Mysql2::Error, /Lost connection/)
156
166
  end
157
167
  end
158
168
 
@@ -163,32 +173,32 @@ describe Mysql2::Result do
163
173
 
164
174
  it "should return nil values for NULL and strings for everything else when :cast is false" do
165
175
  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
166
- result["null_test"].should be_nil
167
- result["tiny_int_test"].should eql("1")
168
- result["bool_cast_test"].should eql("1")
169
- result["int_test"].should eql("10")
170
- result["date_test"].should eql("2010-04-04")
171
- result["enum_test"].should eql("val1")
176
+ expect(result["null_test"]).to be_nil
177
+ expect(result["tiny_int_test"]).to eql("1")
178
+ expect(result["bool_cast_test"]).to eql("1")
179
+ expect(result["int_test"]).to eql("10")
180
+ expect(result["date_test"]).to eql("2010-04-04")
181
+ expect(result["enum_test"]).to eql("val1")
172
182
  end
173
183
 
174
184
  it "should return nil for a NULL value" do
175
- @test_result['null_test'].class.should eql(NilClass)
176
- @test_result['null_test'].should eql(nil)
185
+ expect(@test_result['null_test'].class).to eql(NilClass)
186
+ expect(@test_result['null_test']).to eql(nil)
177
187
  end
178
188
 
179
189
  it "should return String for a BIT(64) value" do
180
- @test_result['bit_test'].class.should eql(String)
181
- @test_result['bit_test'].should eql("\000\000\000\000\000\000\000\005")
190
+ expect(@test_result['bit_test'].class).to eql(String)
191
+ expect(@test_result['bit_test']).to eql("\000\000\000\000\000\000\000\005")
182
192
  end
183
193
 
184
194
  it "should return String for a BIT(1) value" do
185
- @test_result['single_bit_test'].class.should eql(String)
186
- @test_result['single_bit_test'].should eql("\001")
195
+ expect(@test_result['single_bit_test'].class).to eql(String)
196
+ expect(@test_result['single_bit_test']).to eql("\001")
187
197
  end
188
198
 
189
199
  it "should return Fixnum for a TINYINT value" do
190
- [Fixnum, Bignum].should include(@test_result['tiny_int_test'].class)
191
- @test_result['tiny_int_test'].should eql(1)
200
+ expect([Fixnum, Bignum]).to include(@test_result['tiny_int_test'].class)
201
+ expect(@test_result['tiny_int_test']).to eql(1)
192
202
  end
193
203
 
194
204
  it "should return TrueClass or FalseClass for a TINYINT value if :cast_booleans is enabled" do
@@ -202,9 +212,9 @@ describe Mysql2::Result do
202
212
  result1 = @client.query 'SELECT bool_cast_test FROM mysql2_test WHERE bool_cast_test = 1 LIMIT 1', :cast_booleans => true
203
213
  result2 = @client.query 'SELECT bool_cast_test FROM mysql2_test WHERE bool_cast_test = 0 LIMIT 1', :cast_booleans => true
204
214
  result3 = @client.query 'SELECT bool_cast_test FROM mysql2_test WHERE bool_cast_test = -1 LIMIT 1', :cast_booleans => true
205
- result1.first['bool_cast_test'].should be_true
206
- result2.first['bool_cast_test'].should be_false
207
- result3.first['bool_cast_test'].should be_true
215
+ expect(result1.first['bool_cast_test']).to be true
216
+ expect(result2.first['bool_cast_test']).to be false
217
+ expect(result3.first['bool_cast_test']).to be true
208
218
 
209
219
  @client.query "DELETE from mysql2_test WHERE id IN(#{id1},#{id2},#{id3})"
210
220
  end
@@ -217,55 +227,55 @@ describe Mysql2::Result do
217
227
 
218
228
  result1 = @client.query "SELECT single_bit_test FROM mysql2_test WHERE id = #{id1}", :cast_booleans => true
219
229
  result2 = @client.query "SELECT single_bit_test FROM mysql2_test WHERE id = #{id2}", :cast_booleans => true
220
- result1.first['single_bit_test'].should be_true
221
- result2.first['single_bit_test'].should be_false
230
+ expect(result1.first['single_bit_test']).to be true
231
+ expect(result2.first['single_bit_test']).to be false
222
232
 
223
233
  @client.query "DELETE from mysql2_test WHERE id IN(#{id1},#{id2})"
224
234
  end
225
235
 
226
236
  it "should return Fixnum for a SMALLINT value" do
227
- [Fixnum, Bignum].should include(@test_result['small_int_test'].class)
228
- @test_result['small_int_test'].should eql(10)
237
+ expect([Fixnum, Bignum]).to include(@test_result['small_int_test'].class)
238
+ expect(@test_result['small_int_test']).to eql(10)
229
239
  end
230
240
 
231
241
  it "should return Fixnum for a MEDIUMINT value" do
232
- [Fixnum, Bignum].should include(@test_result['medium_int_test'].class)
233
- @test_result['medium_int_test'].should eql(10)
242
+ expect([Fixnum, Bignum]).to include(@test_result['medium_int_test'].class)
243
+ expect(@test_result['medium_int_test']).to eql(10)
234
244
  end
235
245
 
236
246
  it "should return Fixnum for an INT value" do
237
- [Fixnum, Bignum].should include(@test_result['int_test'].class)
238
- @test_result['int_test'].should eql(10)
247
+ expect([Fixnum, Bignum]).to include(@test_result['int_test'].class)
248
+ expect(@test_result['int_test']).to eql(10)
239
249
  end
240
250
 
241
251
  it "should return Fixnum for a BIGINT value" do
242
- [Fixnum, Bignum].should include(@test_result['big_int_test'].class)
243
- @test_result['big_int_test'].should eql(10)
252
+ expect([Fixnum, Bignum]).to include(@test_result['big_int_test'].class)
253
+ expect(@test_result['big_int_test']).to eql(10)
244
254
  end
245
255
 
246
256
  it "should return Fixnum for a YEAR value" do
247
- [Fixnum, Bignum].should include(@test_result['year_test'].class)
248
- @test_result['year_test'].should eql(2009)
257
+ expect([Fixnum, Bignum]).to include(@test_result['year_test'].class)
258
+ expect(@test_result['year_test']).to eql(2009)
249
259
  end
250
260
 
251
261
  it "should return BigDecimal for a DECIMAL value" do
252
- @test_result['decimal_test'].class.should eql(BigDecimal)
253
- @test_result['decimal_test'].should eql(10.3)
262
+ expect(@test_result['decimal_test'].class).to eql(BigDecimal)
263
+ expect(@test_result['decimal_test']).to eql(10.3)
254
264
  end
255
265
 
256
266
  it "should return Float for a FLOAT value" do
257
- @test_result['float_test'].class.should eql(Float)
258
- @test_result['float_test'].should eql(10.3)
267
+ expect(@test_result['float_test'].class).to eql(Float)
268
+ expect(@test_result['float_test']).to eql(10.3)
259
269
  end
260
270
 
261
271
  it "should return Float for a DOUBLE value" do
262
- @test_result['double_test'].class.should eql(Float)
263
- @test_result['double_test'].should eql(10.3)
272
+ expect(@test_result['double_test'].class).to eql(Float)
273
+ expect(@test_result['double_test']).to eql(10.3)
264
274
  end
265
275
 
266
276
  it "should return Time for a DATETIME value when within the supported range" do
267
- @test_result['date_time_test'].class.should eql(Time)
268
- @test_result['date_time_test'].strftime("%Y-%m-%d %H:%M:%S").should eql('2010-04-04 11:44:00')
277
+ expect(@test_result['date_time_test'].class).to eql(Time)
278
+ expect(@test_result['date_time_test'].strftime("%Y-%m-%d %H:%M:%S")).to eql('2010-04-04 11:44:00')
269
279
  end
270
280
 
271
281
  if 1.size == 4 # 32bit
@@ -278,158 +288,153 @@ describe Mysql2::Result do
278
288
  it "should return DateTime when timestamp is < 1901-12-13 20:45:52" do
279
289
  # 1901-12-13T20:45:52 is the min for 32bit Ruby 1.8
280
290
  r = @client.query("SELECT CAST('1901-12-13 20:45:51' AS DATETIME) as test")
281
- r.first['test'].class.should eql(klass)
291
+ expect(r.first['test'].class).to eql(klass)
282
292
  end
283
293
 
284
294
  it "should return DateTime when timestamp is > 2038-01-19T03:14:07" do
285
295
  # 2038-01-19T03:14:07 is the max for 32bit Ruby 1.8
286
296
  r = @client.query("SELECT CAST('2038-01-19 03:14:08' AS DATETIME) as test")
287
- r.first['test'].class.should eql(klass)
297
+ expect(r.first['test'].class).to eql(klass)
288
298
  end
289
299
  elsif 1.size == 8 # 64bit
290
300
  unless RUBY_VERSION =~ /1.8/
291
301
  it "should return Time when timestamp is < 1901-12-13 20:45:52" do
292
302
  r = @client.query("SELECT CAST('1901-12-13 20:45:51' AS DATETIME) as test")
293
- r.first['test'].class.should eql(Time)
303
+ expect(r.first['test'].class).to eql(Time)
294
304
  end
295
305
 
296
306
  it "should return Time when timestamp is > 2038-01-19T03:14:07" do
297
307
  r = @client.query("SELECT CAST('2038-01-19 03:14:08' AS DATETIME) as test")
298
- r.first['test'].class.should eql(Time)
308
+ expect(r.first['test'].class).to eql(Time)
299
309
  end
300
310
  else
301
311
  it "should return Time when timestamp is > 0138-12-31 11:59:59" do
302
312
  r = @client.query("SELECT CAST('0139-1-1 00:00:00' AS DATETIME) as test")
303
- r.first['test'].class.should eql(Time)
313
+ expect(r.first['test'].class).to eql(Time)
304
314
  end
305
315
 
306
316
  it "should return DateTime when timestamp is < 0139-1-1T00:00:00" do
307
317
  r = @client.query("SELECT CAST('0138-12-31 11:59:59' AS DATETIME) as test")
308
- r.first['test'].class.should eql(DateTime)
318
+ expect(r.first['test'].class).to eql(DateTime)
309
319
  end
310
320
 
311
321
  it "should return Time when timestamp is > 2038-01-19T03:14:07" do
312
322
  r = @client.query("SELECT CAST('2038-01-19 03:14:08' AS DATETIME) as test")
313
- r.first['test'].class.should eql(Time)
323
+ expect(r.first['test'].class).to eql(Time)
314
324
  end
315
325
  end
316
326
  end
317
327
 
318
328
  it "should return Time for a TIMESTAMP value when within the supported range" do
319
- @test_result['timestamp_test'].class.should eql(Time)
320
- @test_result['timestamp_test'].strftime("%Y-%m-%d %H:%M:%S").should eql('2010-04-04 11:44:00')
329
+ expect(@test_result['timestamp_test'].class).to eql(Time)
330
+ expect(@test_result['timestamp_test'].strftime("%Y-%m-%d %H:%M:%S")).to eql('2010-04-04 11:44:00')
321
331
  end
322
332
 
323
333
  it "should return Time for a TIME value" do
324
- @test_result['time_test'].class.should eql(Time)
325
- @test_result['time_test'].strftime("%Y-%m-%d %H:%M:%S").should eql('2000-01-01 11:44:00')
334
+ expect(@test_result['time_test'].class).to eql(Time)
335
+ expect(@test_result['time_test'].strftime("%Y-%m-%d %H:%M:%S")).to eql('2000-01-01 11:44:00')
326
336
  end
327
337
 
328
338
  it "should return Date for a DATE value" do
329
- @test_result['date_test'].class.should eql(Date)
330
- @test_result['date_test'].strftime("%Y-%m-%d").should eql('2010-04-04')
339
+ expect(@test_result['date_test'].class).to eql(Date)
340
+ expect(@test_result['date_test'].strftime("%Y-%m-%d")).to eql('2010-04-04')
331
341
  end
332
342
 
333
343
  it "should return String for an ENUM value" do
334
- @test_result['enum_test'].class.should eql(String)
335
- @test_result['enum_test'].should eql('val1')
344
+ expect(@test_result['enum_test'].class).to eql(String)
345
+ expect(@test_result['enum_test']).to eql('val1')
336
346
  end
337
347
 
338
348
  it "should raise an error given an invalid DATETIME" do
339
- begin
340
- @client.query("SELECT CAST('1972-00-27 00:00:00' AS DATETIME) as bad_datetime").each
341
- rescue Mysql2::Error => e
342
- error = e
343
- end
344
-
345
- error.message.should eql("Invalid date in field 'bad_datetime': 1972-00-27 00:00:00")
349
+ expect { @client.query("SELECT CAST('1972-00-27 00:00:00' AS DATETIME) as bad_datetime").each }.to \
350
+ raise_error(Mysql2::Error, "Invalid date in field 'bad_datetime': 1972-00-27 00:00:00")
346
351
  end
347
352
 
348
- if defined? Encoding
349
- context "string encoding for ENUM values" do
350
- it "should default to the connection's encoding if Encoding.default_internal is nil" do
351
- with_internal_encoding nil do
352
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
353
- result['enum_test'].encoding.should eql(Encoding.find('utf-8'))
353
+ context "string encoding for ENUM values" do
354
+ before { pending('Encoding is undefined') unless defined?(Encoding) }
354
355
 
355
- client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
356
- result = client2.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
357
- result['enum_test'].encoding.should eql(Encoding.find('us-ascii'))
358
- client2.close
359
- end
356
+ it "should default to the connection's encoding if Encoding.default_internal is nil" do
357
+ with_internal_encoding nil do
358
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
359
+ expect(result['enum_test'].encoding).to eql(Encoding::UTF_8)
360
+
361
+ client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
362
+ result = client2.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
363
+ expect(result['enum_test'].encoding).to eql(Encoding::ASCII)
364
+ client2.close
360
365
  end
366
+ end
361
367
 
362
- it "should use Encoding.default_internal" do
363
- with_internal_encoding 'utf-8' do
364
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
365
- result['enum_test'].encoding.should eql(Encoding.default_internal)
366
- end
368
+ it "should use Encoding.default_internal" do
369
+ with_internal_encoding Encoding::UTF_8 do
370
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
371
+ expect(result['enum_test'].encoding).to eql(Encoding.default_internal)
372
+ end
367
373
 
368
- with_internal_encoding 'us-ascii' do
369
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
370
- result['enum_test'].encoding.should eql(Encoding.default_internal)
371
- end
374
+ with_internal_encoding Encoding::ASCII do
375
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
376
+ expect(result['enum_test'].encoding).to eql(Encoding.default_internal)
372
377
  end
373
378
  end
374
379
  end
375
380
 
376
381
  it "should return String for a SET value" do
377
- @test_result['set_test'].class.should eql(String)
378
- @test_result['set_test'].should eql('val1,val2')
382
+ expect(@test_result['set_test'].class).to eql(String)
383
+ expect(@test_result['set_test']).to eql('val1,val2')
379
384
  end
380
385
 
381
- if defined? Encoding
382
- context "string encoding for SET values" do
383
- it "should default to the connection's encoding if Encoding.default_internal is nil" do
384
- with_internal_encoding nil do
385
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
386
- result['set_test'].encoding.should eql(Encoding.find('utf-8'))
386
+ context "string encoding for SET values" do
387
+ before { pending('Encoding is undefined') unless defined?(Encoding) }
387
388
 
388
- client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
389
- result = client2.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
390
- result['set_test'].encoding.should eql(Encoding.find('us-ascii'))
391
- client2.close
392
- end
389
+ it "should default to the connection's encoding if Encoding.default_internal is nil" do
390
+ with_internal_encoding nil do
391
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
392
+ expect(result['set_test'].encoding).to eql(Encoding::UTF_8)
393
+
394
+ client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
395
+ result = client2.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
396
+ expect(result['set_test'].encoding).to eql(Encoding::ASCII)
397
+ client2.close
393
398
  end
399
+ end
394
400
 
395
- it "should use Encoding.default_internal" do
396
- with_internal_encoding 'utf-8' do
397
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
398
- result['set_test'].encoding.should eql(Encoding.default_internal)
399
- end
401
+ it "should use Encoding.default_internal" do
402
+ with_internal_encoding Encoding::UTF_8 do
403
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
404
+ expect(result['set_test'].encoding).to eql(Encoding.default_internal)
405
+ end
400
406
 
401
- with_internal_encoding 'us-ascii' do
402
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
403
- result['set_test'].encoding.should eql(Encoding.default_internal)
404
- end
407
+ with_internal_encoding Encoding::ASCII do
408
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
409
+ expect(result['set_test'].encoding).to eql(Encoding.default_internal)
405
410
  end
406
411
  end
407
412
  end
408
413
 
409
414
  it "should return String for a BINARY value" do
410
- @test_result['binary_test'].class.should eql(String)
411
- @test_result['binary_test'].should eql("test#{"\000"*6}")
415
+ expect(@test_result['binary_test'].class).to eql(String)
416
+ expect(@test_result['binary_test']).to eql("test#{"\000"*6}")
412
417
  end
413
418
 
414
- if defined? Encoding
415
- context "string encoding for BINARY values" do
416
- it "should default to binary if Encoding.default_internal is nil" do
417
- with_internal_encoding nil do
418
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
419
- result['binary_test'].encoding.should eql(Encoding.find('binary'))
420
- end
419
+ context "string encoding for BINARY values" do
420
+ before { pending('Encoding is undefined') unless defined?(Encoding) }
421
+
422
+ it "should default to binary if Encoding.default_internal is nil" do
423
+ with_internal_encoding nil do
424
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
425
+ expect(result['binary_test'].encoding).to eql(Encoding::BINARY)
421
426
  end
427
+ end
422
428
 
423
- it "should not use Encoding.default_internal" do
424
- with_internal_encoding 'utf-8' do
425
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
426
- result['binary_test'].encoding.should eql(Encoding.find('binary'))
427
- end
429
+ it "should not use Encoding.default_internal" do
430
+ with_internal_encoding Encoding::UTF_8 do
431
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
432
+ expect(result['binary_test'].encoding).to eql(Encoding::BINARY)
433
+ end
428
434
 
429
- with_internal_encoding 'us-ascii' do
430
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
431
- result['binary_test'].encoding.should eql(Encoding.find('binary'))
432
- end
435
+ with_internal_encoding Encoding::ASCII do
436
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
437
+ expect(result['binary_test'].encoding).to eql(Encoding::BINARY)
433
438
  end
434
439
  end
435
440
  end
@@ -448,54 +453,54 @@ describe Mysql2::Result do
448
453
  'long_text_test' => 'LONGTEXT'
449
454
  }.each do |field, type|
450
455
  it "should return a String for #{type}" do
451
- @test_result[field].class.should eql(String)
452
- @test_result[field].should eql("test")
456
+ expect(@test_result[field].class).to eql(String)
457
+ expect(@test_result[field]).to eql("test")
453
458
  end
454
459
 
455
- if defined? Encoding
456
- context "string encoding for #{type} values" do
457
- if ['VARBINARY', 'TINYBLOB', 'BLOB', 'MEDIUMBLOB', 'LONGBLOB'].include?(type)
458
- it "should default to binary if Encoding.default_internal is nil" do
459
- with_internal_encoding nil do
460
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
461
- result['binary_test'].encoding.should eql(Encoding.find('binary'))
462
- end
460
+ context "string encoding for #{type} values" do
461
+ before { pending('Encoding is undefined') unless defined?(Encoding) }
462
+
463
+ if ['VARBINARY', 'TINYBLOB', 'BLOB', 'MEDIUMBLOB', 'LONGBLOB'].include?(type)
464
+ it "should default to binary if Encoding.default_internal is nil" do
465
+ with_internal_encoding nil do
466
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
467
+ expect(result['binary_test'].encoding).to eql(Encoding::BINARY)
463
468
  end
469
+ end
464
470
 
465
- it "should not use Encoding.default_internal" do
466
- with_internal_encoding 'utf-8' do
467
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
468
- result['binary_test'].encoding.should eql(Encoding.find('binary'))
469
- end
471
+ it "should not use Encoding.default_internal" do
472
+ with_internal_encoding Encoding::UTF_8 do
473
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
474
+ expect(result['binary_test'].encoding).to eql(Encoding::BINARY)
475
+ end
470
476
 
471
- with_internal_encoding 'us-ascii' do
472
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
473
- result['binary_test'].encoding.should eql(Encoding.find('binary'))
474
- end
477
+ with_internal_encoding Encoding::ASCII do
478
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
479
+ expect(result['binary_test'].encoding).to eql(Encoding::BINARY)
475
480
  end
476
- else
477
- it "should default to utf-8 if Encoding.default_internal is nil" do
478
- with_internal_encoding nil do
479
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
480
- result[field].encoding.should eql(Encoding.find('utf-8'))
481
-
482
- client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
483
- result = client2.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
484
- result[field].encoding.should eql(Encoding.find('us-ascii'))
485
- client2.close
486
- end
481
+ end
482
+ else
483
+ it "should default to utf-8 if Encoding.default_internal is nil" do
484
+ with_internal_encoding nil do
485
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
486
+ expect(result[field].encoding).to eql(Encoding::UTF_8)
487
+
488
+ client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
489
+ result = client2.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
490
+ expect(result[field].encoding).to eql(Encoding::ASCII)
491
+ client2.close
487
492
  end
493
+ end
488
494
 
489
- it "should use Encoding.default_internal" do
490
- with_internal_encoding 'utf-8' do
491
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
492
- result[field].encoding.should eql(Encoding.default_internal)
493
- end
495
+ it "should use Encoding.default_internal" do
496
+ with_internal_encoding Encoding::UTF_8 do
497
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
498
+ expect(result[field].encoding).to eql(Encoding.default_internal)
499
+ end
494
500
 
495
- with_internal_encoding 'us-ascii' do
496
- result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
497
- result[field].encoding.should eql(Encoding.default_internal)
498
- end
501
+ with_internal_encoding Encoding::ASCII do
502
+ result = @client.query("SELECT * FROM mysql2_test ORDER BY id DESC LIMIT 1").first
503
+ expect(result[field].encoding).to eql(Encoding.default_internal)
499
504
  end
500
505
  end
501
506
  end