gorsuch-redis 3.0.0.rc1

data/test/distributed_commands_on_value_types_test.rb

@@ -0,0 +1,72 @@
+# 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
+
+load "./test/lint/value_types.rb"
+
+test "DEL" do |r|
+  r.set "foo", "s1"
+  r.set "bar", "s2"
+  r.set "baz", "s3"
+
+  assert ["bar", "baz", "foo"] == r.keys("*").sort
+
+  assert 1 == r.del("foo")
+
+  assert ["bar", "baz"] == r.keys("*").sort
+
+  assert 2 == r.del("bar", "baz")
+
+  assert [] == r.keys("*").sort
+end
+
+test "RANDOMKEY" do |r|
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.randomkey
+  end
+end
+
+test "RENAME" do |r|
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.set("foo", "s1")
+    r.rename "foo", "bar"
+  end
+
+  assert "s1" == r.get("foo")
+  assert nil == r.get("bar")
+end
+
+test "RENAMENX" do |r|
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.set("foo", "s1")
+    r.rename "foo", "bar"
+  end
+
+  assert "s1" == r.get("foo")
+  assert nil  == r.get("bar")
+end
+
+test "DBSIZE" do |r|
+  assert [0] == r.dbsize
+
+  r.set("foo", "s1")
+
+  assert [1] == r.dbsize
+end
+
+test "FLUSHDB" do |r|
+  r.set("foo", "s1")
+  r.set("bar", "s2")
+
+  assert [2] == r.dbsize
+
+  r.flushdb
+
+  assert [0] == r.dbsize
+end

data/test/distributed_commands_requiring_clustering_test.rb

