modesty 0.1.0

data/vendor/redis-rb/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/vendor/redis-rb/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/vendor/redis-rb/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/vendor/redis-rb/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/vendor/redis-rb/test/helper.rb

@@ -0,0 +1,86 @@
+$:.unshift File.expand_path('../lib', File.dirname(__FILE__))
+
+require "cutest"
+require "logger"
+require "stringio"
+
+begin
+  require "ruby-debug"
+rescue LoadError
+end
+
+PORT    = 6379
+OPTIONS = {:port => PORT, :db => 15, :timeout => 3}
+NODES   = ["redis://127.0.0.1:6379/15"]
+
+def init(redis)
+  begin
+    redis.flushdb
+    redis.select 14
+    redis.flushdb
+    redis.select 15
+    redis
+  rescue Errno::ECONNREFUSED
+    puts <<-EOS
+
+      Cannot connect to Redis.
+
+      Make sure Redis is running on localhost, port 6379.
+      This testing suite connects to the database 15.
+
+      To install redis:
+        visit <http://code.google.com/p/redis/>.
+
+      To start the server:
+        rake start
+
+      To stop the server:
+        rake stop
+
+    EOS
+    exit 1
+  end
+end
+
+$VERBOSE = true
+
+require "redis"
+
+def capture_stderr
+  stderr = $stderr
+  $stderr = StringIO.new
+
+  yield
+
+  $stderr = stderr
+end
+
+def silent
+  verbose, $VERBOSE = $VERBOSE, false
+
+  begin
+    yield
+  ensure
+    $VERBOSE = verbose
+  end
+end
+
+def with_external_encoding(encoding)
+  original_encoding = Encoding.default_external
+
+  begin
+    silent { Encoding.default_external = Encoding.find(encoding) }
+    yield
+  ensure
+    silent { Encoding.default_external = original_encoding }
+  end
+end
+
+def assert_nothing_raised(*exceptions)
+  begin
+    yield
+  rescue *exceptions
+    flunk(caller[1])
+  end
+end
+

data/vendor/redis-rb/test/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
+
+setup do
+  log = StringIO.new
+
+  [Redis.new(OPTIONS.merge(:logger => ::Logger.new(log))), log]
+end
+
+$TEST_PIPELINING = true
+$TEST_INSPECT    = true
+
+load File.expand_path("./lint/internals.rb", File.dirname(__FILE__))
+
+test "Redis.current" do
+  Redis.current.set("foo", "bar")
+
+  assert "bar" == Redis.current.get("foo")
+
+  Redis.current = Redis.new(OPTIONS.merge(:db => 14))
+
+  assert Redis.current.get("foo").nil?
+end

data/vendor/redis-rb/test/lint/hashes.rb

@@ -0,0 +1,90 @@
+test "HSET and HGET" do |r|
+  r.hset("foo", "f1", "s1")
+
+  assert "s1" == r.hget("foo", "f1")
+end
+
+test "HDEL" do |r|
+  r.hset("foo", "f1", "s1")
+
+  assert "s1" == r.hget("foo", "f1")
+
+  r.hdel("foo", "f1")
+
+  assert nil == r.hget("foo", "f1")
+end
+
+test "HEXISTS" do |r|
+  assert false == r.hexists("foo", "f1")
+
+  r.hset("foo", "f1", "s1")
+
+  assert r.hexists("foo", "f1")
+end
+
+test "HLEN" do |r|
+  assert 0 == r.hlen("foo")
+
+  r.hset("foo", "f1", "s1")
+
+  assert 1 == r.hlen("foo")
+
+  r.hset("foo", "f2", "s2")
+
+  assert 2 == r.hlen("foo")
+end
+
+test "HKEYS" do |r|
+  assert [] == r.hkeys("foo")
+
+  r.hset("foo", "f1", "s1")
+  r.hset("foo", "f2", "s2")
+
+  assert ["f1", "f2"] == r.hkeys("foo")
+end
+
+test "HVALS" do |r|
+  assert [] == r.hvals("foo")
+
+  r.hset("foo", "f1", "s1")
+  r.hset("foo", "f2", "s2")
+
+  assert ["s1", "s2"] == r.hvals("foo")
+end
+
+test "HGETALL" do |r|
+  assert({} == r.hgetall("foo"))
+
+  r.hset("foo", "f1", "s1")
+  r.hset("foo", "f2", "s2")
+
+  assert({"f1" => "s1", "f2" => "s2"} == r.hgetall("foo"))
+end
+
+test "HMSET" do |r|
+  r.hmset("hash", "foo1", "bar1", "foo2", "bar2")
+
+  assert "bar1" == r.hget("hash", "foo1")
+  assert "bar2" == r.hget("hash", "foo2")
+end
+
+test "HMSET with invalid arguments" do |r|
+  assert_raise(RuntimeError) do
+    r.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3")
+  end
+end
+
+test "HINCRBY" do |r|
+  r.hincrby("foo", "f1", 1)
+
+  assert "1" == r.hget("foo", "f1")
+
+  r.hincrby("foo", "f1", 2)
+
+  assert "3" == r.hget("foo", "f1")
+
+  r.hincrby("foo", "f1", -1)
+
+  assert "2" == r.hget("foo", "f1")
+end
+

