redis 3.0.0.rc1 → 3.0.0.rc2

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.
Files changed (77) hide show
  1. data/.travis.yml +50 -0
  2. data/.travis/Gemfile +11 -0
  3. data/CHANGELOG.md +47 -19
  4. data/README.md +160 -149
  5. data/Rakefile +15 -50
  6. data/examples/pubsub.rb +1 -1
  7. data/examples/unicorn/config.ru +1 -1
  8. data/examples/unicorn/unicorn.rb +1 -1
  9. data/lib/redis.rb +790 -390
  10. data/lib/redis/client.rb +137 -49
  11. data/lib/redis/connection/hiredis.rb +26 -15
  12. data/lib/redis/connection/ruby.rb +170 -53
  13. data/lib/redis/connection/synchrony.rb +23 -35
  14. data/lib/redis/distributed.rb +92 -32
  15. data/lib/redis/errors.rb +4 -2
  16. data/lib/redis/pipeline.rb +17 -6
  17. data/lib/redis/version.rb +1 -1
  18. data/redis.gemspec +4 -6
  19. data/test/blocking_commands_test.rb +42 -0
  20. data/test/command_map_test.rb +18 -17
  21. data/test/commands_on_hashes_test.rb +13 -12
  22. data/test/commands_on_lists_test.rb +35 -45
  23. data/test/commands_on_sets_test.rb +55 -54
  24. data/test/commands_on_sorted_sets_test.rb +106 -105
  25. data/test/commands_on_strings_test.rb +64 -55
  26. data/test/commands_on_value_types_test.rb +66 -54
  27. data/test/connection_handling_test.rb +136 -151
  28. data/test/distributed_blocking_commands_test.rb +33 -40
  29. data/test/distributed_commands_on_hashes_test.rb +6 -7
  30. data/test/distributed_commands_on_lists_test.rb +13 -14
  31. data/test/distributed_commands_on_sets_test.rb +57 -58
  32. data/test/distributed_commands_on_sorted_sets_test.rb +11 -12
  33. data/test/distributed_commands_on_strings_test.rb +31 -32
  34. data/test/distributed_commands_on_value_types_test.rb +61 -46
  35. data/test/distributed_commands_requiring_clustering_test.rb +108 -108
  36. data/test/distributed_connection_handling_test.rb +14 -15
  37. data/test/distributed_internals_test.rb +7 -19
  38. data/test/distributed_key_tags_test.rb +36 -36
  39. data/test/distributed_persistence_control_commands_test.rb +17 -14
  40. data/test/distributed_publish_subscribe_test.rb +61 -69
  41. data/test/distributed_remote_server_control_commands_test.rb +39 -28
  42. data/test/distributed_sorting_test.rb +12 -13
  43. data/test/distributed_test.rb +40 -41
  44. data/test/distributed_transactions_test.rb +20 -21
  45. data/test/encoding_test.rb +12 -9
  46. data/test/error_replies_test.rb +42 -36
  47. data/test/helper.rb +118 -85
  48. data/test/helper_test.rb +20 -6
  49. data/test/internals_test.rb +167 -103
  50. data/test/lint/blocking_commands.rb +124 -0
  51. data/test/lint/hashes.rb +115 -93
  52. data/test/lint/lists.rb +86 -80
  53. data/test/lint/sets.rb +68 -62
  54. data/test/lint/sorted_sets.rb +200 -195
  55. data/test/lint/strings.rb +112 -94
  56. data/test/lint/value_types.rb +76 -55
  57. data/test/persistence_control_commands_test.rb +17 -12
  58. data/test/pipelining_commands_test.rb +135 -126
  59. data/test/publish_subscribe_test.rb +105 -110
  60. data/test/remote_server_control_commands_test.rb +74 -58
  61. data/test/sorting_test.rb +31 -29
  62. data/test/support/connection/hiredis.rb +1 -0
  63. data/test/support/connection/ruby.rb +1 -0
  64. data/test/support/connection/synchrony.rb +17 -0
  65. data/test/{redis_mock.rb → support/redis_mock.rb} +24 -21
  66. data/test/support/wire/synchrony.rb +24 -0
  67. data/test/support/wire/thread.rb +5 -0
  68. data/test/synchrony_driver.rb +9 -9
  69. data/test/test.conf +1 -1
  70. data/test/thread_safety_test.rb +21 -19
  71. data/test/transactions_test.rb +189 -118
  72. data/test/unknown_commands_test.rb +9 -8
  73. data/test/url_param_test.rb +46 -41
  74. metadata +28 -43
  75. data/TODO.md +0 -4
  76. data/benchmarking/thread_safety.rb +0 -38
  77. data/test/lint/internals.rb +0 -36
