mysql2 0.3.21-x86-mswin32-60 → 0.4.0-x86-mswin32-60

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