redis 2.1.1 → 2.2.0

data/test/distributed_connection_handling_test.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require "redis/distributed"
+
+setup do
+  log = StringIO.new
+  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
+end
+
+test "PING" do |r|
+  assert ["PONG"] == r.ping
+end
+
+test "SELECT" do |r|
+  r.set "foo", "bar"
+
+  r.select 14
+  assert nil == r.get("foo")
+
+  r.select 15
+
+  assert "bar" == r.get("foo")
+end
+

data/test/distributed_internals_test.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require File.expand_path("./redis_mock", File.dirname(__FILE__))
+
+include RedisMock::Helper
+
+require "redis/distributed"
+
+setup do
+  log = StringIO.new
+  [init(Redis::Distributed.new(NODES, :logger => ::Logger.new(log))), log]
+end
+
+$TEST_PIPELINING = false
+$TEST_INSPECT    = false
+
+load File.expand_path("./lint/internals.rb", File.dirname(__FILE__))

data/test/distributed_key_tags_test.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require "redis/distributed"
+
+setup do
+  log = StringIO.new
+  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
+end
+
+test "hashes consistently" do
+  r1 = Redis::Distributed.new ["redis://localhost:6379/15", *NODES]
+  r2 = Redis::Distributed.new ["redis://localhost:6379/15", *NODES]
+  r3 = Redis::Distributed.new ["redis://localhost:6379/15", *NODES]
+
+  assert r1.node_for("foo").id == r2.node_for("foo").id
+  assert r1.node_for("foo").id == r3.node_for("foo").id
+end
+
+test "allows clustering of keys" do |r|
+  r = Redis::Distributed.new(NODES)
+  r.add_node("redis://localhost:6379/14")
+  r.flushdb
+
+  100.times do |i|
+    r.set "{foo}users:#{i}", i
+  end
+
+  assert [0, 100] == r.nodes.map { |node| node.keys.size }
+end
+
+test "distributes keys if no clustering is used" do |r|
+  r.add_node("redis://localhost:6379/14")
+  r.flushdb
+
+  r.set "users:1", 1
+  r.set "users:4", 4
+
+  assert [1, 1] == r.nodes.map { |node| node.keys.size }
+end
+
+test "allows passing a custom tag extractor" do |r|
+  r = Redis::Distributed.new(NODES, :tag => /^(.+?):/)
+  r.add_node("redis://localhost:6379/14")
+  r.flushdb
+
+  100.times do |i|
+    r.set "foo:users:#{i}", i
+  end
+
+  assert [0, 100] == r.nodes.map { |node| node.keys.size }
+end
+

data/test/distributed_persistence_control_commands_test.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require "redis/distributed"
+
+setup do
+  log = StringIO.new
+  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
+end
+
+test "SAVE and BGSAVE" do |r|
+  assert_nothing_raised do
+    r.save
+  end
+
+  assert_nothing_raised do
+    r.bgsave
+  end
+end
+
+test "LASTSAVE" do |r|
+  assert r.lastsave.all? { |t| Time.at(t) <= Time.now }
+end
+

data/test/distributed_publish_subscribe_test.rb

@@ -0,0 +1,101 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require "redis/distributed"
+
+setup do
+  log = StringIO.new
+  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
+end
+
+test "SUBSCRIBE and UNSUBSCRIBE" do |r|
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.subscribe("foo", "bar") { }
+  end
+
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.subscribe("{qux}foo", "bar") { }
+  end
+end
+
+test "SUBSCRIBE and UNSUBSCRIBE with tags" do |r|
+  listening = false
+
+  wire = Wire.new do
+    r.subscribe("foo") do |on|
+      on.subscribe do |channel, total|
+        @subscribed = true
+        @t1 = total
+      end
+
+      on.message do |channel, message|
+        if message == "s1"
+          r.unsubscribe
+          @message = message
+        end
+      end
+
+      on.unsubscribe do |channel, total|
+        @unsubscribed = true
+        @t2 = total
+      end
+
+      listening = true
+    end
+  end
+
+  Wire.pass while !listening
+
+  Redis::Distributed.new(NODES).publish("foo", "s1")
+
+  wire.join
+
+  assert @subscribed
+  assert 1 == @t1
+  assert @unsubscribed
+  assert 0 == @t2
+  assert "s1" == @message
+end
+
+test "SUBSCRIBE within SUBSCRIBE" do |r|
+  listening = false
+  @channels = []
+
+  wire = Wire.new do
+    r.subscribe("foo") do |on|
+      on.subscribe do |channel, total|
+        @channels << channel
+
+        r.subscribe("bar") if channel == "foo"
+        r.unsubscribe if channel == "bar"
+      end
+
+      listening = true
+    end
+  end
+
+  Wire.pass while !listening
+
+  Redis::Distributed.new(NODES).publish("foo", "s1")
+
+  wire.join
+
+  assert ["foo", "bar"] == @channels
+end
+
+test "other commands within a SUBSCRIBE" do |r|
+  assert_raise RuntimeError do
+    r.subscribe("foo") do |on|
+      on.subscribe do |channel, total|
+        r.set("bar", "s2")
+      end
+    end
+  end
+end
+
+test "SUBSCRIBE without a block" do |r|
+  assert_raise LocalJumpError do
+    r.subscribe("foo")
+  end
+end
+

