discourse-redis 3.2.2

data/test/distributed_commands_on_lists_test.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/lists"
+
+class TestDistributedCommandsOnLists < Test::Unit::TestCase
+
+  include Helper::Distributed
+  include Lint::Lists
+
+  def test_rpoplpush
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.rpoplpush("foo", "bar")
+    end
+  end
+
+  def test_brpoplpush
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.brpoplpush("foo", "bar", :timeout => 1)
+    end
+  end
+end

data/test/distributed_commands_on_sets_test.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/sets"
+
+class TestDistributedCommandsOnSets < Test::Unit::TestCase
+
+  include Helper::Distributed
+  include Lint::Sets
+
+  def test_smove
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "bar", "s2"
+
+      r.smove("foo", "bar", "s1")
+    end
+  end
+
+  def test_sinter
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "bar", "s2"
+
+      r.sinter("foo", "bar")
+    end
+  end
+
+  def test_sinterstore
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "bar", "s2"
+
+      r.sinterstore("baz", "foo", "bar")
+    end
+  end
+
+  def test_sunion
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "bar", "s2"
+      r.sadd "bar", "s3"
+
+      r.sunion("foo", "bar")
+    end
+  end
+
+  def test_sunionstore
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "bar", "s2"
+      r.sadd "bar", "s3"
+
+      r.sunionstore("baz", "foo", "bar")
+    end
+  end
+
+  def test_sdiff
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "bar", "s2"
+      r.sadd "bar", "s3"
+
+      r.sdiff("foo", "bar")
+    end
+  end
+
+  def test_sdiffstore
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "bar", "s2"
+      r.sadd "bar", "s3"
+
+      r.sdiffstore("baz", "foo", "bar")
+    end
+  end
+end

data/test/distributed_commands_on_sorted_sets_test.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/sorted_sets"
+
+class TestDistributedCommandsOnSortedSets < Test::Unit::TestCase
+
+  include Helper::Distributed
+  include Lint::SortedSets
+
+  def test_zcount
+    r.zadd "foo", 1, "s1"
+    r.zadd "foo", 2, "s2"
+    r.zadd "foo", 3, "s3"
+
+    assert_equal 2, r.zcount("foo", 2, 3)
+  end
+end

data/test/distributed_commands_on_strings_test.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/strings"
+
+class TestDistributedCommandsOnStrings < Test::Unit::TestCase
+
+  include Helper::Distributed
+  include Lint::Strings
+
+  def test_mget
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.mget("foo", "bar")
+    end
+  end
+
+  def test_mget_mapped
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.mapped_mget("foo", "bar")
+    end
+  end
+
+  def test_mset
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.mset(:foo, "s1", :bar, "s2")
+    end
+  end
+
+  def test_mset_mapped
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.mapped_mset(:foo => "s1", :bar => "s2")
+    end
+  end
+
+  def test_msetnx
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.set("foo", "s1")
+      r.msetnx(:foo, "s2", :bar, "s3")
+    end
+  end
+
+  def test_msetnx_mapped
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.set("foo", "s1")
+      r.mapped_msetnx(:foo => "s2", :bar => "s3")
+    end
+  end
+
+  def test_bitop
+    target_version "2.5.10" do
+      assert_raise Redis::Distributed::CannotDistribute do
+        r.set("foo", "a")
+        r.set("bar", "b")
+
+        r.bitop(:and, "foo&bar", "foo", "bar")
+      end
+    end
+  end
+end

data/test/distributed_commands_on_value_types_test.rb

@@ -0,0 +1,95 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/value_types"
+
+class TestDistributedCommandsOnValueTypes < Test::Unit::TestCase
+
+  include Helper::Distributed
+  include Lint::ValueTypes
+
+  def test_del
+    r.set "foo", "s1"
+    r.set "bar", "s2"
+    r.set "baz", "s3"
+
+    assert_equal ["bar", "baz", "foo"], r.keys("*").sort
+
+    assert_equal 1, r.del("foo")
+
+    assert_equal ["bar", "baz"], r.keys("*").sort
+
+    assert_equal 2, r.del("bar", "baz")
+
+    assert_equal [], r.keys("*").sort
+  end
+
+  def test_del_with_array_argument
+    r.set "foo", "s1"
+    r.set "bar", "s2"
+    r.set "baz", "s3"
+
+    assert_equal ["bar", "baz", "foo"], r.keys("*").sort
+
+    assert_equal 1, r.del(["foo"])
+
+    assert_equal ["bar", "baz"], r.keys("*").sort
+
+    assert_equal 2, r.del(["bar", "baz"])
+
+    assert_equal [], r.keys("*").sort
+  end
+
+  def test_randomkey
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.randomkey
+    end
+  end
+
+  def test_rename
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.set("foo", "s1")
+      r.rename "foo", "bar"
+    end
+
+    assert_equal "s1", r.get("foo")
+    assert_equal nil, r.get("bar")
+  end
+
+  def test_renamenx
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.set("foo", "s1")
+      r.rename "foo", "bar"
+    end
+
+    assert_equal "s1", r.get("foo")
+    assert_equal nil , r.get("bar")
+  end
+
+  def test_dbsize
+    assert_equal [0], r.dbsize
+
+    r.set("foo", "s1")
+
+    assert_equal [1], r.dbsize
+  end
+
+  def test_flushdb
+    r.set("foo", "s1")
+    r.set("bar", "s2")
+
+    assert_equal [2], r.dbsize
+
+    r.flushdb
+
+    assert_equal [0], r.dbsize
+  end
+
+  def test_migrate
+    r.set("foo", "s1")
+
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.migrate("foo", {})
+    end
+  end
+end

