mongo 1.10.2 → 1.11.1
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- checksums.yaml.gz.sig +0 -0
- data.tar.gz.sig +0 -0
- data/README.md +43 -9
- data/VERSION +1 -1
- data/lib/mongo.rb +1 -0
- data/lib/mongo/collection.rb +36 -21
- data/lib/mongo/connection/pool.rb +14 -22
- data/lib/mongo/cursor.rb +13 -0
- data/lib/mongo/db.rb +18 -13
- data/lib/mongo/functional.rb +0 -2
- data/lib/mongo/functional/authentication.rb +35 -25
- data/lib/mongo/legacy.rb +4 -4
- data/mongo.gemspec +0 -5
- data/test/functional/authentication_test.rb +3 -2
- data/test/functional/bulk_write_collection_view_test.rb +9 -14
- data/test/functional/client_test.rb +42 -43
- data/test/functional/collection_test.rb +1073 -995
- data/test/functional/collection_writer_test.rb +1 -1
- data/test/functional/cursor_fail_test.rb +3 -9
- data/test/functional/cursor_message_test.rb +14 -15
- data/test/functional/cursor_test.rb +224 -166
- data/test/functional/db_api_test.rb +262 -261
- data/test/functional/db_connection_test.rb +1 -3
- data/test/functional/db_test.rb +116 -115
- data/test/functional/grid_file_system_test.rb +108 -108
- data/test/functional/pool_test.rb +73 -0
- data/test/functional/timeout_test.rb +2 -0
- data/test/helpers/test_unit.rb +146 -11
- data/test/replica_set/authentication_test.rb +4 -2
- data/test/replica_set/basic_test.rb +5 -13
- data/test/replica_set/client_test.rb +8 -6
- data/test/replica_set/complex_connect_test.rb +3 -0
- data/test/replica_set/count_test.rb +2 -0
- data/test/replica_set/cursor_test.rb +5 -0
- data/test/replica_set/insert_test.rb +1 -1
- data/test/replica_set/max_values_test.rb +1 -1
- data/test/replica_set/pinning_test.rb +1 -1
- data/test/replica_set/query_test.rb +1 -1
- data/test/replica_set/read_preference_test.rb +7 -1
- data/test/replica_set/refresh_test.rb +11 -8
- data/test/replica_set/replication_ack_test.rb +2 -1
- data/test/sharded_cluster/basic_test.rb +17 -11
- data/test/shared/authentication/basic_auth_shared.rb +59 -98
- data/test/shared/authentication/bulk_api_auth_shared.rb +11 -21
- data/test/shared/authentication/gssapi_shared.rb +28 -21
- data/test/test_helper.rb +5 -0
- data/test/tools/mongo_config.rb +96 -11
- metadata +4 -5
- metadata.gz.sig +0 -0
- data/lib/mongo/functional/sasl_java.rb +0 -48
@@ -18,42 +18,41 @@ class DBAPITest < Test::Unit::TestCase
|
|
18
18
|
include Mongo
|
19
19
|
include BSON
|
20
20
|
|
21
|
-
@@client = standard_connection
|
22
|
-
@@db = @@client.db(TEST_DB)
|
23
|
-
@@coll = @@db.collection('test')
|
24
|
-
@@version = @@client.server_version
|
25
|
-
|
26
21
|
def setup
|
27
|
-
|
28
|
-
@
|
29
|
-
|
30
|
-
|
22
|
+
@client = standard_connection
|
23
|
+
@db = @client.db(TEST_DB)
|
24
|
+
@coll = @db.collection('test')
|
25
|
+
@version = @client.server_version
|
26
|
+
@coll.remove
|
27
|
+
@r1 = {'a' => 1}
|
28
|
+
@coll.insert(@r1) # collection not created until it's used
|
29
|
+
@coll_full_name = "#{TEST_DB}.test"
|
31
30
|
end
|
32
31
|
|
33
32
|
def teardown
|
34
|
-
|
35
|
-
|
33
|
+
@coll.remove
|
34
|
+
@db.get_last_error
|
36
35
|
end
|
37
36
|
|
38
37
|
def test_clear
|
39
|
-
assert_equal 1,
|
40
|
-
|
41
|
-
assert_equal 0,
|
38
|
+
assert_equal 1, @coll.count
|
39
|
+
@coll.remove
|
40
|
+
assert_equal 0, @coll.count
|
42
41
|
end
|
43
42
|
|
44
43
|
def test_insert
|
45
|
-
assert_kind_of BSON::ObjectId,
|
46
|
-
assert_kind_of BSON::ObjectId,
|
44
|
+
assert_kind_of BSON::ObjectId, @coll.insert('a' => 2)
|
45
|
+
assert_kind_of BSON::ObjectId, @coll.insert('b' => 3)
|
47
46
|
|
48
|
-
assert_equal 3,
|
49
|
-
docs =
|
47
|
+
assert_equal 3, @coll.count
|
48
|
+
docs = @coll.find().to_a
|
50
49
|
assert_equal 3, docs.length
|
51
50
|
assert docs.detect { |row| row['a'] == 1 }
|
52
51
|
assert docs.detect { |row| row['a'] == 2 }
|
53
52
|
assert docs.detect { |row| row['b'] == 3 }
|
54
53
|
|
55
|
-
|
56
|
-
docs =
|
54
|
+
@coll << {'b' => 4}
|
55
|
+
docs = @coll.find().to_a
|
57
56
|
assert_equal 4, docs.length
|
58
57
|
assert docs.detect { |row| row['b'] == 4 }
|
59
58
|
end
|
@@ -63,23 +62,23 @@ class DBAPITest < Test::Unit::TestCase
|
|
63
62
|
oh['a'] = -1
|
64
63
|
oh['b'] = 'foo'
|
65
64
|
|
66
|
-
oid =
|
67
|
-
assert_equal 'foo',
|
65
|
+
oid = @coll.save(oh)
|
66
|
+
assert_equal 'foo', @coll.find_one(oid)['b']
|
68
67
|
|
69
68
|
oh = BSON::OrderedHash['a' => 1, 'b' => 'foo']
|
70
|
-
oid =
|
71
|
-
assert_equal 'foo',
|
69
|
+
oid = @coll.save(oh)
|
70
|
+
assert_equal 'foo', @coll.find_one(oid)['b']
|
72
71
|
end
|
73
72
|
|
74
73
|
def test_insert_multiple
|
75
|
-
ids =
|
74
|
+
ids = @coll.insert([{'a' => 2}, {'b' => 3}])
|
76
75
|
|
77
76
|
ids.each do |i|
|
78
77
|
assert_kind_of BSON::ObjectId, i
|
79
78
|
end
|
80
79
|
|
81
|
-
assert_equal 3,
|
82
|
-
docs =
|
80
|
+
assert_equal 3, @coll.count
|
81
|
+
docs = @coll.find().to_a
|
83
82
|
assert_equal 3, docs.length
|
84
83
|
assert docs.detect { |row| row['a'] == 1 }
|
85
84
|
assert docs.detect { |row| row['a'] == 2 }
|
@@ -87,20 +86,20 @@ class DBAPITest < Test::Unit::TestCase
|
|
87
86
|
end
|
88
87
|
|
89
88
|
def test_count_on_nonexisting
|
90
|
-
|
91
|
-
assert_equal 0,
|
89
|
+
@db.drop_collection('foo')
|
90
|
+
assert_equal 0, @db.collection('foo').count()
|
92
91
|
end
|
93
92
|
|
94
93
|
def test_find_simple
|
95
|
-
@r2 =
|
96
|
-
@r3 =
|
94
|
+
@r2 = @coll.insert('a' => 2)
|
95
|
+
@r3 = @coll.insert('b' => 3)
|
97
96
|
# Check sizes
|
98
|
-
docs =
|
97
|
+
docs = @coll.find().to_a
|
99
98
|
assert_equal 3, docs.size
|
100
|
-
assert_equal 3,
|
99
|
+
assert_equal 3, @coll.count
|
101
100
|
|
102
101
|
# Find by other value
|
103
|
-
docs =
|
102
|
+
docs = @coll.find('a' => @r1['a']).to_a
|
104
103
|
assert_equal 1, docs.size
|
105
104
|
doc = docs.first
|
106
105
|
# Can't compare _id values because at insert, an _id was added to @r1 by
|
@@ -111,52 +110,52 @@ class DBAPITest < Test::Unit::TestCase
|
|
111
110
|
end
|
112
111
|
|
113
112
|
def test_find_advanced
|
114
|
-
|
115
|
-
|
113
|
+
@coll.insert('a' => 2)
|
114
|
+
@coll.insert('b' => 3)
|
116
115
|
|
117
116
|
# Find by advanced query (less than)
|
118
|
-
docs =
|
117
|
+
docs = @coll.find('a' => { '$lt' => 10 }).to_a
|
119
118
|
assert_equal 2, docs.size
|
120
119
|
assert docs.detect { |row| row['a'] == 1 }
|
121
120
|
assert docs.detect { |row| row['a'] == 2 }
|
122
121
|
|
123
122
|
# Find by advanced query (greater than)
|
124
|
-
docs =
|
123
|
+
docs = @coll.find('a' => { '$gt' => 1 }).to_a
|
125
124
|
assert_equal 1, docs.size
|
126
125
|
assert docs.detect { |row| row['a'] == 2 }
|
127
126
|
|
128
127
|
# Find by advanced query (less than or equal to)
|
129
|
-
docs =
|
128
|
+
docs = @coll.find('a' => { '$lte' => 1 }).to_a
|
130
129
|
assert_equal 1, docs.size
|
131
130
|
assert docs.detect { |row| row['a'] == 1 }
|
132
131
|
|
133
132
|
# Find by advanced query (greater than or equal to)
|
134
|
-
docs =
|
133
|
+
docs = @coll.find('a' => { '$gte' => 1 }).to_a
|
135
134
|
assert_equal 2, docs.size
|
136
135
|
assert docs.detect { |row| row['a'] == 1 }
|
137
136
|
assert docs.detect { |row| row['a'] == 2 }
|
138
137
|
|
139
138
|
# Find by advanced query (between)
|
140
|
-
docs =
|
139
|
+
docs = @coll.find('a' => { '$gt' => 1, '$lt' => 3 }).to_a
|
141
140
|
assert_equal 1, docs.size
|
142
141
|
assert docs.detect { |row| row['a'] == 2 }
|
143
142
|
|
144
143
|
# Find by advanced query (in clause)
|
145
|
-
docs =
|
144
|
+
docs = @coll.find('a' => {'$in' => [1,2]}).to_a
|
146
145
|
assert_equal 2, docs.size
|
147
146
|
assert docs.detect { |row| row['a'] == 1 }
|
148
147
|
assert docs.detect { |row| row['a'] == 2 }
|
149
148
|
end
|
150
149
|
|
151
150
|
def test_find_sorting
|
152
|
-
|
153
|
-
|
154
|
-
|
155
|
-
|
156
|
-
|
151
|
+
@coll.remove
|
152
|
+
@coll.insert('a' => 1, 'b' => 2)
|
153
|
+
@coll.insert('a' => 2, 'b' => 1)
|
154
|
+
@coll.insert('a' => 3, 'b' => 2)
|
155
|
+
@coll.insert('a' => 4, 'b' => 1)
|
157
156
|
|
158
157
|
# Sorting (ascending)
|
159
|
-
docs =
|
158
|
+
docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => [['a', 1]]).to_a
|
160
159
|
assert_equal 4, docs.size
|
161
160
|
assert_equal 1, docs[0]['a']
|
162
161
|
assert_equal 2, docs[1]['a']
|
@@ -164,7 +163,7 @@ class DBAPITest < Test::Unit::TestCase
|
|
164
163
|
assert_equal 4, docs[3]['a']
|
165
164
|
|
166
165
|
# Sorting (descending)
|
167
|
-
docs =
|
166
|
+
docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => [['a', -1]]).to_a
|
168
167
|
assert_equal 4, docs.size
|
169
168
|
assert_equal 4, docs[0]['a']
|
170
169
|
assert_equal 3, docs[1]['a']
|
@@ -172,7 +171,7 @@ class DBAPITest < Test::Unit::TestCase
|
|
172
171
|
assert_equal 1, docs[3]['a']
|
173
172
|
|
174
173
|
# Sorting using array of names; assumes ascending order.
|
175
|
-
docs =
|
174
|
+
docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => 'a').to_a
|
176
175
|
assert_equal 4, docs.size
|
177
176
|
assert_equal 1, docs[0]['a']
|
178
177
|
assert_equal 2, docs[1]['a']
|
@@ -180,14 +179,14 @@ class DBAPITest < Test::Unit::TestCase
|
|
180
179
|
assert_equal 4, docs[3]['a']
|
181
180
|
|
182
181
|
# Sorting using single name; assumes ascending order.
|
183
|
-
docs =
|
182
|
+
docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => 'a').to_a
|
184
183
|
assert_equal 4, docs.size
|
185
184
|
assert_equal 1, docs[0]['a']
|
186
185
|
assert_equal 2, docs[1]['a']
|
187
186
|
assert_equal 3, docs[2]['a']
|
188
187
|
assert_equal 4, docs[3]['a']
|
189
188
|
|
190
|
-
docs =
|
189
|
+
docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => [['b', 'asc'], ['a', 'asc']]).to_a
|
191
190
|
assert_equal 4, docs.size
|
192
191
|
assert_equal 2, docs[0]['a']
|
193
192
|
assert_equal 4, docs[1]['a']
|
@@ -195,7 +194,7 @@ class DBAPITest < Test::Unit::TestCase
|
|
195
194
|
assert_equal 3, docs[3]['a']
|
196
195
|
|
197
196
|
# Sorting using empty array; no order guarantee should not blow up.
|
198
|
-
docs =
|
197
|
+
docs = @coll.find({'a' => { '$lt' => 10 }}, :sort => []).to_a
|
199
198
|
assert_equal 4, docs.size
|
200
199
|
end
|
201
200
|
|
@@ -203,17 +202,17 @@ class DBAPITest < Test::Unit::TestCase
|
|
203
202
|
# Sorting using ordered hash. You can use an unordered one, but then the
|
204
203
|
# order of the keys won't be guaranteed thus your sort won't make sense.
|
205
204
|
|
206
|
-
|
207
|
-
|
208
|
-
|
209
|
-
|
210
|
-
|
205
|
+
@coll.remove
|
206
|
+
@coll.insert('a' => 1, 'b' => 2)
|
207
|
+
@coll.insert('a' => 2, 'b' => 1)
|
208
|
+
@coll.insert('a' => 3, 'b' => 2)
|
209
|
+
@coll.insert('a' => 4, 'b' => 1)
|
211
210
|
|
212
211
|
oh = BSON::OrderedHash.new
|
213
212
|
oh['a'] = -1
|
214
213
|
|
215
214
|
# Sort as a method
|
216
|
-
docs =
|
215
|
+
docs = @coll.find.sort(oh).to_a
|
217
216
|
assert_equal 4, docs.size
|
218
217
|
assert_equal 4, docs[0]['a']
|
219
218
|
assert_equal 3, docs[1]['a']
|
@@ -221,7 +220,7 @@ class DBAPITest < Test::Unit::TestCase
|
|
221
220
|
assert_equal 1, docs[3]['a']
|
222
221
|
|
223
222
|
# Sort as an option
|
224
|
-
docs =
|
223
|
+
docs = @coll.find({}, :sort => oh).to_a
|
225
224
|
assert_equal 4, docs.size
|
226
225
|
assert_equal 4, docs[0]['a']
|
227
226
|
assert_equal 3, docs[1]['a']
|
@@ -229,21 +228,21 @@ class DBAPITest < Test::Unit::TestCase
|
|
229
228
|
assert_equal 1, docs[3]['a']
|
230
229
|
|
231
230
|
if RUBY_VERSION > '1.9'
|
232
|
-
docs =
|
231
|
+
docs = @coll.find({}, :sort => {:a => -1}).to_a
|
233
232
|
assert_equal 4, docs.size
|
234
233
|
assert_equal 4, docs[0]['a']
|
235
234
|
assert_equal 3, docs[1]['a']
|
236
235
|
assert_equal 2, docs[2]['a']
|
237
236
|
assert_equal 1, docs[3]['a']
|
238
237
|
|
239
|
-
docs =
|
238
|
+
docs = @coll.find.sort(:a => -1).to_a
|
240
239
|
assert_equal 4, docs.size
|
241
240
|
assert_equal 4, docs[0]['a']
|
242
241
|
assert_equal 3, docs[1]['a']
|
243
242
|
assert_equal 2, docs[2]['a']
|
244
243
|
assert_equal 1, docs[3]['a']
|
245
244
|
|
246
|
-
docs =
|
245
|
+
docs = @coll.find.sort(:b => -1, :a => 1).to_a
|
247
246
|
assert_equal 4, docs.size
|
248
247
|
assert_equal 1, docs[0]['a']
|
249
248
|
assert_equal 3, docs[1]['a']
|
@@ -252,168 +251,168 @@ class DBAPITest < Test::Unit::TestCase
|
|
252
251
|
else
|
253
252
|
# Sort as an option
|
254
253
|
assert_raise InvalidSortValueError do
|
255
|
-
|
254
|
+
@coll.find({}, :sort => {:a => -1}).to_a
|
256
255
|
end
|
257
256
|
# Sort as a method
|
258
257
|
assert_raise InvalidSortValueError do
|
259
|
-
|
258
|
+
@coll.find.sort(:a => -1).to_a
|
260
259
|
end
|
261
260
|
end
|
262
261
|
end
|
263
262
|
|
264
263
|
def test_find_limits
|
265
|
-
|
266
|
-
|
267
|
-
|
264
|
+
@coll.insert('b' => 2)
|
265
|
+
@coll.insert('c' => 3)
|
266
|
+
@coll.insert('d' => 4)
|
268
267
|
|
269
|
-
docs =
|
268
|
+
docs = @coll.find({}, :limit => 1).to_a
|
270
269
|
assert_equal 1, docs.size
|
271
|
-
docs =
|
270
|
+
docs = @coll.find({}, :limit => 2).to_a
|
272
271
|
assert_equal 2, docs.size
|
273
|
-
docs =
|
272
|
+
docs = @coll.find({}, :limit => 3).to_a
|
274
273
|
assert_equal 3, docs.size
|
275
|
-
docs =
|
274
|
+
docs = @coll.find({}, :limit => 4).to_a
|
276
275
|
assert_equal 4, docs.size
|
277
|
-
docs =
|
276
|
+
docs = @coll.find({}).to_a
|
278
277
|
assert_equal 4, docs.size
|
279
|
-
docs =
|
278
|
+
docs = @coll.find({}, :limit => 99).to_a
|
280
279
|
assert_equal 4, docs.size
|
281
280
|
end
|
282
281
|
|
283
282
|
def test_find_one_no_records
|
284
|
-
|
285
|
-
x =
|
283
|
+
@coll.remove
|
284
|
+
x = @coll.find_one('a' => 1)
|
286
285
|
assert_nil x
|
287
286
|
end
|
288
287
|
|
289
288
|
def test_drop_collection
|
290
|
-
assert
|
291
|
-
assert
|
289
|
+
assert @db.drop_collection(@coll.name), "drop of collection #{@coll.name} failed"
|
290
|
+
assert !@db.collection_names.include?(@coll.name)
|
292
291
|
end
|
293
292
|
|
294
293
|
def test_other_drop
|
295
|
-
assert
|
296
|
-
|
297
|
-
assert
|
294
|
+
assert @db.collection_names.include?(@coll.name)
|
295
|
+
@coll.drop
|
296
|
+
assert !@db.collection_names.include?(@coll.name)
|
298
297
|
end
|
299
298
|
|
300
299
|
def test_collection_names
|
301
|
-
names =
|
300
|
+
names = @db.collection_names
|
302
301
|
assert names.length >= 1
|
303
|
-
assert names.include?(
|
302
|
+
assert names.include?(@coll.name)
|
304
303
|
|
305
|
-
coll2 =
|
304
|
+
coll2 = @db.collection('test2')
|
306
305
|
coll2.insert('a' => 1) # collection not created until it's used
|
307
|
-
names =
|
306
|
+
names = @db.collection_names
|
308
307
|
assert names.length >= 2
|
309
|
-
assert names.include?(
|
308
|
+
assert names.include?(@coll.name)
|
310
309
|
assert names.include?('test2')
|
311
310
|
ensure
|
312
|
-
|
311
|
+
@db.drop_collection('test2')
|
313
312
|
end
|
314
313
|
|
315
314
|
def test_collections_info
|
316
|
-
cursor =
|
315
|
+
cursor = @db.collections_info
|
317
316
|
rows = cursor.to_a
|
318
317
|
assert rows.length >= 1
|
319
|
-
row = rows.detect { |r| r['name'] ==
|
318
|
+
row = rows.detect { |r| r['name'] == @coll_full_name }
|
320
319
|
assert_not_nil row
|
321
320
|
end
|
322
321
|
|
323
322
|
def test_collection_options
|
324
|
-
|
325
|
-
|
323
|
+
@db.drop_collection('foobar')
|
324
|
+
@db.strict = true
|
326
325
|
|
327
326
|
begin
|
328
|
-
coll =
|
327
|
+
coll = @db.create_collection('foobar', :capped => true, :size => 4096)
|
329
328
|
options = coll.options
|
330
|
-
assert_equal 'foobar', options['create'] if
|
329
|
+
assert_equal 'foobar', options['create'] if @client.server_version < '2.5.5'
|
331
330
|
assert_equal true, options['capped']
|
332
331
|
assert_equal 4096, options['size']
|
333
332
|
rescue => ex
|
334
|
-
|
333
|
+
@db.drop_collection('foobar')
|
335
334
|
fail "did not expect exception \"#{ex.inspect}\""
|
336
335
|
ensure
|
337
|
-
|
336
|
+
@db.strict = false
|
338
337
|
end
|
339
338
|
end
|
340
339
|
|
341
340
|
def test_collection_options_are_passed_to_the_existing_ones
|
342
|
-
|
341
|
+
@db.drop_collection('foobar')
|
343
342
|
|
344
|
-
|
343
|
+
@db.create_collection('foobar')
|
345
344
|
|
346
|
-
coll =
|
345
|
+
coll = @db.create_collection('foobar')
|
347
346
|
assert_equal true, Mongo::WriteConcern.gle?(coll.write_concern)
|
348
347
|
end
|
349
348
|
|
350
349
|
|
351
350
|
def test_index_information
|
352
|
-
assert_equal
|
351
|
+
assert_equal @coll.index_information.length, 1
|
353
352
|
|
354
|
-
name =
|
355
|
-
info =
|
353
|
+
name = @coll.create_index('a')
|
354
|
+
info = @db.index_information(@coll.name)
|
356
355
|
assert_equal name, "a_1"
|
357
|
-
assert_equal
|
356
|
+
assert_equal @coll.index_information, info
|
358
357
|
assert_equal 2, info.length
|
359
358
|
|
360
359
|
assert info.has_key?(name)
|
361
360
|
assert_equal info[name]["key"], {"a" => 1}
|
362
361
|
ensure
|
363
|
-
|
362
|
+
@db.drop_index(@coll.name, name)
|
364
363
|
end
|
365
364
|
|
366
365
|
def test_index_create_with_symbol
|
367
|
-
assert_equal
|
366
|
+
assert_equal @coll.index_information.length, 1
|
368
367
|
|
369
|
-
name =
|
370
|
-
info =
|
368
|
+
name = @coll.create_index([['a', 1]])
|
369
|
+
info = @db.index_information(@coll.name)
|
371
370
|
assert_equal name, "a_1"
|
372
|
-
assert_equal
|
371
|
+
assert_equal @coll.index_information, info
|
373
372
|
assert_equal 2, info.length
|
374
373
|
|
375
374
|
assert info.has_key?(name)
|
376
375
|
assert_equal info[name]['key'], {"a" => 1}
|
377
376
|
ensure
|
378
|
-
|
377
|
+
@db.drop_index(@coll.name, name)
|
379
378
|
end
|
380
379
|
|
381
380
|
def test_multiple_index_cols
|
382
|
-
name =
|
383
|
-
info =
|
381
|
+
name = @coll.create_index([['a', DESCENDING], ['b', ASCENDING], ['c', DESCENDING]])
|
382
|
+
info = @db.index_information(@coll.name)
|
384
383
|
assert_equal 2, info.length
|
385
384
|
|
386
385
|
assert_equal name, 'a_-1_b_1_c_-1'
|
387
386
|
assert info.has_key?(name)
|
388
387
|
assert_equal info[name]['key'], {"a" => -1, "b" => 1, "c" => -1}
|
389
388
|
ensure
|
390
|
-
|
389
|
+
@db.drop_index(@coll.name, name)
|
391
390
|
end
|
392
391
|
|
393
392
|
def test_multiple_index_cols_with_symbols
|
394
|
-
name =
|
395
|
-
info =
|
393
|
+
name = @coll.create_index([[:a, DESCENDING], [:b, ASCENDING], [:c, DESCENDING]])
|
394
|
+
info = @db.index_information(@coll.name)
|
396
395
|
assert_equal 2, info.length
|
397
396
|
|
398
397
|
assert_equal name, 'a_-1_b_1_c_-1'
|
399
398
|
assert info.has_key?(name)
|
400
399
|
assert_equal info[name]['key'], {"a" => -1, "b" => 1, "c" => -1}
|
401
400
|
ensure
|
402
|
-
|
401
|
+
@db.drop_index(@coll.name, name)
|
403
402
|
end
|
404
403
|
|
405
404
|
def test_unique_index
|
406
|
-
|
407
|
-
test =
|
405
|
+
@db.drop_collection("blah")
|
406
|
+
test = @db.collection("blah")
|
408
407
|
test.create_index("hello")
|
409
408
|
|
410
409
|
test.insert("hello" => "world")
|
411
410
|
test.insert("hello" => "mike")
|
412
411
|
test.insert("hello" => "world")
|
413
|
-
assert
|
412
|
+
assert !@db.error?
|
414
413
|
|
415
|
-
|
416
|
-
test =
|
414
|
+
@db.drop_collection("blah")
|
415
|
+
test = @db.collection("blah")
|
417
416
|
test.create_index("hello", :unique => true)
|
418
417
|
|
419
418
|
test.insert("hello" => "world")
|
@@ -424,16 +423,16 @@ class DBAPITest < Test::Unit::TestCase
|
|
424
423
|
end
|
425
424
|
|
426
425
|
def test_index_on_subfield
|
427
|
-
|
428
|
-
test =
|
426
|
+
@db.drop_collection("blah")
|
427
|
+
test = @db.collection("blah")
|
429
428
|
|
430
429
|
test.insert("hello" => {"a" => 4, "b" => 5})
|
431
430
|
test.insert("hello" => {"a" => 7, "b" => 2})
|
432
431
|
test.insert("hello" => {"a" => 4, "b" => 10})
|
433
|
-
assert
|
432
|
+
assert !@db.error?
|
434
433
|
|
435
|
-
|
436
|
-
test =
|
434
|
+
@db.drop_collection("blah")
|
435
|
+
test = @db.collection("blah")
|
437
436
|
test.create_index("hello.a", :unique => true)
|
438
437
|
|
439
438
|
test.insert("hello" => {"a" => 4, "b" => 5})
|
@@ -444,19 +443,19 @@ class DBAPITest < Test::Unit::TestCase
|
|
444
443
|
end
|
445
444
|
|
446
445
|
def test_array
|
447
|
-
|
448
|
-
|
449
|
-
|
450
|
-
rows =
|
446
|
+
@coll.remove({'$atomic' => true})
|
447
|
+
@coll.insert({'b' => [1, 2, 3]})
|
448
|
+
@coll.insert({'b' => [1, 2, 3]})
|
449
|
+
rows = @coll.find({}, {:fields => ['b']}).to_a
|
451
450
|
assert_equal 2, rows.length
|
452
451
|
assert_equal [1, 2, 3], rows[1]['b']
|
453
452
|
end
|
454
453
|
|
455
454
|
def test_regex
|
456
455
|
regex = /foobar/i
|
457
|
-
|
458
|
-
rows =
|
459
|
-
if
|
456
|
+
@coll << {'b' => regex}
|
457
|
+
rows = @coll.find({}, {:fields => ['b']}).to_a
|
458
|
+
if @version < "1.1.3"
|
460
459
|
assert_equal 1, rows.length
|
461
460
|
assert_equal regex, rows[0]['b']
|
462
461
|
else
|
@@ -466,14 +465,14 @@ class DBAPITest < Test::Unit::TestCase
|
|
466
465
|
end
|
467
466
|
|
468
467
|
def test_regex_multi_line
|
469
|
-
if
|
470
|
-
doc = <<HERE
|
468
|
+
if @version >= "1.9.1"
|
469
|
+
doc = <<HERE
|
471
470
|
the lazy brown
|
472
471
|
fox
|
473
472
|
HERE
|
474
|
-
|
475
|
-
assert
|
476
|
-
|
473
|
+
@coll.save({:doc => doc})
|
474
|
+
assert @coll.find_one({:doc => /n.*x/m})
|
475
|
+
@coll.remove
|
477
476
|
end
|
478
477
|
end
|
479
478
|
|
@@ -481,135 +480,137 @@ HERE
|
|
481
480
|
# Note: can't use Time.new because that will include fractional seconds,
|
482
481
|
# which Mongo does not store.
|
483
482
|
t = Time.at(1234567890)
|
484
|
-
|
485
|
-
rows =
|
483
|
+
@coll << {'_id' => t}
|
484
|
+
rows = @coll.find({'_id' => t}).to_a
|
486
485
|
assert_equal 1, rows.length
|
487
486
|
assert_equal t, rows[0]['_id']
|
488
487
|
end
|
489
488
|
|
490
489
|
def test_strict
|
491
|
-
assert
|
492
|
-
|
493
|
-
assert
|
490
|
+
assert !@db.strict?
|
491
|
+
@db.strict = true
|
492
|
+
assert @db.strict?
|
494
493
|
ensure
|
495
|
-
|
494
|
+
@db.strict = false
|
496
495
|
end
|
497
496
|
|
498
497
|
def test_strict_access_collection
|
499
|
-
|
498
|
+
@db.strict = true
|
500
499
|
begin
|
501
|
-
|
500
|
+
@db.collection('does-not-exist')
|
502
501
|
fail "expected exception"
|
503
502
|
rescue => ex
|
504
503
|
assert_equal Mongo::MongoDBError, ex.class
|
505
504
|
assert_equal "Collection 'does-not-exist' doesn't exist. (strict=true)", ex.to_s
|
506
505
|
ensure
|
507
|
-
|
508
|
-
|
506
|
+
@db.strict = false
|
507
|
+
@db.drop_collection('does-not-exist')
|
509
508
|
end
|
510
509
|
end
|
511
510
|
|
512
511
|
def test_strict_create_collection
|
513
|
-
|
514
|
-
|
512
|
+
@db.drop_collection('foobar')
|
513
|
+
@db.strict = true
|
515
514
|
|
516
515
|
begin
|
517
|
-
assert
|
516
|
+
assert @db.create_collection('foobar')
|
518
517
|
rescue => ex
|
519
518
|
fail "did not expect exception \"#{ex}\""
|
520
519
|
end
|
521
520
|
|
522
521
|
# Now the collection exists. This time we should see an exception.
|
523
522
|
assert_raise Mongo::MongoDBError do
|
524
|
-
|
523
|
+
@db.create_collection('foobar')
|
525
524
|
end
|
526
|
-
|
527
|
-
|
525
|
+
@db.strict = false
|
526
|
+
@db.drop_collection('foobar')
|
528
527
|
|
529
528
|
# Now we're not in strict mode - should succeed
|
530
|
-
|
531
|
-
|
532
|
-
|
529
|
+
@db.create_collection('foobar')
|
530
|
+
@db.create_collection('foobar')
|
531
|
+
@db.drop_collection('foobar')
|
533
532
|
end
|
534
533
|
|
535
534
|
def test_where
|
536
|
-
|
537
|
-
|
535
|
+
@coll.insert('a' => 2)
|
536
|
+
@coll.insert('a' => 3)
|
538
537
|
|
539
|
-
assert_equal 3,
|
540
|
-
assert_equal 1,
|
541
|
-
assert_equal 2,
|
538
|
+
assert_equal 3, @coll.count
|
539
|
+
assert_equal 1, @coll.find('$where' => BSON::Code.new('this.a > 2')).count()
|
540
|
+
assert_equal 2, @coll.find('$where' => BSON::Code.new('this.a > i', {'i' => 1})).count()
|
542
541
|
end
|
543
542
|
|
544
543
|
def test_eval
|
545
|
-
|
544
|
+
grant_admin_user_eval_role(@client)
|
545
|
+
|
546
|
+
assert_equal 3, @db.eval('function (x) {return x;}', 3)
|
546
547
|
|
547
|
-
assert_equal nil,
|
548
|
-
assert_equal 5,
|
548
|
+
assert_equal nil, @db.eval("function (x) {db.test_eval.save({y:x});}", 5)
|
549
|
+
assert_equal 5, @db.collection('test_eval').find_one['y']
|
549
550
|
|
550
|
-
assert_equal 5,
|
551
|
-
assert_equal 5,
|
552
|
-
assert_equal 5,
|
551
|
+
assert_equal 5, @db.eval("function (x, y) {return x + y;}", 2, 3)
|
552
|
+
assert_equal 5, @db.eval("function () {return 5;}")
|
553
|
+
assert_equal 5, @db.eval("2 + 3;")
|
553
554
|
|
554
|
-
assert_equal 5,
|
555
|
-
assert_equal 2,
|
556
|
-
assert_equal 5,
|
555
|
+
assert_equal 5, @db.eval(Code.new("2 + 3;"))
|
556
|
+
assert_equal 2, @db.eval(Code.new("return i;", {"i" => 2}))
|
557
|
+
assert_equal 5, @db.eval(Code.new("i + 3;", {"i" => 2}))
|
557
558
|
|
558
559
|
assert_raise OperationFailure do
|
559
|
-
|
560
|
+
@db.eval("5 ++ 5;")
|
560
561
|
end
|
561
562
|
end
|
562
563
|
|
563
564
|
def test_hint
|
564
|
-
name =
|
565
|
+
name = @coll.create_index('a')
|
565
566
|
begin
|
566
|
-
assert_nil
|
567
|
-
assert_equal 1,
|
568
|
-
assert_equal 1,
|
569
|
-
assert_equal 1,
|
570
|
-
|
571
|
-
|
572
|
-
assert_equal({'a' => 1},
|
573
|
-
assert_equal 1,
|
574
|
-
|
575
|
-
|
576
|
-
assert_equal({'a' => 1},
|
577
|
-
assert_equal 1,
|
578
|
-
|
579
|
-
|
580
|
-
assert_equal({'a' => 1},
|
581
|
-
assert_equal 1,
|
582
|
-
|
583
|
-
|
584
|
-
assert_nil
|
585
|
-
assert_equal 1,
|
567
|
+
assert_nil @coll.hint
|
568
|
+
assert_equal 1, @coll.find({'a' => 1}, :hint => 'a').to_a.size
|
569
|
+
assert_equal 1, @coll.find({'a' => 1}, :hint => ['a']).to_a.size
|
570
|
+
assert_equal 1, @coll.find({'a' => 1}, :hint => {'a' => 1}).to_a.size
|
571
|
+
|
572
|
+
@coll.hint = 'a'
|
573
|
+
assert_equal({'a' => 1}, @coll.hint)
|
574
|
+
assert_equal 1, @coll.find('a' => 1).to_a.size
|
575
|
+
|
576
|
+
@coll.hint = ['a']
|
577
|
+
assert_equal({'a' => 1}, @coll.hint)
|
578
|
+
assert_equal 1, @coll.find('a' => 1).to_a.size
|
579
|
+
|
580
|
+
@coll.hint = {'a' => 1}
|
581
|
+
assert_equal({'a' => 1}, @coll.hint)
|
582
|
+
assert_equal 1, @coll.find('a' => 1).to_a.size
|
583
|
+
|
584
|
+
@coll.hint = nil
|
585
|
+
assert_nil @coll.hint
|
586
|
+
assert_equal 1, @coll.find('a' => 1).to_a.size
|
586
587
|
ensure
|
587
|
-
|
588
|
+
@coll.drop_index(name)
|
588
589
|
end
|
589
590
|
end
|
590
591
|
|
591
592
|
def test_named_hint
|
592
|
-
name =
|
593
|
+
name = @coll.create_index('a', :name => 'named_index')
|
593
594
|
begin
|
594
|
-
assert_nil
|
595
|
-
assert_equal 1,
|
596
|
-
assert_equal 1,
|
595
|
+
assert_nil @coll.hint
|
596
|
+
assert_equal 1, @coll.find({'a' => 1}, :named_hint => 'named_index').to_a.size
|
597
|
+
assert_equal 1, @coll.find({'a' => 1}, :hint => 'a', :named_hint => "bad_hint").to_a.size
|
597
598
|
ensure
|
598
|
-
|
599
|
+
@coll.drop_index('named_index')
|
599
600
|
end
|
600
601
|
end
|
601
602
|
|
602
603
|
def test_hash_default_value_id
|
603
604
|
val = Hash.new(0)
|
604
605
|
val["x"] = 5
|
605
|
-
|
606
|
-
id =
|
606
|
+
@coll.insert val
|
607
|
+
id = @coll.find_one("x" => 5)["_id"]
|
607
608
|
assert id != 0
|
608
609
|
end
|
609
610
|
|
610
611
|
def test_group
|
611
|
-
|
612
|
-
test =
|
612
|
+
@db.drop_collection("test")
|
613
|
+
test = @db.collection("test")
|
613
614
|
|
614
615
|
assert_equal [], test.group(:initial => {"count" => 0}, :reduce => "function (obj, prev) { prev.count++; }")
|
615
616
|
assert_equal [], test.group(:initial => {"count" => 0}, :reduce => "function (obj, prev) { prev.count++; }")
|
@@ -619,26 +620,26 @@ HERE
|
|
619
620
|
test.insert("a" => 1)
|
620
621
|
|
621
622
|
assert_equal 3, test.group(:initial => {"count" => 0},
|
622
|
-
|
623
|
+
:reduce => "function (obj, prev) { prev.count++; }")[0]["count"]
|
623
624
|
assert_equal 3, test.group(:initial => {"count" => 0},
|
624
|
-
|
625
|
+
:reduce => "function (obj, prev) { prev.count++; }")[0]["count"]
|
625
626
|
assert_equal 1, test.group(:cond => {"a" => {"$gt" => 1}},
|
626
|
-
|
627
|
+
:initial => {"count" => 0}, :reduce => "function (obj, prev) { prev.count++; }")[0]["count"]
|
627
628
|
assert_equal 1, test.group(:cond => {"a" => {"$gt" => 1}},
|
628
|
-
|
629
|
+
:initial => {"count" => 0}, :reduce => "function (obj, prev) { prev.count++; }")[0]["count"]
|
629
630
|
|
630
631
|
finalize = "function (obj) { obj.f = obj.count - 1; }"
|
631
632
|
assert_equal 2, test.group(:initial => {"count" => 0},
|
632
|
-
|
633
|
+
:reduce => "function (obj, prev) { prev.count++; }", :finalize => finalize)[0]["f"]
|
633
634
|
|
634
635
|
test.insert("a" => 2, "b" => 3)
|
635
636
|
expected = [{"a" => 2, "count" => 2},
|
636
637
|
{"a" => nil, "count" => 1},
|
637
638
|
{"a" => 1, "count" => 1}]
|
638
639
|
assert_equal expected, test.group(:key => ["a"], :initial => {"count" => 0},
|
639
|
-
|
640
|
+
:reduce => "function (obj, prev) { prev.count++; }")
|
640
641
|
assert_equal expected, test.group(:key => :a, :initial => {"count" => 0},
|
641
|
-
|
642
|
+
:reduce => "function (obj, prev) { prev.count++; }")
|
642
643
|
|
643
644
|
assert_raise OperationFailure do
|
644
645
|
test.group(:initial => {}, :reduce => "5 ++ 5")
|
@@ -646,109 +647,109 @@ HERE
|
|
646
647
|
end
|
647
648
|
|
648
649
|
def test_deref
|
649
|
-
|
650
|
+
@coll.remove
|
650
651
|
|
651
|
-
assert_equal nil,
|
652
|
-
|
653
|
-
key =
|
654
|
-
assert_equal "hello",
|
652
|
+
assert_equal nil, @db.dereference(DBRef.new("test", ObjectId.new))
|
653
|
+
@coll.insert({"x" => "hello"})
|
654
|
+
key = @coll.find_one()["_id"]
|
655
|
+
assert_equal "hello", @db.dereference(DBRef.new("test", key))["x"]
|
655
656
|
|
656
|
-
assert_equal nil,
|
657
|
+
assert_equal nil, @db.dereference(DBRef.new("test", 4))
|
657
658
|
obj = {"_id" => 4}
|
658
|
-
|
659
|
-
assert_equal obj,
|
659
|
+
@coll.insert(obj)
|
660
|
+
assert_equal obj, @db.dereference(DBRef.new("test", 4))
|
660
661
|
|
661
|
-
|
662
|
-
|
663
|
-
assert_equal nil,
|
662
|
+
@coll.remove
|
663
|
+
@coll.insert({"x" => "hello"})
|
664
|
+
assert_equal nil, @db.dereference(DBRef.new("test", nil))
|
664
665
|
end
|
665
666
|
|
666
667
|
def test_save
|
667
|
-
|
668
|
+
@coll.remove
|
668
669
|
|
669
670
|
a = {"hello" => "world"}
|
670
671
|
|
671
|
-
id =
|
672
|
+
id = @coll.save(a)
|
672
673
|
assert_kind_of ObjectId, id
|
673
|
-
assert_equal 1,
|
674
|
+
assert_equal 1, @coll.count
|
674
675
|
|
675
|
-
assert_equal id,
|
676
|
-
assert_equal 1,
|
676
|
+
assert_equal id, @coll.save(a)
|
677
|
+
assert_equal 1, @coll.count
|
677
678
|
|
678
|
-
assert_equal "world",
|
679
|
+
assert_equal "world", @coll.find_one()["hello"]
|
679
680
|
|
680
681
|
a["hello"] = "mike"
|
681
|
-
|
682
|
-
assert_equal 1,
|
682
|
+
@coll.save(a)
|
683
|
+
assert_equal 1, @coll.count
|
683
684
|
|
684
|
-
assert_equal "mike",
|
685
|
+
assert_equal "mike", @coll.find_one()["hello"]
|
685
686
|
|
686
|
-
|
687
|
-
assert_equal 2,
|
687
|
+
@coll.save({"hello" => "world"})
|
688
|
+
assert_equal 2, @coll.count
|
688
689
|
end
|
689
690
|
|
690
691
|
def test_save_long
|
691
|
-
|
692
|
-
|
693
|
-
assert_equal 9223372036854775807,
|
692
|
+
@coll.remove
|
693
|
+
@coll.insert("x" => 9223372036854775807)
|
694
|
+
assert_equal 9223372036854775807, @coll.find_one()["x"]
|
694
695
|
end
|
695
696
|
|
696
697
|
def test_find_by_oid
|
697
|
-
|
698
|
+
@coll.remove
|
698
699
|
|
699
|
-
|
700
|
-
id =
|
700
|
+
@coll.save("hello" => "mike")
|
701
|
+
id = @coll.save("hello" => "world")
|
701
702
|
assert_kind_of ObjectId, id
|
702
703
|
|
703
|
-
assert_equal "world",
|
704
|
-
|
704
|
+
assert_equal "world", @coll.find_one(:_id => id)["hello"]
|
705
|
+
@coll.find(:_id => id).to_a.each do |doc|
|
705
706
|
assert_equal "world", doc["hello"]
|
706
707
|
end
|
707
708
|
|
708
709
|
id = ObjectId.from_string(id.to_s)
|
709
|
-
assert_equal "world",
|
710
|
+
assert_equal "world", @coll.find_one(:_id => id)["hello"]
|
710
711
|
end
|
711
712
|
|
712
713
|
def test_save_with_object_that_has_id_but_does_not_actually_exist_in_collection
|
713
|
-
|
714
|
+
@coll.remove
|
714
715
|
|
715
716
|
a = {'_id' => '1', 'hello' => 'world'}
|
716
|
-
|
717
|
-
assert_equal(1,
|
718
|
-
assert_equal("world",
|
717
|
+
@coll.save(a)
|
718
|
+
assert_equal(1, @coll.count)
|
719
|
+
assert_equal("world", @coll.find_one()["hello"])
|
719
720
|
|
720
721
|
a["hello"] = "mike"
|
721
|
-
|
722
|
-
assert_equal(1,
|
723
|
-
assert_equal("mike",
|
722
|
+
@coll.save(a)
|
723
|
+
assert_equal(1, @coll.count)
|
724
|
+
assert_equal("mike", @coll.find_one()["hello"])
|
724
725
|
end
|
725
726
|
|
726
727
|
def test_collection_names_errors
|
727
728
|
assert_raise TypeError do
|
728
|
-
|
729
|
+
@db.collection(5)
|
729
730
|
end
|
730
731
|
assert_raise Mongo::InvalidNSName do
|
731
|
-
|
732
|
+
@db.collection("")
|
732
733
|
end
|
733
734
|
assert_raise Mongo::InvalidNSName do
|
734
|
-
|
735
|
+
@db.collection("te$t")
|
735
736
|
end
|
736
737
|
assert_raise Mongo::InvalidNSName do
|
737
|
-
|
738
|
+
@db.collection(".test")
|
738
739
|
end
|
739
740
|
assert_raise Mongo::InvalidNSName do
|
740
|
-
|
741
|
+
@db.collection("test.")
|
741
742
|
end
|
742
743
|
assert_raise Mongo::InvalidNSName do
|
743
|
-
|
744
|
+
@db.collection("tes..t")
|
744
745
|
end
|
745
746
|
end
|
746
747
|
|
747
748
|
def test_rename_collection
|
748
|
-
|
749
|
-
|
750
|
-
a =
|
751
|
-
b =
|
749
|
+
@db.drop_collection("foo")
|
750
|
+
@db.drop_collection("bar")
|
751
|
+
a = @db.collection("foo")
|
752
|
+
b = @db.collection("bar")
|
752
753
|
|
753
754
|
assert_raise TypeError do
|
754
755
|
a.rename(5)
|
@@ -784,9 +785,9 @@ HERE
|
|
784
785
|
|
785
786
|
# doesn't really test functionality, just that the option is set correctly
|
786
787
|
def test_snapshot
|
787
|
-
|
788
|
+
@db.collection("test").find({}, :snapshot => true).to_a
|
788
789
|
assert_raise OperationFailure do
|
789
|
-
|
790
|
+
@db.collection("test").find({}, :snapshot => true, :sort => 'a').to_a
|
790
791
|
end
|
791
792
|
end
|
792
793
|
|
@@ -807,9 +808,9 @@ HERE
|
|
807
808
|
assert_equal "UTF-8", utf8.encoding.name
|
808
809
|
assert_equal "ISO-8859-1", iso8859.encoding.name
|
809
810
|
|
810
|
-
|
811
|
-
|
812
|
-
doc =
|
811
|
+
@coll.remove
|
812
|
+
@coll.save("default" => default, "utf8" => utf8, "iso8859" => iso8859)
|
813
|
+
doc = @coll.find_one()
|
813
814
|
|
814
815
|
assert_equal "UTF-8", doc["default"].encoding.name
|
815
816
|
assert_equal "UTF-8", doc["utf8"].encoding.name
|