fakeredis 0.3.0 → 0.3.1
Sign up to get free protection for your applications and to get access to all the features.
- data/lib/fakeredis/version.rb +1 -1
- data/lib/redis/connection/memory.rb +109 -135
- metadata +6 -6
data/lib/fakeredis/version.rb
CHANGED
@@ -202,32 +202,25 @@ class Redis
|
|
202
202
|
end
|
203
203
|
|
204
204
|
def hgetall(key)
|
205
|
-
|
206
|
-
|
207
|
-
when Hash then hash
|
208
|
-
else fail "Not a hash"
|
209
|
-
end
|
205
|
+
data_type_check(key, Hash)
|
206
|
+
@data[key] || {}
|
210
207
|
end
|
211
208
|
|
212
209
|
def hget(key, field)
|
213
|
-
|
214
|
-
|
215
|
-
@data[key][field.to_s]
|
210
|
+
data_type_check(key, Hash)
|
211
|
+
@data[key] && @data[key][field.to_s]
|
216
212
|
end
|
217
213
|
|
218
214
|
def hdel(key, field)
|
219
|
-
|
220
|
-
|
221
|
-
@data[key].delete(field)
|
215
|
+
data_type_check(key, Hash)
|
216
|
+
@data[key] && @data[key].delete(field)
|
222
217
|
remove_key_for_empty_collection(key)
|
223
218
|
end
|
224
219
|
|
225
220
|
def hkeys(key)
|
226
|
-
|
227
|
-
|
228
|
-
|
229
|
-
else fail "Not a hash"
|
230
|
-
end
|
221
|
+
data_type_check(key, Hash)
|
222
|
+
return [] if @data[key].nil?
|
223
|
+
@data[key].keys
|
231
224
|
end
|
232
225
|
|
233
226
|
def keys(pattern = "*")
|
@@ -260,31 +253,29 @@ class Redis
|
|
260
253
|
end
|
261
254
|
|
262
255
|
def llen(key)
|
263
|
-
|
264
|
-
|
256
|
+
data_type_check(key, Array)
|
257
|
+
return 0 unless @data[key]
|
265
258
|
@data[key].size
|
266
259
|
end
|
267
260
|
|
268
261
|
def lrange(key, startidx, endidx)
|
269
|
-
|
270
|
-
|
271
|
-
@data[key][startidx..endidx]
|
262
|
+
data_type_check(key, Array)
|
263
|
+
@data[key] && @data[key][startidx..endidx]
|
272
264
|
end
|
273
265
|
|
274
266
|
def ltrim(key, start, stop)
|
275
|
-
|
267
|
+
data_type_check(key, Array)
|
276
268
|
return unless @data[key]
|
277
269
|
@data[key] = @data[key][start..stop]
|
278
270
|
end
|
279
271
|
|
280
272
|
def lindex(key, index)
|
281
|
-
|
282
|
-
|
283
|
-
@data[key][index]
|
273
|
+
data_type_check(key, Array)
|
274
|
+
@data[key] && @data[key][index]
|
284
275
|
end
|
285
276
|
|
286
277
|
def linsert(key, where, pivot, value)
|
287
|
-
|
278
|
+
data_type_check(key, Array)
|
288
279
|
return unless @data[key]
|
289
280
|
index = @data[key].index(pivot)
|
290
281
|
case where
|
@@ -295,14 +286,14 @@ class Redis
|
|
295
286
|
end
|
296
287
|
|
297
288
|
def lset(key, index, value)
|
298
|
-
|
289
|
+
data_type_check(key, Array)
|
299
290
|
return unless @data[key]
|
300
|
-
raise RuntimeError
|
291
|
+
raise RuntimeError if index >= @data[key].size
|
301
292
|
@data[key][index] = value
|
302
293
|
end
|
303
294
|
|
304
295
|
def lrem(key, count, value)
|
305
|
-
|
296
|
+
data_type_check(key, Array)
|
306
297
|
return unless @data[key]
|
307
298
|
old_size = @data[key].size
|
308
299
|
diff =
|
@@ -320,107 +311,100 @@ class Redis
|
|
320
311
|
end
|
321
312
|
|
322
313
|
def rpush(key, value)
|
314
|
+
data_type_check(key, Array)
|
323
315
|
@data[key] ||= []
|
324
|
-
fail "Not a list" unless @data[key].is_a?(Array)
|
325
316
|
@data[key].push(value)
|
317
|
+
@data[key].size
|
326
318
|
end
|
327
319
|
|
328
320
|
def rpushx(key, value)
|
321
|
+
data_type_check(key, Array)
|
329
322
|
return unless @data[key]
|
330
|
-
fail "Not a list" unless @data[key].is_a?(Array)
|
331
323
|
rpush(key, value)
|
332
324
|
end
|
333
325
|
|
334
326
|
def lpush(key, value)
|
327
|
+
data_type_check(key, Array)
|
335
328
|
@data[key] ||= []
|
336
|
-
|
337
|
-
@data[key] = [value] + @data[key]
|
329
|
+
@data[key].unshift(value)
|
338
330
|
@data[key].size
|
339
331
|
end
|
340
332
|
|
341
333
|
def lpushx(key, value)
|
334
|
+
data_type_check(key, Array)
|
342
335
|
return unless @data[key]
|
343
|
-
fail "Not a list" unless @data[key].is_a?(Array)
|
344
336
|
lpush(key, value)
|
345
337
|
end
|
346
338
|
|
347
339
|
def rpop(key)
|
348
|
-
|
340
|
+
data_type_check(key, Array)
|
341
|
+
return unless @data[key]
|
349
342
|
@data[key].pop
|
350
343
|
end
|
351
344
|
|
352
345
|
def rpoplpush(key1, key2)
|
353
|
-
|
354
|
-
elem =
|
346
|
+
data_type_check(key1, Array)
|
347
|
+
elem = rpop(key1)
|
355
348
|
lpush(key2, elem)
|
356
349
|
end
|
357
350
|
|
358
351
|
def lpop(key)
|
352
|
+
data_type_check(key, Array)
|
359
353
|
return unless @data[key]
|
360
|
-
|
361
|
-
@data[key].delete_at(0)
|
354
|
+
@data[key].shift
|
362
355
|
end
|
363
356
|
|
364
357
|
def smembers(key)
|
365
|
-
|
366
|
-
|
367
|
-
|
368
|
-
when Set then set.to_a.reverse
|
369
|
-
end
|
358
|
+
data_type_check(key, Set)
|
359
|
+
return [] unless @data[key]
|
360
|
+
@data[key].to_a.reverse
|
370
361
|
end
|
371
362
|
|
372
363
|
def sismember(key, value)
|
373
|
-
|
374
|
-
|
375
|
-
|
376
|
-
when Set then set.include?(value.to_s)
|
377
|
-
end
|
364
|
+
data_type_check(key, Set)
|
365
|
+
return false unless @data[key]
|
366
|
+
@data[key].include?(value.to_s)
|
378
367
|
end
|
379
368
|
|
380
369
|
def sadd(key, value)
|
381
|
-
|
382
|
-
|
383
|
-
|
384
|
-
|
370
|
+
data_type_check(key, Set)
|
371
|
+
if @data[key]
|
372
|
+
!!@data[key].add?(value.to_s)
|
373
|
+
else
|
374
|
+
@data[key] = Set.new([value.to_s])
|
375
|
+
true
|
385
376
|
end
|
386
377
|
end
|
387
378
|
|
388
379
|
def srem(key, value)
|
389
|
-
|
390
|
-
deleted =
|
391
|
-
case set = @data[key]
|
392
|
-
when nil then false
|
393
|
-
when Set then !!set.delete?(value.to_s)
|
394
|
-
end
|
395
|
-
|
380
|
+
data_type_check(key, Set)
|
381
|
+
deleted = !!(@data[key] && @data[key].delete?(value.to_s))
|
396
382
|
remove_key_for_empty_collection(key)
|
397
383
|
deleted
|
398
384
|
end
|
399
385
|
|
400
386
|
def smove(source, destination, value)
|
401
|
-
|
387
|
+
data_type_check(destination, Set)
|
402
388
|
result = self.srem(source, value)
|
403
389
|
self.sadd(destination, value) if result
|
404
390
|
result
|
405
391
|
end
|
406
392
|
|
407
393
|
def spop(key)
|
408
|
-
|
394
|
+
data_type_check(key, Set)
|
409
395
|
elem = srandmember(key)
|
410
396
|
srem(key, elem)
|
411
397
|
elem
|
412
398
|
end
|
413
399
|
|
414
400
|
def scard(key)
|
415
|
-
|
416
|
-
|
417
|
-
|
418
|
-
when Set then set.size
|
419
|
-
end
|
401
|
+
data_type_check(key, Set)
|
402
|
+
return 0 unless @data[key]
|
403
|
+
@data[key].size
|
420
404
|
end
|
421
405
|
|
422
406
|
def sinter(*keys)
|
423
|
-
keys.each { |k|
|
407
|
+
keys.each { |k| data_type_check(k, Set) }
|
424
408
|
return Set.new if keys.any? { |k| @data[k].nil? }
|
425
409
|
keys = keys.map { |k| @data[k] || Set.new }
|
426
410
|
keys.inject do |set, key|
|
@@ -429,13 +413,13 @@ class Redis
|
|
429
413
|
end
|
430
414
|
|
431
415
|
def sinterstore(destination, *keys)
|
432
|
-
|
416
|
+
data_type_check(destination, Set)
|
433
417
|
result = sinter(*keys)
|
434
418
|
@data[destination] = Set.new(result)
|
435
419
|
end
|
436
420
|
|
437
421
|
def sunion(*keys)
|
438
|
-
keys.each { |k|
|
422
|
+
keys.each { |k| data_type_check(k, Set) }
|
439
423
|
keys = keys.map { |k| @data[k] || Set.new }
|
440
424
|
keys.inject(Set.new) do |set, key|
|
441
425
|
set | key
|
@@ -443,13 +427,13 @@ class Redis
|
|
443
427
|
end
|
444
428
|
|
445
429
|
def sunionstore(destination, *keys)
|
446
|
-
|
430
|
+
data_type_check(destination, Set)
|
447
431
|
result = sunion(*keys)
|
448
432
|
@data[destination] = Set.new(result)
|
449
433
|
end
|
450
434
|
|
451
435
|
def sdiff(key1, *keys)
|
452
|
-
[key1, *keys].each { |k|
|
436
|
+
[key1, *keys].each { |k| data_type_check(k, Set) }
|
453
437
|
keys = keys.map { |k| @data[k] || Set.new }
|
454
438
|
keys.inject(@data[key1]) do |memo, set|
|
455
439
|
memo - set
|
@@ -457,17 +441,15 @@ class Redis
|
|
457
441
|
end
|
458
442
|
|
459
443
|
def sdiffstore(destination, key1, *keys)
|
460
|
-
|
444
|
+
data_type_check(destination, Set)
|
461
445
|
result = sdiff(key1, *keys)
|
462
446
|
@data[destination] = Set.new(result)
|
463
447
|
end
|
464
448
|
|
465
449
|
def srandmember(key)
|
466
|
-
|
467
|
-
|
468
|
-
|
469
|
-
when Set then set.to_a[rand(set.size)]
|
470
|
-
end
|
450
|
+
data_type_check(key, Set)
|
451
|
+
return nil unless @data[key]
|
452
|
+
@data[key].to_a[rand(@data[key].size)]
|
471
453
|
end
|
472
454
|
|
473
455
|
def del(*keys)
|
@@ -527,69 +509,71 @@ class Redis
|
|
527
509
|
end
|
528
510
|
|
529
511
|
def hset(key, field, value)
|
512
|
+
data_type_check(key, Hash)
|
530
513
|
field = field.to_s
|
531
|
-
|
532
|
-
|
533
|
-
|
534
|
-
|
514
|
+
if @data[key]
|
515
|
+
result = !@data[key].include?(field)
|
516
|
+
@data[key][field] = value.to_s
|
517
|
+
result
|
518
|
+
else
|
519
|
+
@data[key] = { field => value.to_s }
|
520
|
+
true
|
535
521
|
end
|
536
522
|
end
|
537
523
|
|
538
524
|
def hsetnx(key, field, value)
|
525
|
+
data_type_check(key, Hash)
|
539
526
|
field = field.to_s
|
540
|
-
return false if
|
527
|
+
return false if @data[key] && @data[key][field]
|
541
528
|
hset(key, field, value)
|
542
529
|
end
|
543
530
|
|
544
531
|
def hmset(key, *fields)
|
532
|
+
data_type_check(key, Hash)
|
545
533
|
@data[key] ||= {}
|
546
|
-
fail "Not a hash" unless @data[key].is_a?(Hash)
|
547
534
|
fields.each_slice(2) do |field|
|
548
535
|
@data[key][field[0].to_s] = field[1].to_s
|
549
536
|
end
|
550
537
|
end
|
551
538
|
|
552
539
|
def hmget(key, *fields)
|
540
|
+
data_type_check(key, Hash)
|
553
541
|
values = []
|
554
|
-
fields.
|
542
|
+
fields.map do |field|
|
555
543
|
field = field.to_s
|
556
|
-
|
557
|
-
|
558
|
-
|
559
|
-
|
544
|
+
if @data[key]
|
545
|
+
@data[key][field]
|
546
|
+
else
|
547
|
+
nil
|
560
548
|
end
|
561
549
|
end
|
562
|
-
values
|
563
550
|
end
|
564
551
|
|
565
552
|
def hlen(key)
|
566
|
-
|
567
|
-
|
568
|
-
|
569
|
-
else fail "Not a hash"
|
570
|
-
end
|
553
|
+
data_type_check(key, Hash)
|
554
|
+
return 0 unless @data[key]
|
555
|
+
@data[key].size
|
571
556
|
end
|
572
557
|
|
573
558
|
def hvals(key)
|
574
|
-
|
575
|
-
|
576
|
-
|
577
|
-
else fail "Not a hash"
|
578
|
-
end
|
559
|
+
data_type_check(key, Hash)
|
560
|
+
return [] unless @data[key]
|
561
|
+
@data[key].values
|
579
562
|
end
|
580
563
|
|
581
564
|
def hincrby(key, field, increment)
|
582
|
-
|
583
|
-
|
584
|
-
|
585
|
-
|
565
|
+
data_type_check(key, Hash)
|
566
|
+
if @data[key]
|
567
|
+
@data[key][field] = (@data[key][field.to_s].to_i + increment.to_i).to_s
|
568
|
+
else
|
569
|
+
@data[key] = { field => increment.to_s }
|
586
570
|
end
|
587
571
|
@data[key][field].to_i
|
588
572
|
end
|
589
573
|
|
590
574
|
def hexists(key, field)
|
591
|
-
|
592
|
-
|
575
|
+
data_type_check(key, Hash)
|
576
|
+
return false unless @data[key]
|
593
577
|
@data[key].key?(field)
|
594
578
|
end
|
595
579
|
|
@@ -705,7 +689,7 @@ class Redis
|
|
705
689
|
end
|
706
690
|
|
707
691
|
def zadd(key, score, value)
|
708
|
-
|
692
|
+
data_type_check(key, ZSet)
|
709
693
|
@data[key] ||= ZSet.new
|
710
694
|
exists = @data[key].key?(value.to_s)
|
711
695
|
@data[key][value.to_s] = score.to_i
|
@@ -713,7 +697,7 @@ class Redis
|
|
713
697
|
end
|
714
698
|
|
715
699
|
def zrem(key, value)
|
716
|
-
|
700
|
+
data_type_check(key, ZSet)
|
717
701
|
exists = false
|
718
702
|
exists = @data[key].delete(value.to_s) if @data[key]
|
719
703
|
remove_key_for_empty_collection(key)
|
@@ -721,40 +705,40 @@ class Redis
|
|
721
705
|
end
|
722
706
|
|
723
707
|
def zcard(key)
|
724
|
-
|
708
|
+
data_type_check(key, ZSet)
|
725
709
|
@data[key] ? @data[key].size : 0
|
726
710
|
end
|
727
711
|
|
728
712
|
def zscore(key, value)
|
729
|
-
|
713
|
+
data_type_check(key, ZSet)
|
730
714
|
@data[key] && @data[key][value.to_s].to_s
|
731
715
|
end
|
732
716
|
|
733
717
|
def zcount(key, min, max)
|
734
|
-
|
718
|
+
data_type_check(key, ZSet)
|
735
719
|
return 0 unless @data[key]
|
736
720
|
zrange_select_by_score(key, min, max).size
|
737
721
|
end
|
738
722
|
|
739
723
|
def zincrby(key, num, value)
|
740
|
-
|
724
|
+
data_type_check(key, ZSet)
|
741
725
|
@data[key][value.to_s] ||= 0
|
742
726
|
@data[key][value.to_s] += num
|
743
727
|
@data[key][value.to_s].to_s
|
744
728
|
end
|
745
729
|
|
746
730
|
def zrank(key, value)
|
747
|
-
|
731
|
+
data_type_check(key, ZSet)
|
748
732
|
@data[key].keys.sort_by {|k| @data[key][k] }.index(value.to_s)
|
749
733
|
end
|
750
734
|
|
751
735
|
def zrevrank(key, value)
|
752
|
-
|
736
|
+
data_type_check(key, ZSet)
|
753
737
|
@data[key].keys.sort_by {|k| -@data[key][k] }.index(value.to_s)
|
754
738
|
end
|
755
739
|
|
756
740
|
def zrange(key, start, stop, with_scores = nil)
|
757
|
-
|
741
|
+
data_type_check(key, ZSet)
|
758
742
|
return [] unless @data[key]
|
759
743
|
|
760
744
|
if with_scores
|
@@ -765,7 +749,7 @@ class Redis
|
|
765
749
|
end
|
766
750
|
|
767
751
|
def zrevrange(key, start, stop, with_scores = nil)
|
768
|
-
|
752
|
+
data_type_check(key, ZSet)
|
769
753
|
return [] unless @data[key]
|
770
754
|
|
771
755
|
if with_scores
|
@@ -776,7 +760,7 @@ class Redis
|
|
776
760
|
end
|
777
761
|
|
778
762
|
def zrangebyscore(key, min, max, with_scores = nil)
|
779
|
-
|
763
|
+
data_type_check(key, ZSet)
|
780
764
|
return [] unless @data[key]
|
781
765
|
|
782
766
|
range = zrange_select_by_score(key, min, max)
|
@@ -788,7 +772,7 @@ class Redis
|
|
788
772
|
end
|
789
773
|
|
790
774
|
def zrevrangebyscore(key, max, min, with_scores = nil)
|
791
|
-
|
775
|
+
data_type_check(key, ZSet)
|
792
776
|
return [] unless @data[key]
|
793
777
|
|
794
778
|
range = zrange_select_by_score(key, min, max)
|
@@ -800,7 +784,7 @@ class Redis
|
|
800
784
|
end
|
801
785
|
|
802
786
|
def zinterstore(out, _, *keys)
|
803
|
-
|
787
|
+
data_type_check(out, ZSet)
|
804
788
|
|
805
789
|
hashes = keys.map do |src|
|
806
790
|
case @data[src]
|
@@ -824,22 +808,6 @@ class Redis
|
|
824
808
|
|
825
809
|
private
|
826
810
|
|
827
|
-
def is_a_set?(key)
|
828
|
-
@data[key].is_a?(Set) || @data[key].nil?
|
829
|
-
end
|
830
|
-
|
831
|
-
def fail_unless_set(key)
|
832
|
-
fail "Not a set" unless is_a_set?(key)
|
833
|
-
end
|
834
|
-
|
835
|
-
def is_a_zset?(key)
|
836
|
-
@data[key].is_a?(ZSet) || @data[key].nil?
|
837
|
-
end
|
838
|
-
|
839
|
-
def fail_unless_zset(key)
|
840
|
-
fail "Not a sorted set" unless is_a_zset?(key)
|
841
|
-
end
|
842
|
-
|
843
811
|
def zrange_select_by_score(key, min, max)
|
844
812
|
@data[key].reject {|_,v| v < min || v > max }
|
845
813
|
end
|
@@ -847,6 +815,12 @@ class Redis
|
|
847
815
|
def remove_key_for_empty_collection(key)
|
848
816
|
del(key) if @data[key] && @data[key].empty?
|
849
817
|
end
|
818
|
+
|
819
|
+
def data_type_check(key, klass)
|
820
|
+
if @data[key] && !@data[key].is_a?(klass)
|
821
|
+
fail "Operation against a key holding the wrong kind of value: Expected #{klass} at #{key}."
|
822
|
+
end
|
823
|
+
end
|
850
824
|
end
|
851
825
|
end
|
852
826
|
end
|
metadata
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
2
2
|
name: fakeredis
|
3
3
|
version: !ruby/object:Gem::Version
|
4
|
-
version: 0.3.
|
4
|
+
version: 0.3.1
|
5
5
|
prerelease:
|
6
6
|
platform: ruby
|
7
7
|
authors:
|
@@ -9,11 +9,11 @@ authors:
|
|
9
9
|
autorequire:
|
10
10
|
bindir: bin
|
11
11
|
cert_chain: []
|
12
|
-
date: 2012-03-
|
12
|
+
date: 2012-03-20 00:00:00.000000000 Z
|
13
13
|
dependencies:
|
14
14
|
- !ruby/object:Gem::Dependency
|
15
15
|
name: redis
|
16
|
-
requirement: &
|
16
|
+
requirement: &70160189787260 !ruby/object:Gem::Requirement
|
17
17
|
none: false
|
18
18
|
requirements:
|
19
19
|
- - ~>
|
@@ -21,10 +21,10 @@ dependencies:
|
|
21
21
|
version: 2.2.0
|
22
22
|
type: :runtime
|
23
23
|
prerelease: false
|
24
|
-
version_requirements: *
|
24
|
+
version_requirements: *70160189787260
|
25
25
|
- !ruby/object:Gem::Dependency
|
26
26
|
name: rspec
|
27
|
-
requirement: &
|
27
|
+
requirement: &70160189786740 !ruby/object:Gem::Requirement
|
28
28
|
none: false
|
29
29
|
requirements:
|
30
30
|
- - ! '>='
|
@@ -32,7 +32,7 @@ dependencies:
|
|
32
32
|
version: 2.0.0
|
33
33
|
type: :development
|
34
34
|
prerelease: false
|
35
|
-
version_requirements: *
|
35
|
+
version_requirements: *70160189786740
|
36
36
|
description: Fake (In-memory) driver for redis-rb. Useful for testing environment
|
37
37
|
and machines without Redis.
|
38
38
|
email:
|