data/test/lint/blocking_commands.rb ADDED
@@ -0,0 +1,124 @@
1
+ module Lint
2
+
3
+ module BlockingCommands
4
+
5
+ def setup
6
+ super
7
+
8
+ r.rpush("{zap}foo", "s1")
9
+ r.rpush("{zap}foo", "s2")
10
+ r.rpush("{zap}bar", "s1")
11
+ r.rpush("{zap}bar", "s2")
12
+ end
13
+
14
+ def to_protocol(obj)
15
+ case obj
16
+ when String
17
+ "$#{obj.length}\r\n#{obj}\r\n"
18
+ when Array
19
+ "*#{obj.length}\r\n" + obj.map { |e| to_protocol(e) }.join
20
+ else
21
+ fail
22
+ end
23
+ end
24
+
25
+ def mock(options = {}, &blk)
26
+ commands = {
27
+ :blpop => lambda do |*args|
28
+ sleep options[:delay] if options.has_key?(:delay)
29
+ to_protocol([args.first, args.last])
30
+ end,
31
+ :brpop => lambda do |*args|
32
+ sleep options[:delay] if options.has_key?(:delay)
33
+ to_protocol([args.first, args.last])
34
+ end,
35
+ :brpoplpush => lambda do |*args|
36
+ sleep options[:delay] if options.has_key?(:delay)
37
+ to_protocol(args.last)
38
+ end,
39
+ }
40
+
41
+ redis_mock(commands, &blk)
42
+ end
43
+
44
+ def test_blpop
45
+ assert_equal ["{zap}foo", "s1"], r.blpop("{zap}foo")
46
+ assert_equal ["{zap}foo", "s2"], r.blpop(["{zap}foo"])
47
+ assert_equal ["{zap}bar", "s1"], r.blpop(["{zap}bar", "{zap}foo"])
48
+ assert_equal ["{zap}bar", "s2"], r.blpop(["{zap}foo", "{zap}bar"])
49
+ end
50
+
51
+ def test_blpop_timeout
52
+ mock do |r|
53
+ assert_equal ["{zap}foo", "0"], r.blpop("{zap}foo")
54
+ assert_equal ["{zap}foo", "1"], r.blpop("{zap}foo", :timeout => 1)
55
+ end
56
+ end
57
+
58
+ def test_blpop_with_old_prototype
59
+ assert_equal ["{zap}foo", "s1"], r.blpop("{zap}foo", 0)
60
+ assert_equal ["{zap}foo", "s2"], r.blpop("{zap}foo", 0)
61
+ assert_equal ["{zap}bar", "s1"], r.blpop("{zap}bar", "{zap}foo", 0)
62
+ assert_equal ["{zap}bar", "s2"], r.blpop("{zap}foo", "{zap}bar", 0)
63
+ end
64
+
65
+ def test_blpop_timeout_with_old_prototype
66
+ mock do |r|
67
+ assert_equal ["{zap}foo", "0"], r.blpop("{zap}foo", 0)
68
+ assert_equal ["{zap}foo", "1"], r.blpop("{zap}foo", 1)
69
+ end
70
+ end
71
+
72
+ def test_brpop
73
+ assert_equal ["{zap}foo", "s2"], r.brpop("{zap}foo")
74
+ assert_equal ["{zap}foo", "s1"], r.brpop(["{zap}foo"])
75
+ assert_equal ["{zap}bar", "s2"], r.brpop(["{zap}bar", "{zap}foo"])
76
+ assert_equal ["{zap}bar", "s1"], r.brpop(["{zap}foo", "{zap}bar"])
77
+ end
78
+
79
+ def test_brpop_timeout
80
+ mock do |r|
81
+ assert_equal ["{zap}foo", "0"], r.brpop("{zap}foo")
82
+ assert_equal ["{zap}foo", "1"], r.brpop("{zap}foo", :timeout => 1)
83
+ end
84
+ end
85
+
86
+ def test_brpop_with_old_prototype
87
+ assert_equal ["{zap}foo", "s2"], r.brpop("{zap}foo", 0)
88
+ assert_equal ["{zap}foo", "s1"], r.brpop("{zap}foo", 0)
89
+ assert_equal ["{zap}bar", "s2"], r.brpop("{zap}bar", "{zap}foo", 0)
90
+ assert_equal ["{zap}bar", "s1"], r.brpop("{zap}foo", "{zap}bar", 0)
91
+ end
92
+
93
+ def test_brpop_timeout_with_old_prototype
94
+ mock do |r|
95
+ assert_equal ["{zap}foo", "0"], r.brpop("{zap}foo", 0)
96
+ assert_equal ["{zap}foo", "1"], r.brpop("{zap}foo", 1)
97
+ end
98
+ end
99
+
100
+ def test_brpoplpush
101
+ assert_equal "s2", r.brpoplpush("{zap}foo", "{zap}qux")
102
+ assert_equal ["s2"], r.lrange("{zap}qux", 0, -1)
103
+ end
104
+
105
+ def test_brpoplpush_timeout
106
+ mock do |r|
107
+ assert_equal "0", r.brpoplpush("{zap}foo", "{zap}bar")
108
+ assert_equal "1", r.brpoplpush("{zap}foo", "{zap}bar", :timeout => 1)
109
+ end
110
+ end
111
+
112
+ def test_brpoplpush_with_old_prototype
113
+ assert_equal "s2", r.brpoplpush("{zap}foo", "{zap}qux", 0)
114
+ assert_equal ["s2"], r.lrange("{zap}qux", 0, -1)
115
+ end
116
+
117
+ def test_brpoplpush_timeout_with_old_prototype
118
+ mock do |r|
119
+ assert_equal "0", r.brpoplpush("{zap}foo", "{zap}bar", 0)
120
+ assert_equal "1", r.brpoplpush("{zap}foo", "{zap}bar", 1)
121
+ end
122
+ end
123
+ end
124
+ end
data/test/lint/hashes.rb CHANGED
@@ -1,140 +1,162 @@
1
- test "HSET and HGET" do |r|
2
- r.hset("foo", "f1", "s1")
1
+ module Lint
3
2
 