data/vendor/redis-rb/test/lint/internals.rb

@@ -0,0 +1,53 @@
+test "Logger" do |r, log|
+  r.ping
+  
+  assert log.string =~ /Redis >> PING/
+  assert log.string =~ /Redis >> \d+\.\d+ms/
+end
+
+test "Logger with pipelining" do |r, log|
+  r.pipelined do
+    r.set "foo", "bar"
+    r.get "foo"
+  end
+
+  assert log.string["SET foo bar"]
+  assert log.string["GET foo"]
+end if $TEST_PIPELINING
+
+test "Timeout" do
+  assert_nothing_raised do
+    Redis.new(OPTIONS.merge(:timeout => 0))
+  end
+end
+
+test "Connection timeout" do
+  assert_raise(Timeout::Error) do
+    Redis.new(OPTIONS.merge(:host => "127.0.0.2", :timeout => 1)).ping
+  end
+end
+
+test "Recovers from failed commands" do |r, _|
+  # See http://github.com/ezmobius/redis-rb/issues#issue/28
+
+  assert_raise(ArgumentError) do
+    r.srem "foo"
+  end
+
+  assert_nothing_raised do
+    r.info
+  end
+end
+
+test "provides a meaningful inspect" do |r, _|
+  assert "#<Redis client v#{Redis::VERSION} connected to redis://127.0.0.1:6379/15 (Redis v#{r.info["redis_version"]})>" == r.inspect
+end if $TEST_INSPECT
+
+test "raises on protocol errors" do
+  redis_mock(:ping => lambda { |*_| "foo" }) do
+    assert_raise(Redis::ProtocolError) do
+      Redis.connect(:port => 6380).ping
+    end
+  end
+end
+

data/vendor/redis-rb/test/lint/lists.rb

@@ -0,0 +1,93 @@
+test "RPUSH" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+  assert "s2" == r.rpop("foo")
+end
+
+test "LPUSH" do |r|
+  r.lpush "foo", "s1"
+  r.lpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+  assert "s2" == r.lpop("foo")
+end
+
+test "LLEN" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+end
+
+test "LRANGE" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+  r.rpush "foo", "s3"
+
+  assert ["s2", "s3"] == r.lrange("foo", 1, -1)
+  assert ["s1", "s2"] == r.lrange("foo", 0, 1)
+
+  assert [] == r.lrange("bar", 0, -1)
+end
+
+test "LTRIM" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+  r.rpush "foo", "s3"
+
+  r.ltrim "foo", 0, 1
+
+  assert 2 == r.llen("foo")
+  assert ["s1", "s2"] == r.lrange("foo", 0, -1)
+end
+
+test "LINDEX" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert "s1" == r.lindex("foo", 0)
+  assert "s2" == r.lindex("foo", 1)
+end
+
+test "LSET" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert "s2" == r.lindex("foo", 1)
+  assert r.lset("foo", 1, "s3")
+  assert "s3" == r.lindex("foo", 1)
+
+  assert_raise RuntimeError do
+    r.lset("foo", 4, "s3")
+  end
+end
+
+test "LREM" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 1 == r.lrem("foo", 1, "s1")
+  assert ["s2"] == r.lrange("foo", 0, -1)
+end
+
+test "LPOP" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+  assert "s1" == r.lpop("foo")
+  assert 1 == r.llen("foo")
+end
+
+test "RPOP" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+  assert "s2" == r.rpop("foo")
+  assert 1 == r.llen("foo")
+end
+
+