data/test/distributed_remote_server_control_commands_test.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require "redis/distributed"
+
+setup do
+  log = StringIO.new
+  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
+end
+
+test "INFO" do |r|
+  %w(last_save_time redis_version total_connections_received connected_clients total_commands_processed connected_slaves uptime_in_seconds used_memory uptime_in_days changes_since_last_save).each do |x|
+    r.info.each do |info|
+      assert info.keys.include?(x)
+    end
+  end
+end
+
+test "MONITOR" do |r|
+  begin
+    r.monitor
+  rescue Exception => ex
+  ensure
+    assert ex.kind_of?(NotImplementedError)
+  end
+end
+
+test "ECHO" do |r|
+  assert ["foo bar baz\n"] == r.echo("foo bar baz\n")
+end
+

data/test/distributed_sorting_test.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require "redis/distributed"
+
+setup do
+  log = StringIO.new
+  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
+end
+
+test "SORT" do |r|
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.set("foo:1", "s1")
+    r.set("foo:2", "s2")
+
+    r.rpush("bar", "1")
+    r.rpush("bar", "2")
+
+    r.sort("bar", :get => "foo:*", :limit => [0, 1])
+  end
+end

data/test/distributed_test.rb

@@ -0,0 +1,60 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require "redis/distributed"
+
+setup do
+  log = StringIO.new
+  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
+end
+
+test "handle multiple servers" do
+  @r = Redis::Distributed.new ["redis://localhost:6379/15", *NODES]
+
+  100.times do |idx|
+    @r.set(idx.to_s, "foo#{idx}")
+  end
+
+  100.times do |idx|
+    assert "foo#{idx}" == @r.get(idx.to_s)
+  end
+
+  assert "0" == @r.keys("*").sort.first
+  assert "string" == @r.type("1")
+end
+
+test "add nodes" do
+  logger = Logger.new("/dev/null")
+
+  @r = Redis::Distributed.new NODES, :logger => logger, :timeout => 10
+
+  assert "127.0.0.1" == @r.nodes[0].client.host
+  assert 6379 == @r.nodes[0].client.port
+  assert 15 == @r.nodes[0].client.db
+  assert 10 == @r.nodes[0].client.timeout
+  assert logger == @r.nodes[0].client.logger
+
+  @r.add_node("redis://localhost:6380/14")
+
+  assert "localhost" == @r.nodes[1].client.host
+  assert 6380 == @r.nodes[1].client.port
+  assert 14 == @r.nodes[1].client.db
+  assert 10 == @r.nodes[1].client.timeout
+  assert logger == @r.nodes[1].client.logger
+end
+
+test "Pipelining commands cannot be distributed" do |r|
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.pipelined do
+      r.lpush "foo", "s1"
+      r.lpush "foo", "s2"
+    end
+  end
+end
+
+test "Unknown commands does not work by default" do |r|
+  assert_raise NoMethodError do
+    r.not_yet_implemented_command
+  end
+end
+

data/test/distributed_transactions_test.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require "redis/distributed"
+
+setup do
+  log = StringIO.new
+  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
+end
+
+test "MULTI/DISCARD" do |r|
+  @foo = nil
+
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.multi { @foo = 1 }
+  end
+
+  assert nil == @foo
+
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.discard
+  end
+end
+
+test "WATCH/UNWATCH" do |r|
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.watch("foo")
+  end
+
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.unwatch
+  end
+end
+

data/test/encoding_test.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "returns properly encoded strings" do |r|
+  with_external_encoding("UTF-8") do
+    r.set "foo", "שלום"
+
+    assert "Shalom שלום" == "Shalom " + r.get("foo")
+  end
+end if defined?(Encoding)
+

data/test/error_replies_test.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+# Every test shouldn't disconnect from the server. Also, when error replies are
+# in play, the protocol should never get into an invalid state where there are
+# pending replies in the connection. Calling INFO after every test ensures that
+# the protocol is still in a valid state.
+def test_with_reconnection_check(title)
+  test(title) do |r|
+    before = r.info["total_connections_received"]
+    yield(r)
+    after = r.info["total_connections_received"]
+    assert before == after
+  end
+end
+
+test_with_reconnection_check "Error reply for single command" do |r|
+  begin
+    r.unknown_command
+  rescue => ex
+  ensure
+    assert ex.message =~ /unknown command/i
+  end
+end
+
+test_with_reconnection_check "Raise first error reply in pipeline" do |r|
+  begin
+    r.pipelined do
+      r.set("foo", "s1")
+      r.incr("foo") # not an integer
+      r.lpush("foo", "value") # wrong kind of value
+    end
+  rescue => ex
+  ensure
+    assert ex.message =~ /not an integer/i
+  end
+end
+
+test_with_reconnection_check "Recover from raise in #call_loop" do |r|
+  begin
+    r.client.call_loop(:invalid_monitor) do
+      assert false # Should never be executed
+    end
+  rescue => ex
+  ensure
+    assert ex.message =~ /unknown command/i
+  end
+end