4
- assert "s1" == r.hget("foo", "f1")
5
- end
3
+ module Hashes
6
4
 
7
- test "HSETNX" do |r|
8
- r.hset("foo", "f1", "s1")
9
- r.hsetnx("foo", "f1", "s2")
5
+ def test_hset_and_hget
6
+ r.hset("foo", "f1", "s1")
10
7
 
11
- assert "s1" == r.hget("foo", "f1")
8
+ assert_equal "s1", r.hget("foo", "f1")
9
+ end
12
10
 
13
- r.del("foo")
14
- r.hsetnx("foo", "f1", "s2")
11
+ def test_hsetnx
12
+ r.hset("foo", "f1", "s1")
13
+ r.hsetnx("foo", "f1", "s2")
15
14
 
16
- assert "s2" == r.hget("foo", "f1")
17
- end
15
+ assert_equal "s1", r.hget("foo", "f1")
18
16
 
19
- test "HDEL" do |r|
20
- r.hset("foo", "f1", "s1")
17
+ r.del("foo")
18
+ r.hsetnx("foo", "f1", "s2")
21
19
 
22
- assert "s1" == r.hget("foo", "f1")
20
+ assert_equal "s2", r.hget("foo", "f1")
21
+ end
23
22
 
24
- assert 1 == r.hdel("foo", "f1")
23
+ def test_hdel
24
+ r.hset("foo", "f1", "s1")
25
25
 
