/vendor/bundle/jruby/2.1/gems/redis-3.0.7/test/scanning_test.rb

  1# encoding: UTF-8
  2
  3require File.expand_path("helper", File.dirname(__FILE__))
  4
  5unless defined?(Enumerator)
  6  Enumerator = Enumerable::Enumerator
  7end
  8
  9class TestScanning < Test::Unit::TestCase
 10
 11  include Helper::Client
 12
 13  def test_scan_basic
 14    target_version "2.7.105" do
 15      r.debug :populate, 1000
 16
 17      cursor = 0
 18      all_keys   = []
 19      loop {
 20        cursor, keys = r.scan cursor
 21        all_keys += keys
 22        break if cursor == "0"
 23      }
 24
 25      assert_equal 1000, all_keys.uniq.size
 26    end
 27  end
 28
 29  def test_scan_count
 30    target_version "2.7.105" do
 31      r.debug :populate, 1000
 32
 33      cursor = 0
 34      all_keys   = []
 35      loop {
 36        cursor, keys = r.scan cursor, :count => 5
 37        all_keys += keys
 38        break if cursor == "0"
 39      }
 40
 41      assert_equal 1000, all_keys.uniq.size
 42    end
 43  end
 44
 45  def test_scan_match
 46    target_version "2.7.105" do
 47      r.debug :populate, 1000
 48
 49      cursor = 0
 50      all_keys   = []
 51      loop {
 52        cursor, keys = r.scan cursor, :match => "key:1??"
 53        all_keys += keys
 54        break if cursor == "0"
 55      }
 56
 57      assert_equal 100, all_keys.uniq.size
 58    end
 59  end
 60
 61  def test_scan_each_enumerator
 62    target_version "2.7.105" do
 63
 64      r.debug :populate, 1000
 65
 66      scan_enumerator = r.scan_each
 67      assert_equal true, scan_enumerator.is_a?(::Enumerator)
 68
 69      keys_from_scan = scan_enumerator.to_a.uniq
 70      all_keys = r.keys "*"
 71
 72      assert all_keys.sort == keys_from_scan.sort
 73    end
 74  end
 75
 76  def test_scan_each_enumerator_match
 77    target_version "2.7.105" do
 78
 79      r.debug :populate, 1000
 80
 81      keys_from_scan = r.scan_each(:match => "key:1??").to_a.uniq
 82      all_keys = r.keys "key:1??"
 83
 84      assert all_keys.sort == keys_from_scan.sort
 85    end
 86  end
 87
 88  def test_scan_each_block
 89    target_version "2.7.105" do
 90
 91      r.debug :populate, 100
 92
 93      keys_from_scan   = []
 94      r.scan_each {|key|
 95        keys_from_scan << key
 96      }
 97
 98      all_keys = r.keys "*"
 99
