mongo 1.10.2 → 1.11.1
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.
- 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
|