26
- assert nil == r.hget("foo", "f1")
27
- end
26
+ assert_equal "s1", r.hget("foo", "f1")
28
27
 
29
- test "Variadic HDEL" do |r|
30
- next if version(r) < 203090
28
+ assert_equal 1, r.hdel("foo", "f1")
31
29
 
32
- r.hset("foo", "f1", "s1")
33
- r.hset("foo", "f2", "s2")
30
+ assert_equal nil, r.hget("foo", "f1")
31
+ end
34
32
 
35
- assert "s1" == r.hget("foo", "f1")
36
- assert "s2" == r.hget("foo", "f2")
33
+ def test_variadic_hdel
34
+ return if version < "2.3.9"
37
35
 
38
- assert 2 == r.hdel("foo", ["f1", "f2"])
36
+ r.hset("foo", "f1", "s1")
37
+ r.hset("foo", "f2", "s2")
39
38
 
40
- assert nil == r.hget("foo", "f1")
41
- assert nil == r.hget("foo", "f2")
42
- end
39
+ assert_equal "s1", r.hget("foo", "f1")
40
+ assert_equal "s2", r.hget("foo", "f2")
43
41
 
44
- test "HEXISTS" do |r|
45
- assert false == r.hexists("foo", "f1")
42
+ assert_equal 2, r.hdel("foo", ["f1", "f2"])
46
43
 
47
- r.hset("foo", "f1", "s1")
44
+ assert_equal nil, r.hget("foo", "f1")
45
+ assert_equal nil, r.hget("foo", "f2")
46
+ end
48
47
 
49
- assert r.hexists("foo", "f1")
50
- end
48
+ def test_hexists
49
+ assert_equal false, r.hexists("foo", "f1")
51
50
 
52
- test "HLEN" do |r|
53
- assert 0 == r.hlen("foo")
51
+ r.hset("foo", "f1", "s1")
54
52
 
55
- r.hset("foo", "f1", "s1")
53
+ assert r.hexists("foo", "f1")
54
+ end
56
55
 
57
- assert 1 == r.hlen("foo")
56
+ def test_hlen
57
+ assert_equal 0, r.hlen("foo")
58
58
 
59
- r.hset("foo", "f2", "s2")
59
+ r.hset("foo", "f1", "s1")
60
60
 
61
- assert 2 == r.hlen("foo")
62
- end
61
+ assert_equal 1, r.hlen("foo")
63
62
 
64
- test "HKEYS" do |r|
65
- assert [] == r.hkeys("foo")
63
+ r.hset("foo", "f2", "s2")
66
64
 
67
- r.hset("foo", "f1", "s1")
68
- r.hset("foo", "f2", "s2")
65
+ assert_equal 2, r.hlen("foo")
66
+ end
69
67
 
70
- assert ["f1", "f2"] == r.hkeys("foo")
71
- end
68
+ def test_hkeys
69
+ assert_equal [], r.hkeys("foo")
72
70
 
73
- test "HVALS" do |r|
74
- assert [] == r.hvals("foo")
71
+ r.hset("foo", "f1", "s1")
72
+ r.hset("foo", "f2", "s2")
75
73
 
76
- r.hset("foo", "f1", "s1")
77
- r.hset("foo", "f2", "s2")
74
+ assert_equal ["f1", "f2"], r.hkeys("foo")
75
+ end
78
76
 
79
- assert ["s1", "s2"] == r.hvals("foo")
80
- end
77
+ def test_hvals
78
+ assert_equal [], r.hvals("foo")
81
79
 
82
- test "HGETALL" do |r|
83
- assert({} == r.hgetall("foo"))
80
+ r.hset("foo", "f1", "s1")
81
+ r.hset("foo", "f2", "s2")
84
82
 
85
- r.hset("foo", "f1", "s1")
86
- r.hset("foo", "f2", "s2")
83
+ assert_equal ["s1", "s2"], r.hvals("foo")
84
+ end
87
85
 
88
- assert({"f1" => "s1", "f2" => "s2"} == r.hgetall("foo"))
89
- end
86
+ def test_hgetall
87
+ assert({} == r.hgetall("foo"))
90
88
 