data/test/distributed_commands_requiring_clustering_test.rb

@@ -0,0 +1,164 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class TestDistributedCommandsRequiringClustering < Test::Unit::TestCase
+
+  include Helper::Distributed
+
+  def test_rename
+    r.set("{qux}foo", "s1")
+    r.rename "{qux}foo", "{qux}bar"
+
+    assert_equal "s1", r.get("{qux}bar")
+    assert_equal nil, r.get("{qux}foo")
+  end
+
+  def test_renamenx
+    r.set("{qux}foo", "s1")
+    r.set("{qux}bar", "s2")
+
+    assert_equal false, r.renamenx("{qux}foo", "{qux}bar")
+
+    assert_equal "s1", r.get("{qux}foo")
+    assert_equal "s2", r.get("{qux}bar")
+  end
+
+  def test_brpoplpush
+    r.rpush "{qux}foo", "s1"
+    r.rpush "{qux}foo", "s2"
+
+    assert_equal "s2", r.brpoplpush("{qux}foo", "{qux}bar", :timeout => 1)
+    assert_equal ["s2"], r.lrange("{qux}bar", 0, -1)
+  end
+
+  def test_rpoplpush
+    r.rpush "{qux}foo", "s1"
+    r.rpush "{qux}foo", "s2"
+
+    assert_equal "s2", r.rpoplpush("{qux}foo", "{qux}bar")
+    assert_equal ["s2"], r.lrange("{qux}bar", 0, -1)
+    assert_equal "s1", r.rpoplpush("{qux}foo", "{qux}bar")
+    assert_equal ["s1", "s2"], r.lrange("{qux}bar", 0, -1)
+  end
+
+  def test_smove
+    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
+
+  def test_sinter
+    r.sadd "{qux}foo", "s1"
+    r.sadd "{qux}foo", "s2"
+    r.sadd "{qux}bar", "s2"
+
+    assert_equal ["s2"], r.sinter("{qux}foo", "{qux}bar")
+  end
+
+  def test_sinterstore
+    r.sadd "{qux}foo", "s1"
+    r.sadd "{qux}foo", "s2"
+    r.sadd "{qux}bar", "s2"
+
+    r.sinterstore("{qux}baz", "{qux}foo", "{qux}bar")
+
+    assert_equal ["s2"], r.smembers("{qux}baz")
+  end
+
+  def test_sunion
+    r.sadd "{qux}foo", "s1"
+    r.sadd "{qux}foo", "s2"
+    r.sadd "{qux}bar", "s2"
+    r.sadd "{qux}bar", "s3"
+
+    assert_equal ["s1", "s2", "s3"], r.sunion("{qux}foo", "{qux}bar").sort
+  end
+
+  def test_sunionstore
+    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_equal ["s1", "s2", "s3"], r.smembers("{qux}baz").sort
+  end
+
+  def test_sdiff
+    r.sadd "{qux}foo", "s1"
+    r.sadd "{qux}foo", "s2"
+    r.sadd "{qux}bar", "s2"
+    r.sadd "{qux}bar", "s3"
+
+    assert_equal ["s1"], r.sdiff("{qux}foo", "{qux}bar")
+    assert_equal ["s3"], r.sdiff("{qux}bar", "{qux}foo")
+  end
+
+  def test_sdiffstore
+    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_equal ["s1"], r.smembers("{qux}baz")
+  end
+
+  def test_sort
+    r.set("{qux}foo:1", "s1")
+    r.set("{qux}foo:2", "s2")
+
+    r.rpush("{qux}bar", "1")
+    r.rpush("{qux}bar", "2")
+
+    assert_equal ["s1"], r.sort("{qux}bar", :get => "{qux}foo:*", :limit => [0, 1])
+    assert_equal ["s2"], r.sort("{qux}bar", :get => "{qux}foo:*", :limit => [0, 1], :order => "desc alpha")
+  end
+
+  def test_sort_with_an_array_of_gets
+    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_equal [["s1a", "s1b"]], r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"], :limit => [0, 1])
+    assert_equal [["s2a", "s2b"]], r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"], :limit => [0, 1], :order => "desc alpha")
+    assert_equal [["s1a", "s1b"], ["s2a", "s2b"]], r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"])
+  end
+
+  def test_sort_with_store
+    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_equal ["s1", "s2"], r.lrange("{qux}baz", 0, -1)
+  end
+
+  def test_bitop
+    target_version "2.5.10" do
+      r.set("{qux}foo", "a")
+      r.set("{qux}bar", "b")
+
+      r.bitop(:and, "{qux}foo&bar", "{qux}foo", "{qux}bar")
+      assert_equal "\x60", r.get("{qux}foo&bar")
+      r.bitop(:or, "{qux}foo|bar", "{qux}foo", "{qux}bar")
+      assert_equal "\x63", r.get("{qux}foo|bar")
+      r.bitop(:xor, "{qux}foo^bar", "{qux}foo", "{qux}bar")
+      assert_equal "\x03", r.get("{qux}foo^bar")
+      r.bitop(:not, "{qux}~foo", "{qux}foo")
+      assert_equal "\x9E", r.get("{qux}~foo")
+    end
+  end
+end

data/test/distributed_connection_handling_test.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class TestDistributedConnectionHandling < Test::Unit::TestCase
+
+  include Helper::Distributed
+
+  def test_ping
+    assert_equal ["PONG"], r.ping
+  end
+
+  def test_select
+    r.set "foo", "bar"
+
+    r.select 14
+    assert_equal nil, r.get("foo")
+
+    r.select 15
+
+    assert_equal "bar", r.get("foo")
+  end
+end