100      assert all_keys.sort == keys_from_scan.uniq.sort
101    end
102  end
103
104  def test_scan_each_block_match
105    target_version "2.7.105" do
106
107      r.debug :populate, 100
108
109      keys_from_scan   = []
110      r.scan_each(:match => "key:1?") {|key|
111        keys_from_scan << key
112      }
113
114      all_keys = r.keys "key:1?"
115
116      assert all_keys.sort == keys_from_scan.uniq.sort
117    end
118  end
119
120  def test_sscan_with_encoding
121    target_version "2.7.105" do
122      [:intset, :hashtable].each do |enc|
123        r.del "set"
124
125        prefix = ""
126        prefix = "ele:" if enc == :hashtable
127
128        elements = []
129        100.times { |j| elements << "#{prefix}#{j}" }
130
131        r.sadd "set", elements
132
133        assert_equal enc.to_s, r.object("encoding", "set")
134
135        cursor = 0
136        all_keys   = []
137        loop {
138          cursor, keys = r.sscan "set", cursor
139          all_keys += keys
140          break if cursor == "0"
141        }
142
143        assert_equal 100, all_keys.uniq.size
144      end
145    end
146  end
147
148  def test_sscan_each_enumerator
149    target_version "2.7.105" do
150      elements = []
151      100.times { |j| elements << "ele:#{j}" }
152      r.sadd "set", elements
153
154      scan_enumerator = r.sscan_each("set")
155      assert_equal true, scan_enumerator.is_a?(::Enumerator)
156
157      keys_from_scan = scan_enumerator.to_a.uniq
158      all_keys = r.smembers("set")
159
160      assert all_keys.sort == keys_from_scan.sort
161    end
162  end
163
164  def test_sscan_each_enumerator_match
165    target_version "2.7.105" do
166      elements = []
167      100.times { |j| elements << "ele:#{j}" }
168      r.sadd "set", elements
169
170      keys_from_scan = r.sscan_each("set", :match => "ele:1?").to_a.uniq
171
172      all_keys = r.smembers("set").grep(/^ele:1.$/)
173
174      assert all_keys.sort == keys_from_scan.sort
175    end
176  end
177
178  def test_sscan_each_enumerator_block
179    target_version "2.7.105" do
180      elements = []
181      100.times { |j| elements << "ele:#{j}" }
182      r.sadd "set", elements
183
184      keys_from_scan = []
185      r.sscan_each("set") do |key|
186        keys_from_scan << key
187      end
188
189      all_keys = r.smembers("set")
190
191      assert all_keys.sort == keys_from_scan.uniq.sort
192    end
193  end
194
195  def test_sscan_each_enumerator_block_match
196    target_version "2.7.105" do
197      elements = []
198      100.times { |j| elements << "ele:#{j}" }
199      r.sadd "set", elements
200
201      keys_from_scan = []
202      r.sscan_each("set", :match => "ele:1?") do |key|
203        keys_from_scan << key
204      end
205
206      all_keys = r.smembers("set").grep(/^ele:1.$/)
207
208      assert all_keys.sort == keys_from_scan.uniq.sort
209    end
210  end
211
212  def test_hscan_with_encoding
213    target_version "2.7.105" do
214      [:ziplist, :hashtable].each do |enc|
215        r.del "set"
216
217        count = 1000
218        count = 30 if enc == :ziplist
219
220        elements = []
221        count.times { |j| elements << "key:#{j}" << j.to_s }
222
223        r.hmset "hash", *elements
224
225        assert_equal enc.to_s, r.object("encoding", "hash")
226
227        cursor = 0
228        all_key_values   = []
229        loop {
230          cursor, key_values = r.hscan "hash", cursor
231          all_key_values.concat key_values
232          break if cursor == "0"
233        }
234
235        keys2 = []
236        all_key_values.each do |k, v|
237          assert_equal "key:#{v}", k
238          keys2 << k
239        end
240
241        assert_equal count, keys2.uniq.size
242      end
243    end
244  end
245
246  def test_hscan_each_enumerator
247    target_version "2.7.105" do
248      count = 1000
249      elements = []
250      count.times { |j| elements << "key:#{j}" << j.to_s }
251      r.hmset "hash", *elements
252
253      scan_enumerator = r.hscan_each("hash")
254      assert_equal true, scan_enumerator.is_a?(::Enumerator)
255
256      keys_from_scan = scan_enumerator.to_a.uniq
257      all_keys = r.hgetall("hash").to_a
258
259      assert all_keys.sort == keys_from_scan.sort
260    end
261  end
262
263  def test_hscan_each_enumerator_match
264    target_version "2.7.105" do
265      count = 100
266      elements = []
267      count.times { |j| elements << "key:#{j}" << j.to_s }
268      r.hmset "hash", *elements
269
270      keys_from_scan = r.hscan_each("hash", :match => "key:1?").to_a.uniq
271      all_keys = r.hgetall("hash").to_a.select{|k,v| k =~ /^key:1.$/}
272
273      assert all_keys.sort == keys_from_scan.sort
274    end
275  end
276
277  def test_hscan_each_block
278    target_version "2.7.105" do
279      count = 1000
280      elements = []
281      count.times { |j| elements << "key:#{j}" << j.to_s }
282      r.hmset "hash", *elements
283
284      keys_from_scan = []
285      r.hscan_each("hash") do |field, value|
286        keys_from_scan << [field, value]
287      end
288      all_keys = r.hgetall("hash").to_a
289
290      assert all_keys.sort == keys_from_scan.uniq.sort
291    end
292  end
293
294  def test_hscan_each_block_match
295    target_version "2.7.105" do
296      count = 1000
297      elements = []
298      count.times { |j| elements << "key:#{j}" << j.to_s }
299      r.hmset "hash", *elements
300
301      keys_from_scan = []
302      r.hscan_each("hash", :match => "key:1?") do |field, value|
303        keys_from_scan << [field, value]
304      end
305      all_keys = r.hgetall("hash").to_a.select{|k,v| k =~ /^key:1.$/}
306
307      assert all_keys.sort == keys_from_scan.uniq.sort
308    end
309  end
310
311  def test_zscan_with_encoding
312    target_version "2.7.105" do
313      [:ziplist, :skiplist].each do |enc|
314        r.del "zset"
315
316        count = 1000
317        count = 30 if enc == :ziplist
318
319        elements = []
320        count.times { |j| elements << j << "key:#{j}" }
321
322        r.zadd "zset", elements
323
324        assert_equal enc.to_s, r.object("encoding", "zset")
325
326        cursor = 0
327        all_key_scores   = []
328        loop {
329          cursor, key_scores = r.zscan "zset", cursor
330          all_key_scores.concat  key_scores
331          break if cursor == "0"
332        }
333
334        keys2 = []
335        all_key_scores.each do |k, v|
336          assert_equal true, v.is_a?(Float)
337          assert_equal "key:#{Integer(v)}", k
338          keys2 << k
339        end
340
341        assert_equal count, keys2.uniq.size
342      end
343    end
344  end
345
346  def test_zscan_each_enumerator
347    target_version "2.7.105" do
348      count = 1000
349      elements = []
350      count.times { |j| elements << j << "key:#{j}" }
351      r.zadd "zset", elements
352
353      scan_enumerator = r.zscan_each "zset"
354      assert_equal true, scan_enumerator.is_a?(::Enumerator)
355
356      scores_from_scan = scan_enumerator.to_a.uniq
357      member_scores = r.zrange("zset", 0, -1, :with_scores => true)
358
359      assert member_scores.sort == scores_from_scan.sort
360    end
361  end
362
363  def test_zscan_each_enumerator_match
364    target_version "2.7.105" do
365      count = 1000
366      elements = []
367      count.times { |j| elements << j << "key:#{j}" }
368      r.zadd "zset", elements
369
370      scores_from_scan = r.zscan_each("zset", :match => "key:1??").to_a.uniq
371      member_scores = r.zrange("zset", 0, -1, :with_scores => true)
372      filtered_members = member_scores.select{|k,s| k =~ /^key:1..$/}
373
374      assert filtered_members.sort == scores_from_scan.sort
375    end
376  end
377
378  def test_zscan_each_block
379    target_version "2.7.105" do
380      count = 1000
381      elements = []
382      count.times { |j| elements << j << "key:#{j}" }
383      r.zadd "zset", elements
384
385      scores_from_scan = []
386      r.zscan_each("zset") do |member, score|
387        scores_from_scan << [member, score]
388      end
389      member_scores = r.zrange("zset", 0, -1, :with_scores => true)
390
391      assert member_scores.sort == scores_from_scan.sort
392    end
393  end
394
395  def test_zscan_each_block_match
396    target_version "2.7.105" do
397      count = 1000
398      elements = []
399      count.times { |j| elements << j << "key:#{j}" }
400      r.zadd "zset", elements
401
402      scores_from_scan = []
403      r.zscan_each("zset", :match => "key:1??") do |member, score|
404        scores_from_scan << [member, score]
405      end
406      member_scores = r.zrange("zset", 0, -1, :with_scores => true)
407      filtered_members = member_scores.select{|k,s| k =~ /^key:1..$/}
408
409      assert filtered_members.sort == scores_from_scan.sort
410    end
411  end
412
413end