91
- test "HMSET" do |r|
92
- r.hmset("hash", "foo1", "bar1", "foo2", "bar2")
89
+ r.hset("foo", "f1", "s1")
90
+ r.hset("foo", "f2", "s2")
93
91
 
94
- assert "bar1" == r.hget("hash", "foo1")
95
- assert "bar2" == r.hget("hash", "foo2")
96
- end
92
+ assert({"f1" => "s1", "f2" => "s2"} == r.hgetall("foo"))
93
+ end
97
94
 
98
- test "HMSET with invalid arguments" do |r|
99
- assert_raise(Redis::CommandError) do
100
- r.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3")
101
- end
102
- end
95
+ def test_hmset
96
+ r.hmset("hash", "foo1", "bar1", "foo2", "bar2")
103
97
 
104
- test "Mapped HMSET" do |r|
105
- r.mapped_hmset("foo", :f1 => "s1", :f2 => "s2")
98
+ assert_equal "bar1", r.hget("hash", "foo1")
99
+ assert_equal "bar2", r.hget("hash", "foo2")
100
+ end
106
101
 
107
- assert "s1" == r.hget("foo", "f1")
108
- assert "s2" == r.hget("foo", "f2")
109
- end
102
+ def test_hmset_with_invalid_arguments
103
+ assert_raise(Redis::CommandError) do
104
+ r.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3")
105
+ end
106
+ end
110
107
 
111
- test "HMGET" do |r|
112
- r.hset("foo", "f1", "s1")
113
- r.hset("foo", "f2", "s2")
114
- r.hset("foo", "f3", "s3")
108
+ def test_mapped_hmset
109
+ r.mapped_hmset("foo", :f1 => "s1", :f2 => "s2")
115
110
 
116
- assert ["s2", "s3"] == r.hmget("foo", "f2", "f3")
117
- end
111
+ assert_equal "s1", r.hget("foo", "f1")
112
+ assert_equal "s2", r.hget("foo", "f2")
113
+ end
118
114
 
119
- test "HMGET mapped" do |r|
120
- r.hset("foo", "f1", "s1")
121
- r.hset("foo", "f2", "s2")
122
- r.hset("foo", "f3", "s3")
115
+ def test_hmget
116
+ r.hset("foo", "f1", "s1")
117
+ r.hset("foo", "f2", "s2")
118
+ r.hset("foo", "f3", "s3")
123
119
 
124
- assert({"f1" => "s1"} == r.mapped_hmget("foo", "f1"))
125
- assert({"f1" => "s1", "f2" => "s2"} == r.mapped_hmget("foo", "f1", "f2"))
126
- end
120
+ assert_equal ["s2", "s3"], r.hmget("foo", "f2", "f3")
121
+ end
122
+
123
+ def test_hmget_mapped
124
+ r.hset("foo", "f1", "s1")
125
+ r.hset("foo", "f2", "s2")
126
+ r.hset("foo", "f3", "s3")
127
+
128
+ assert({"f1" => "s1"} == r.mapped_hmget("foo", "f1"))
129
+ assert({"f1" => "s1", "f2" => "s2"} == r.mapped_hmget("foo", "f1", "f2"))
130
+ end
131
+
132
+ def test_hincrby
133
+ r.hincrby("foo", "f1", 1)
134
+
135
+ assert_equal "1", r.hget("foo", "f1")
127
136
 
128
- test "HINCRBY" do |r|
129
- r.hincrby("foo", "f1", 1)
137
+ r.hincrby("foo", "f1", 2)
130
138
 
131
- assert "1" == r.hget("foo", "f1")
139
+ assert_equal "3", r.hget("foo", "f1")
132
140
 
133
- r.hincrby("foo", "f1", 2)
141
+ r.hincrby("foo", "f1", -1)
134
142
 
135
- assert "3" == r.hget("foo", "f1")
143
+ assert_equal "2", r.hget("foo", "f1")
144
+ end
136
145
 
137
- r.hincrby("foo", "f1", -1)
146
+ def test_hincrbyfloat
147
+ return if version < "2.5.4"
138
148
 
