finsync_redis 3.3.5

data/redis.gemspec

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+$:.unshift File.expand_path("../lib", __FILE__)
+
+require "redis/version"
+
+Gem::Specification.new do |s|
+  s.name = "finsync_redis"
+
+  s.version = Redis::VERSION
+
+  s.homepage = "https://github.com/finsync/redis-rb"
+
+  s.summary = "FINSYNC modifications for Redis"
+
+  s.description = <<-EOS
+    A Ruby client that tries to match Redis' API one-to-one, while still
+    providing an idiomatic interface. It features thread-safety,
+    client-side sharding, pipelining, and an obsession for performance.
+  EOS
+
+  s.license = "MIT"
+
+  s.authors = [
+    "Ezra Zygmuntowicz",
+    "Taylor Weibley",
+    "Matthew Clark",
+    "Brian McKinney",
+    "Salvatore Sanfilippo",
+    "Luca Guidi",
+    "Michel Martens",
+    "Damian Janowski",
+    "Pieter Noordhuis"
+  ]
+
+  s.email = ["redis-db@googlegroups.com"]
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+
+  s.add_development_dependency("rake", "<11.0.0")
+  s.add_development_dependency("test-unit", "3.1.5")
+end

data/test/bitpos_test.rb

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+unless defined?(Enumerator)
+  Enumerator = Enumerable::Enumerator
+end
+
+class TestBitpos < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_bitpos_empty_zero
+    target_version "2.9.11" do
+      r.del "foo"
+      assert_equal 0, r.bitpos("foo", 0)
+    end
+  end
+
+  def test_bitpos_empty_one
+    target_version "2.9.11" do
+      r.del "foo"
+      assert_equal -1, r.bitpos("foo", 1)
+    end
+  end
+
+  def test_bitpos_zero
+    target_version "2.9.11" do
+      r.set "foo", "\xff\xf0\x00"
+      assert_equal 12, r.bitpos("foo", 0)
+    end
+  end
+
+  def test_bitpos_one
+    target_version "2.9.11" do
+      r.set "foo", "\x00\x0f\x00"
+      assert_equal 12, r.bitpos("foo", 1)
+    end
+  end
+
+  def test_bitpos_zero_end_is_given
+    target_version "2.9.11" do
+      r.set "foo", "\xff\xff\xff"
+      assert_equal 24, r.bitpos("foo", 0)
+      assert_equal 24, r.bitpos("foo", 0, 0)
+      assert_equal -1, r.bitpos("foo", 0, 0, -1)
+    end
+  end
+
+  def test_bitpos_one_intervals
+    target_version "2.9.11" do
+      r.set "foo", "\x00\xff\x00"
+      assert_equal 8,  r.bitpos("foo", 1, 0, -1)
+      assert_equal 8,  r.bitpos("foo", 1, 1, -1)
+      assert_equal -1, r.bitpos("foo", 1, 2, -1)
+      assert_equal -1, r.bitpos("foo", 1, 2, 200)
+      assert_equal 8,  r.bitpos("foo", 1, 1, 1)
+    end
+  end
+
+  def test_bitpos_raise_exception_if_stop_not_start
+    target_version "2.9.11" do
+      assert_raises(ArgumentError) do
+        r.bitpos("foo", 0, nil, 2)
+      end
+    end
+  end
+
+end

data/test/blocking_commands_test.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/blocking_commands"
+
+class TestBlockingCommands < Test::Unit::TestCase
+
+  include Helper::Client
+  include Lint::BlockingCommands
+
+  def assert_takes_longer_than_client_timeout
+    timeout = OPTIONS[:timeout]
+    delay = timeout * 2
+
+    mock(:delay => delay) do |r|
+      t1 = Time.now
+      yield(r)
+      t2 = Time.now
+
+      assert timeout == r.client.timeout
+      assert delay <= (t2 - t1)
+    end
+  end
+
+  def test_blpop_disable_client_timeout
+    assert_takes_longer_than_client_timeout do |r|
+      assert_equal ["foo", "0"], r.blpop("foo")
+    end
+  end
+
+  def test_brpop_disable_client_timeout
+    assert_takes_longer_than_client_timeout do |r|
+      assert_equal ["foo", "0"], r.brpop("foo")
+    end
+  end
+
+  def test_brpoplpush_disable_client_timeout
+    assert_takes_longer_than_client_timeout do |r|
+      assert_equal "0", r.brpoplpush("foo", "bar")
+    end
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,59 @@
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class TestClient < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_call
+    result = r.call("PING")
+    assert_equal result, "PONG"
+  end
+
+  def test_call_with_arguments
+    result = r.call("SET", "foo", "bar")
+    assert_equal result, "OK"
+  end
+
+  def test_call_integers
+    result = r.call("INCR", "foo")
+    assert_equal result, 1
+  end
+
+  def test_call_raise
+    assert_raises(Redis::CommandError) do
+      r.call("INCR")
+    end
+  end
+
+  def test_queue_commit
+    r.queue("SET", "foo", "bar")
+    r.queue("GET", "foo")
+    result = r.commit
+
+    assert_equal result, ["OK", "bar"]
+  end
+
+  def test_commit_raise
+    r.queue("SET", "foo", "bar")
+    r.queue("INCR")
+
+    assert_raise(Redis::CommandError) do
+      r.commit
+    end
+  end
+
+  def test_queue_after_error
+    r.queue("SET", "foo", "bar")
+    r.queue("INCR")
+
+    assert_raise(Redis::CommandError) do
+      r.commit
+    end
+
+    r.queue("SET",  "foo", "bar")
+    r.queue("INCR", "baz")
+    result = r.commit
+
+    assert_equal result, ["OK", 1]
+  end
+end