@@ -0,0 +1,148 @@
+# 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 "RENAME" do |r|
+  r.set("{qux}foo", "s1")
+  r.rename "{qux}foo", "{qux}bar"
+
+  assert "s1" == r.get("{qux}bar")
+  assert nil == r.get("{qux}foo")
+end
+
+test "RENAMENX" do |r|
+  r.set("{qux}foo", "s1")
+  r.set("{qux}bar", "s2")
+
+  assert false == r.renamenx("{qux}foo", "{qux}bar")
+
+  assert "s1" == r.get("{qux}foo")
+  assert "s2" == r.get("{qux}bar")
+end
+
+test "BRPOPLPUSH" do |r|
+  r.rpush "{qux}foo", "s1"
+  r.rpush "{qux}foo", "s2"
+
+  assert_equal "s2", r.brpoplpush("{qux}foo", "{qux}bar", 1)
+  assert_equal ["s2"], r.lrange("{qux}bar", 0, -1)
+end
+
+test "RPOPLPUSH" do |r|
+  r.rpush "{qux}foo", "s1"
+  r.rpush "{qux}foo", "s2"
+
+  assert "s2" == r.rpoplpush("{qux}foo", "{qux}bar")
+  assert ["s2"] == r.lrange("{qux}bar", 0, -1)
+  assert "s1" == r.rpoplpush("{qux}foo", "{qux}bar")
+  assert ["s1", "s2"] == r.lrange("{qux}bar", 0, -1)
+end
+
+test "SMOVE" do |r|
+  r.sadd "{qux}foo", "s1"
+  r.sadd "{qux}bar", "s2"
+
+  assert r.smove("{qux}foo", "{qux}bar", "s1")
+  assert r.sismember("{qux}bar", "s1")
+end
+
+test "SINTER" do |r|
+  r.sadd "{qux}foo", "s1"
+  r.sadd "{qux}foo", "s2"
+  r.sadd "{qux}bar", "s2"
+
+  assert ["s2"] == r.sinter("{qux}foo", "{qux}bar")
+end
+
+test "SINTERSTORE" do |r|
+  r.sadd "{qux}foo", "s1"
+  r.sadd "{qux}foo", "s2"
+  r.sadd "{qux}bar", "s2"
+
+  r.sinterstore("{qux}baz", "{qux}foo", "{qux}bar")
+
+  assert ["s2"] == r.smembers("{qux}baz")
+end
+
+test "SUNION" do |r|
+  r.sadd "{qux}foo", "s1"
+  r.sadd "{qux}foo", "s2"
+  r.sadd "{qux}bar", "s2"
+  r.sadd "{qux}bar", "s3"
+
+  assert ["s1", "s2", "s3"] == r.sunion("{qux}foo", "{qux}bar").sort
+end
+
+test "SUNIONSTORE" do |r|
+  r.sadd "{qux}foo", "s1"
+  r.sadd "{qux}foo", "s2"
+  r.sadd "{qux}bar", "s2"
+  r.sadd "{qux}bar", "s3"
+
+  r.sunionstore("{qux}baz", "{qux}foo", "{qux}bar")
+
+  assert ["s1", "s2", "s3"] == r.smembers("{qux}baz").sort
+end
+
+test "SDIFF" do |r|
+  r.sadd "{qux}foo", "s1"
+  r.sadd "{qux}foo", "s2"
+  r.sadd "{qux}bar", "s2"
+  r.sadd "{qux}bar", "s3"
+
+  assert ["s1"] == r.sdiff("{qux}foo", "{qux}bar")
+  assert ["s3"] == r.sdiff("{qux}bar", "{qux}foo")
+end
+
+test "SDIFFSTORE" do |r|
+  r.sadd "{qux}foo", "s1"
+  r.sadd "{qux}foo", "s2"
+  r.sadd "{qux}bar", "s2"
+  r.sadd "{qux}bar", "s3"
+
+  r.sdiffstore("{qux}baz", "{qux}foo", "{qux}bar")
+
+  assert ["s1"] == r.smembers("{qux}baz")
+end
+
+test "SORT" do |r|
+  r.set("{qux}foo:1", "s1")
+  r.set("{qux}foo:2", "s2")
+
+  r.rpush("{qux}bar", "1")
+  r.rpush("{qux}bar", "2")
+
+  assert ["s1"] == r.sort("{qux}bar", :get => "{qux}foo:*", :limit => [0, 1])
+  assert ["s2"] == r.sort("{qux}bar", :get => "{qux}foo:*", :limit => [0, 1], :order => "desc alpha")
+end
+
+test "SORT with an array of GETs" do |r|
+  r.set("{qux}foo:1:a", "s1a")
+  r.set("{qux}foo:1:b", "s1b")
+
+  r.set("{qux}foo:2:a", "s2a")
+  r.set("{qux}foo:2:b", "s2b")
+
+  r.rpush("{qux}bar", "1")
+  r.rpush("{qux}bar", "2")
+
+  assert ["s1a", "s1b"] == r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"], :limit => [0, 1])
+  assert ["s2a", "s2b"] == r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"], :limit => [0, 1], :order => "desc alpha")
+end
+
+test "SORT with STORE" do |r|
+  r.set("{qux}foo:1", "s1")
+  r.set("{qux}foo:2", "s2")
+
+  r.rpush("{qux}bar", "1")
+  r.rpush("{qux}bar", "2")
+
+  r.sort("{qux}bar", :get => "{qux}foo:*", :store => "{qux}baz")
+  assert ["s1", "s2"] == r.lrange("{qux}baz", 0, -1)
+end

data/test/distributed_connection_handling_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 "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,27 @@
+# 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
+
+load File.expand_path("./lint/internals.rb", File.dirname(__FILE__))
+
+test "provides a meaningful inspect" do |r, _|
+  nodes = ["redis://localhost:6379/15", *NODES]
+  @r = Redis::Distributed.new nodes
+
+  node_info = nodes.map do |node|
+    "#{node} (Redis v#{@r.info.first["redis_version"]})"
+  end
+  assert "#<Redis client v#{Redis::VERSION} connected to #{node_info.join(', ')}>" == @r.inspect
+end

data/test/distributed_key_tags_test.rb

@@ -0,0 +1,52 @@
+# 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,23 @@
+# 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,100 @@
+# 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 Redis::CommandError 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