139
- assert "2" == r.hget("foo", "f1")
149
+ r.hincrbyfloat("foo", "f1", 1.23)
150
+
151
+ assert_equal "1.23", r.hget("foo", "f1")
152
+
153
+ r.hincrbyfloat("foo", "f1", 0.77)
154
+
155
+ assert_equal "2", r.hget("foo", "f1")
156
+
157
+ r.hincrbyfloat("foo", "f1", -0.1)
158
+
159
+ assert_equal "1.9", r.hget("foo", "f1")
160
+ end
161
+ end
140
162
  end
data/test/lint/lists.rb CHANGED
@@ -1,107 +1,113 @@
1
- test "RPUSH" do |r|
2
- r.rpush "foo", "s1"
3
- r.rpush "foo", "s2"
1
+ module Lint
4
2
 
5
- assert 2 == r.llen("foo")
6
- assert "s2" == r.rpop("foo")
7
- end
3
+ module Lists
8
4
 
9
- test "Variadic RPUSH" do |r|
10
- next if version(r) < 203090 # 2.4-rc6
5
+ def test_rpush
6
+ r.rpush "foo", "s1"
7
+ r.rpush "foo", "s2"
11
8
 
12
- assert 3 == r.rpush("foo", ["s1", "s2", "s3"])
13
- assert 3 == r.llen("foo")
14
- assert "s3" == r.rpop("foo")
15
- end
9
+ assert_equal 2, r.llen("foo")
10
+ assert_equal "s2", r.rpop("foo")
11
+ end
16
12
 
17
- test "LPUSH" do |r|
18
- r.lpush "foo", "s1"
19
- r.lpush "foo", "s2"
13
+ def test_variadic_rpush
14
+ return if version < "2.3.9" # 2.4-rc6
20
15
 
21
- assert 2 == r.llen("foo")
22
- assert "s2" == r.lpop("foo")
23
- end
16
+ assert_equal 3, r.rpush("foo", ["s1", "s2", "s3"])
17
+ assert_equal 3, r.llen("foo")
18
+ assert_equal "s3", r.rpop("foo")
19
+ end
24
20
 
25
- test "Variadic LPUSH" do |r|
26
- next if version(r) < 203090 # 2.4-rc6
21
+ def test_lpush
22
+ r.lpush "foo", "s1"
23
+ r.lpush "foo", "s2"
27
24
 
28
- assert 3 == r.lpush("foo", ["s1", "s2", "s3"])
29
- assert 3 == r.llen("foo")
30
- assert "s3" == r.lpop("foo")
31
- end
25
+ assert_equal 2, r.llen("foo")
26
+ assert_equal "s2", r.lpop("foo")
27
+ end
32
28
 
33
- test "LLEN" do |r|
34
- r.rpush "foo", "s1"
35
- r.rpush "foo", "s2"
29
+ def test_variadic_lpush
30
+ return if version < "2.3.9" # 2.4-rc6
36
31
 
37
- assert 2 == r.llen("foo")
38
- end
32
+ assert_equal 3, r.lpush("foo", ["s1", "s2", "s3"])
33
+ assert_equal 3, r.llen("foo")
34
+ assert_equal "s3", r.lpop("foo")
35
+ end
39
36
 
40
- test "LRANGE" do |r|
41
- r.rpush "foo", "s1"
42
- r.rpush "foo", "s2"
43
- r.rpush "foo", "s3"
37
+ def test_llen
38
+ r.rpush "foo", "s1"
39
+ r.rpush "foo", "s2"
44
40
 
45
- assert ["s2", "s3"] == r.lrange("foo", 1, -1)
46
- assert ["s1", "s2"] == r.lrange("foo", 0, 1)
41
+ assert_equal 2, r.llen("foo")
42
+ end
47
43
 
48
- assert [] == r.lrange("bar", 0, -1)
49
- end
44
+ def test_lrange
45
+ r.rpush "foo", "s1"
46
+ r.rpush "foo", "s2"
47
+ r.rpush "foo", "s3"
50
48
 