data/test/command_map_test.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class TestCommandMap < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_override_existing_commands
+    r.set("counter", 1)
+
+    assert_equal 2, r.incr("counter")
+
+    r.client.command_map[:incr] = :decr
+
+    assert_equal 1, r.incr("counter")
+  end
+
+  def test_override_non_existing_commands
+    r.set("key", "value")
+
+    assert_raise Redis::CommandError do
+      r.idontexist("key")
+    end
+
+    r.client.command_map[:idontexist] = :get
+
+    assert_equal "value", r.idontexist("key")
+  end
+end

data/test/commands_on_hashes_test.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/hashes"
+
+class TestCommandsOnHashes < Test::Unit::TestCase
+
+  include Helper::Client
+  include Lint::Hashes
+
+  def test_mapped_hmget_in_a_pipeline_returns_hash
+    r.hset("foo", "f1", "s1")
+    r.hset("foo", "f2", "s2")
+
+    result = r.pipelined do
+      r.mapped_hmget("foo", "f1", "f2")
+    end
+
+    assert_equal result[0], { "f1" => "s1", "f2" => "s2" }
+  end
+end

data/test/commands_on_hyper_log_log_test.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/hyper_log_log"
+
+class TestCommandsOnHyperLogLog < Test::Unit::TestCase
+
+  include Helper::Client
+  include Lint::HyperLogLog
+
+  def test_pfmerge
+    target_version "2.8.9" do
+      r.pfadd "foo", "s1"
+      r.pfadd "bar", "s2"
+
+      assert_equal true, r.pfmerge("res", "foo", "bar")
+      assert_equal 2, r.pfcount("res")
+    end
+  end
+
+end

data/test/commands_on_lists_test.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/lists"
+
+class TestCommandsOnLists < Test::Unit::TestCase
+
+  include Helper::Client
+  include Lint::Lists
+
+  def test_rpoplpush
+    r.rpush "foo", "s1"
+    r.rpush "foo", "s2"
+
+    assert_equal "s2", r.rpoplpush("foo", "bar")
+    assert_equal ["s2"], r.lrange("bar", 0, -1)
+    assert_equal "s1", r.rpoplpush("foo", "bar")
+    assert_equal ["s1", "s2"], r.lrange("bar", 0, -1)
+  end
+end

data/test/commands_on_sets_test.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/sets"
+
+class TestCommandsOnSets < Test::Unit::TestCase
+
+  include Helper::Client
+  include Lint::Sets
+
+  def test_smove
+    r.sadd "foo", "s1"
+    r.sadd "bar", "s2"
+
+    assert r.smove("foo", "bar", "s1")
+    assert r.sismember("bar", "s1")
+  end
+
+  def test_sinter
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+    r.sadd "bar", "s2"
+
+    assert_equal ["s2"], r.sinter("foo", "bar")
+  end
+
+  def test_sinterstore
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+    r.sadd "bar", "s2"
+
+    r.sinterstore("baz", "foo", "bar")
+
+    assert_equal ["s2"], r.smembers("baz")
+  end
+
+  def test_sunion
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+    r.sadd "bar", "s2"
+    r.sadd "bar", "s3"
+
+    assert_equal ["s1", "s2", "s3"], r.sunion("foo", "bar").sort
+  end
+
+  def test_sunionstore
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+    r.sadd "bar", "s2"
+    r.sadd "bar", "s3"
+
+    r.sunionstore("baz", "foo", "bar")
+
+    assert_equal ["s1", "s2", "s3"], r.smembers("baz").sort
+  end
+
+  def test_sdiff
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+    r.sadd "bar", "s2"
+    r.sadd "bar", "s3"
+
+    assert_equal ["s1"], r.sdiff("foo", "bar")
+    assert_equal ["s3"], r.sdiff("bar", "foo")
+  end
+
+  def test_sdiffstore
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+    r.sadd "bar", "s2"
+    r.sadd "bar", "s3"
+
+    r.sdiffstore("baz", "foo", "bar")
+
+    assert_equal ["s1"], r.smembers("baz")
+  end
+end