51
- test "LTRIM" do |r|
52
- r.rpush "foo", "s1"
53
- r.rpush "foo", "s2"
54
- r.rpush "foo", "s3"
49
+ assert_equal ["s2", "s3"], r.lrange("foo", 1, -1)
50
+ assert_equal ["s1", "s2"], r.lrange("foo", 0, 1)
55
51
 
56
- r.ltrim "foo", 0, 1
52
+ assert_equal [], r.lrange("bar", 0, -1)
53
+ end
57
54
 
58
- assert 2 == r.llen("foo")
59
- assert ["s1", "s2"] == r.lrange("foo", 0, -1)
60
- end
55
+ def test_ltrim
56
+ r.rpush "foo", "s1"
57
+ r.rpush "foo", "s2"
58
+ r.rpush "foo", "s3"
61
59
 
62
- test "LINDEX" do |r|
63
- r.rpush "foo", "s1"
64
- r.rpush "foo", "s2"
60
+ r.ltrim "foo", 0, 1
65
61
 
66
- assert "s1" == r.lindex("foo", 0)
67
- assert "s2" == r.lindex("foo", 1)
68
- end
62
+ assert_equal 2, r.llen("foo")
63
+ assert_equal ["s1", "s2"], r.lrange("foo", 0, -1)
64
+ end
69
65
 
70
- test "LSET" do |r|
71
- r.rpush "foo", "s1"
72
- r.rpush "foo", "s2"
66
+ def test_lindex
67
+ r.rpush "foo", "s1"
68
+ r.rpush "foo", "s2"
73
69
 
74
- assert "s2" == r.lindex("foo", 1)
75
- assert r.lset("foo", 1, "s3")
76
- assert "s3" == r.lindex("foo", 1)
70
+ assert_equal "s1", r.lindex("foo", 0)
71
+ assert_equal "s2", r.lindex("foo", 1)
72
+ end
77
73
 
78
- assert_raise Redis::CommandError do
79
- r.lset("foo", 4, "s3")
80
- end
81
- end
74
+ def test_lset
75
+ r.rpush "foo", "s1"
76
+ r.rpush "foo", "s2"
82
77
 
83
- test "LREM" do |r|
84
- r.rpush "foo", "s1"
85
- r.rpush "foo", "s2"
78
+ assert_equal "s2", r.lindex("foo", 1)
79
+ assert r.lset("foo", 1, "s3")
80
+ assert_equal "s3", r.lindex("foo", 1)
86
81
 
87
- assert 1 == r.lrem("foo", 1, "s1")
88
- assert ["s2"] == r.lrange("foo", 0, -1)
89
- end
82
+ assert_raise Redis::CommandError do
83
+ r.lset("foo", 4, "s3")
84
+ end
85
+ end
90
86
 
91
- test "LPOP" do |r|
92
- r.rpush "foo", "s1"
93
- r.rpush "foo", "s2"
87
+ def test_lrem
88
+ r.rpush "foo", "s1"
89
+ r.rpush "foo", "s2"
94
90
 
95
- assert 2 == r.llen("foo")
96
- assert "s1" == r.lpop("foo")
97
- assert 1 == r.llen("foo")
98
- end
91
+ assert_equal 1, r.lrem("foo", 1, "s1")
92
+ assert_equal ["s2"], r.lrange("foo", 0, -1)
93
+ end
99
94
 
100
- test "RPOP" do |r|
101
- r.rpush "foo", "s1"
102
- r.rpush "foo", "s2"
95
+ def test_lpop
96
+ r.rpush "foo", "s1"
97
+ r.rpush "foo", "s2"
103
98
 
104
- assert 2 == r.llen("foo")
105
- assert "s2" == r.rpop("foo")
106
- assert 1 == r.llen("foo")
99
+ assert_equal 2, r.llen("foo")
100
+ assert_equal "s1", r.lpop("foo")
101
+ assert_equal 1, r.llen("foo")
102
+ end
103
+
104
+ def test_rpop
105
+ r.rpush "foo", "s1"
106
+ r.rpush "foo", "s2"
107
+
108
+ assert_equal 2, r.llen("foo")
109
+ assert_equal "s2", r.rpop("foo")
110
+ assert_equal 1, r.llen("foo")
111
+ end
112
+ end
107
113
  end