data/test/commands_on_sorted_sets_test.rb

@@ -0,0 +1,137 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/sorted_sets"
+
+class TestCommandsOnSortedSets < Test::Unit::TestCase
+
+  include Helper::Client
+  include Lint::SortedSets
+
+  def test_zrangebylex
+    target_version "2.8.9" do
+      r.zadd "foo", 0, "aaren"
+      r.zadd "foo", 0, "abagael"
+      r.zadd "foo", 0, "abby"
+      r.zadd "foo", 0, "abbygail"
+
+      assert_equal ["aaren", "abagael", "abby", "abbygail"], r.zrangebylex("foo", "[a", "[a\xff")
+      assert_equal ["aaren", "abagael"], r.zrangebylex("foo", "[a", "[a\xff", :limit => [0, 2])
+      assert_equal ["abby", "abbygail"], r.zrangebylex("foo", "(abb", "(abb\xff")
+      assert_equal ["abbygail"], r.zrangebylex("foo", "(abby", "(abby\xff")
+    end
+  end
+
+  def test_zrevrangebylex
+    target_version "2.9.9" do
+      r.zadd "foo", 0, "aaren"
+      r.zadd "foo", 0, "abagael"
+      r.zadd "foo", 0, "abby"
+      r.zadd "foo", 0, "abbygail"
+
+      assert_equal ["abbygail", "abby", "abagael", "aaren"], r.zrevrangebylex("foo", "[a\xff", "[a")
+      assert_equal ["abbygail", "abby"], r.zrevrangebylex("foo", "[a\xff", "[a", :limit => [0, 2])
+      assert_equal ["abbygail", "abby"], r.zrevrangebylex("foo", "(abb\xff", "(abb")
+      assert_equal ["abbygail"], r.zrevrangebylex("foo", "(abby\xff", "(abby")
+    end
+  end
+
+  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
+
+  def test_zunionstore
+    r.zadd "foo", 1, "s1"
+    r.zadd "bar", 2, "s2"
+    r.zadd "foo", 3, "s3"
+    r.zadd "bar", 4, "s4"
+
+    assert_equal 4, r.zunionstore("foobar", ["foo", "bar"])
+    assert_equal ["s1", "s2", "s3", "s4"], r.zrange("foobar", 0, -1)
+  end
+
+  def test_zunionstore_with_weights
+    r.zadd "foo", 1, "s1"
+    r.zadd "foo", 3, "s3"
+    r.zadd "bar", 20, "s2"
+    r.zadd "bar", 40, "s4"
+
+    assert_equal 4, r.zunionstore("foobar", ["foo", "bar"])
+    assert_equal ["s1", "s3", "s2", "s4"], r.zrange("foobar", 0, -1)
+
+    assert_equal 4, r.zunionstore("foobar", ["foo", "bar"], :weights => [10, 1])
+    assert_equal ["s1", "s2", "s3", "s4"], r.zrange("foobar", 0, -1)
+  end
+
+  def test_zunionstore_with_aggregate
+    r.zadd "foo", 1, "s1"
+    r.zadd "foo", 2, "s2"
+    r.zadd "bar", 4, "s2"
+    r.zadd "bar", 3, "s3"
+
+    assert_equal 3, r.zunionstore("foobar", ["foo", "bar"])
+    assert_equal ["s1", "s3", "s2"], r.zrange("foobar", 0, -1)
+
+    assert_equal 3, r.zunionstore("foobar", ["foo", "bar"], :aggregate => :min)
+    assert_equal ["s1", "s2", "s3"], r.zrange("foobar", 0, -1)
+
+    assert_equal 3, r.zunionstore("foobar", ["foo", "bar"], :aggregate => :max)
+    assert_equal ["s1", "s3", "s2"], r.zrange("foobar", 0, -1)
+  end
+
+  def test_zinterstore
+    r.zadd "foo", 1, "s1"
+    r.zadd "bar", 2, "s1"
+    r.zadd "foo", 3, "s3"
+    r.zadd "bar", 4, "s4"
+
+    assert_equal 1, r.zinterstore("foobar", ["foo", "bar"])
+    assert_equal ["s1"], r.zrange("foobar", 0, -1)
+  end
+
+  def test_zinterstore_with_weights
+    r.zadd "foo", 1, "s1"
+    r.zadd "foo", 2, "s2"
+    r.zadd "foo", 3, "s3"
+    r.zadd "bar", 20, "s2"
+    r.zadd "bar", 30, "s3"
+    r.zadd "bar", 40, "s4"
+
+    assert_equal 2, r.zinterstore("foobar", ["foo", "bar"])
+    assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1)
+
+    assert_equal 2, r.zinterstore("foobar", ["foo", "bar"], :weights => [10, 1])
+    assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1)
+
+    assert_equal 40.0, r.zscore("foobar", "s2")
+    assert_equal 60.0, r.zscore("foobar", "s3")
+  end
+
+  def test_zinterstore_with_aggregate
+    r.zadd "foo", 1, "s1"
+    r.zadd "foo", 2, "s2"
+    r.zadd "foo", 3, "s3"
+    r.zadd "bar", 20, "s2"
+    r.zadd "bar", 30, "s3"
+    r.zadd "bar", 40, "s4"
+
+    assert_equal 2, r.zinterstore("foobar", ["foo", "bar"])
+    assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1)
+    assert_equal 22.0, r.zscore("foobar", "s2")
+    assert_equal 33.0, r.zscore("foobar", "s3")
+
+    assert_equal 2, r.zinterstore("foobar", ["foo", "bar"], :aggregate => :min)
+    assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1)
+    assert_equal 2.0, r.zscore("foobar", "s2")
+    assert_equal 3.0, r.zscore("foobar", "s3")
+
+    assert_equal 2, r.zinterstore("foobar", ["foo", "bar"], :aggregate => :max)
+    assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1)
+    assert_equal 20.0, r.zscore("foobar", "s2")
+    assert_equal 30.0, r.zscore("foobar", "s3")
+  end
+end

data/test/commands_on_strings_test.rb

@@ -0,0 +1,101 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/strings"
+
+class TestCommandsOnStrings < Test::Unit::TestCase
+
+  include Helper::Client
+  include Lint::Strings
+
+  def test_mget
+    r.set("foo", "s1")
+    r.set("bar", "s2")
+
+    assert_equal ["s1", "s2"]     , r.mget("foo", "bar")
+    assert_equal ["s1", "s2", nil], r.mget("foo", "bar", "baz")
+  end
+
+  def test_mget_mapped
+    r.set("foo", "s1")
+    r.set("bar", "s2")
+
+    response = r.mapped_mget("foo", "bar")
+
+    assert_equal "s1", response["foo"]
+    assert_equal "s2", response["bar"]
+
+    response = r.mapped_mget("foo", "bar", "baz")
+
+    assert_equal "s1", response["foo"]
+    assert_equal "s2", response["bar"]
+    assert_equal nil , response["baz"]
+  end
+
+  def test_mapped_mget_in_a_pipeline_returns_hash
+    r.set("foo", "s1")
+    r.set("bar", "s2")
+
+    result = r.pipelined do
+      r.mapped_mget("foo", "bar")
+    end
+
+    assert_equal result[0], { "foo" => "s1", "bar" => "s2" }
+  end
+
+  def test_mset
+    r.mset(:foo, "s1", :bar, "s2")
+
+    assert_equal "s1", r.get("foo")
+    assert_equal "s2", r.get("bar")
+  end
+
+  def test_mset_mapped
+    r.mapped_mset(:foo => "s1", :bar => "s2")
+
+    assert_equal "s1", r.get("foo")
+    assert_equal "s2", r.get("bar")
+  end
+
+  def test_msetnx
+    r.set("foo", "s1")
+    assert_equal false, r.msetnx(:foo, "s2", :bar, "s3")
+    assert_equal "s1", r.get("foo")
+    assert_equal nil, r.get("bar")
+
+    r.del("foo")
+    assert_equal true, r.msetnx(:foo, "s2", :bar, "s3")
+    assert_equal "s2", r.get("foo")
+    assert_equal "s3", r.get("bar")
+  end
+
+  def test_msetnx_mapped
+    r.set("foo", "s1")
+    assert_equal false, r.mapped_msetnx(:foo => "s2", :bar => "s3")
+    assert_equal "s1", r.get("foo")
+    assert_equal nil, r.get("bar")
+
+    r.del("foo")
+    assert_equal true, r.mapped_msetnx(:foo => "s2", :bar => "s3")
+    assert_equal "s2", r.get("foo")
+    assert_equal "s3", r.get("bar")
+  end
+
+  def test_bitop
+    try_encoding("UTF-8") do
+      target_version "2.5.10" do
+        r.set("foo", "a")
+        r.set("bar", "b")
+
+        r.bitop(:and, "foo&bar", "foo", "bar")
+        assert_equal "\x60", r.get("foo&bar")
+        r.bitop(:or, "foo|bar", "foo", "bar")
+        assert_equal "\x63", r.get("foo|bar")
+        r.bitop(:xor, "foo^bar", "foo", "bar")
+        assert_equal "\x03", r.get("foo^bar")
+        r.bitop(:not, "~foo", "foo")
+        assert_equal "\x9E", r.get("~foo")
+      end
+    end
+  end
+end