modesty 0.1.0

data/vendor/redis-rb/test/publish_subscribe_test.rb

@@ -0,0 +1,151 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "SUBSCRIBE and UNSUBSCRIBE" do |r|
+  thread = Thread.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
+    end
+  end
+
+  Redis.new(OPTIONS).publish("foo", "s1")
+
+  thread.join
+
+  assert @subscribed
+  assert 1 == @t1
+  assert @unsubscribed
+  assert 0 == @t2
+  assert "s1" == @message
+end
+
+test "PSUBSCRIBE and PUNSUBSCRIBE" do |r|
+  listening = false
+
+  thread = Thread.new do
+    r.psubscribe("f*") do |on|
+      on.psubscribe do |pattern, total|
+        @subscribed = true
+        @t1 = total
+      end
+
+      on.pmessage do |pattern, channel, message|
+        if message == "s1"
+          r.punsubscribe
+          @message = message
+        end
+      end
+
+      on.punsubscribe do |pattern, total|
+        @unsubscribed = true
+        @t2 = total
+      end
+
+      listening = true
+    end
+  end
+
+  while !listening; end
+
+  Redis.new(OPTIONS).publish("foo", "s1")
+
+  thread.join
+
+  assert @subscribed
+  assert 1 == @t1
+  assert @unsubscribed
+  assert 0 == @t2
+  assert "s1" == @message
+end
+
+test "SUBSCRIBE within SUBSCRIBE" do |r|
+  listening = false
+
+  @channels = []
+
+  thread = Thread.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
+
+  while !listening; end
+
+  Redis.new(OPTIONS).publish("foo", "s1")
+
+  thread.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
+
+test "UNSUBSCRIBE without a SUBSCRIBE" do |r|
+  assert_raise RuntimeError do
+    r.unsubscribe
+  end
+
+  assert_raise RuntimeError do
+    r.punsubscribe
+  end
+end
+
+test "SUBSCRIBE past a timeout" do |r|
+  # For some reason, a thread here doesn't reproduce the issue.
+  fork do
+    sleep OPTIONS[:timeout] + 1
+    Redis.new(OPTIONS).publish "foo", "bar"
+  end
+
+  received = false
+
+  r.subscribe "foo" do |on|
+    on.message do |channel, message|
+      received = true
+      r.unsubscribe
+    end
+  end
+
+  assert received
+end

data/vendor/redis-rb/test/redis_mock.rb

@@ -0,0 +1,64 @@
+require "socket"
+
+module RedisMock
+  def self.start(port = 6380)
+    server = TCPServer.new("127.0.0.1", port)
+
+    loop do
+      session = server.accept
+
+      while line = session.gets
+        parts = Array.new(line[1..-3].to_i) do
+          bytes = session.gets[1..-3].to_i
+          argument = session.read(bytes)
+          session.read(2) # Discard \r\n
+          argument
+        end
+
+        response = yield(*parts)
+
+        if response.nil?
+          session.shutdown(Socket::SHUT_RDWR)
+          break
+        else
+          session.write(response)
+          session.write("\r\n")
+        end
+      end
+    end
+  end
+
+  module Helper
+    # Forks the current process and starts a new mock Redis server on
+    # port 6380.
+    #
+    # The server will reply with a `+OK` to all commands, but you can
+    # customize it by providing a hash. For example:
+    #
+    #     redis_mock(:ping => lambda { "+PONG" }) do
+    #       assert_equal "PONG", Redis.new(:port => 6380).ping
+    #     end
+    #
+    def redis_mock(replies = {})
+      begin
+        pid = fork do
+          trap("TERM") { exit }
+
+          RedisMock.start do |command, *args|
+            (replies[command.to_sym] || lambda { |*_| "+OK" }).call(*args)
+          end
+        end
+
+        sleep 1 # Give time for the socket to start listening.
+
+        yield
+
+      ensure
+        if pid
+          Process.kill("TERM", pid)
+          Process.wait(pid)
+        end
+      end
+    end
+  end
+end

data/vendor/redis-rb/test/remote_server_control_commands_test.rb

@@ -0,0 +1,56 @@
+# 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
+  init Redis.new(OPTIONS)
+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|
+    assert r.info.keys.include?(x)
+  end
+end
+
+test "MONITOR" do |r|
+  log = []
+
+  t1 = Thread.new do
+    Redis.new(OPTIONS).monitor do |line|
+      log << line
+      break if log.size == 3
+    end
+  end
+
+  while log.empty?; end # Faster than sleep
+
+  r.set "foo", "s1"
+
+  t1.join
+
+  assert log[-1][%q{(db 15) "set" "foo" "s1"}]
+end
+
+test "ECHO" do |r|
+  assert "foo bar baz\n" == r.echo("foo bar baz\n")
+end
+
+test "DEBUG" do |r|
+  r.set "foo", "s1"
+
+  assert r.debug(:object, "foo").kind_of?(String)
+end
+
+test "SYNC" do |r|
+  replies = {:sync => lambda { "+OK" }}
+
+  redis_mock(replies) do
+    redis = Redis.new(OPTIONS.merge(:port => 6380))
+
+    assert "OK" == redis.sync
+  end
+end
+

data/vendor/redis-rb/test/sorting_test.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "SORT" do |r|
+  r.set("foo:1", "s1")
+  r.set("foo:2", "s2")
+
+  r.rpush("bar", "1")
+  r.rpush("bar", "2")
+
+  assert ["s1"] == r.sort("bar", :get => "foo:*", :limit => [0, 1])
+  assert ["s2"] == r.sort("bar", :get => "foo:*", :limit => [0, 1], :order => "desc alpha")
+end
+
+test "SORT with an array of GETs" do |r|
+  r.set("foo:1:a", "s1a")
+  r.set("foo:1:b", "s1b")
+
+  r.set("foo:2:a", "s2a")
+  r.set("foo:2:b", "s2b")
+
+  r.rpush("bar", "1")
+  r.rpush("bar", "2")
+
+  assert ["s1a", "s1b"] == r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1])
+  assert ["s2a", "s2b"] == r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1], :order => "desc alpha")
+end
+
+test "SORT with STORE" do |r|
+  r.set("foo:1", "s1")
+  r.set("foo:2", "s2")
+
+  r.rpush("bar", "1")
+  r.rpush("bar", "2")
+
+  r.sort("bar", :get => "foo:*", :store => "baz")
+  assert ["s1", "s2"] == r.lrange("baz", 0, -1)
+end
+

data/vendor/redis-rb/test/test.conf

@@ -0,0 +1,8 @@
+dir ./test/db
+pidfile ./redis.pid
+port 6379
+timeout 300
+loglevel debug
+logfile stdout
+databases 16
+daemonize yes

data/vendor/redis-rb/test/thread_safety_test.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "thread safety" do |r|
+  r = init Redis.new(OPTIONS.merge(:thread_safe => true))
+  r.client.disconnect
+
+  r1, r2 = nil
+
+  t1 = Thread.new do
+    r1 = r.client.process([:set, "foo", 1]) do
+      sleep 1
+      r.client.send(:read)
+    end
+  end
+
+  t2 = Thread.new do
+    r2 = r.client.process([:get, "foo"]) do
+      r.client.send(:read)
+    end
+  end
+
+  t1.join
+  t2.join
+
+  assert "OK" == r1
+  assert "1" == r2
+end
+

data/vendor/redis-rb/test/transactions_test.rb

@@ -0,0 +1,91 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "MULTI/DISCARD" do |r|
+  r.multi
+
+  assert "QUEUED" == r.set("foo", "1")
+  assert "QUEUED" == r.get("foo")
+
+  r.discard
+
+  assert nil == r.get("foo")
+end
+
+test "MULTI/EXEC with a block" do |r|
+  r.multi do |r|
+    r.set "foo", "s1"
+  end
+
+  assert "s1" == r.get("foo")
+
+  begin
+    r.multi do
+      r.set "bar", "s2"
+      raise "Some error"
+      r.set "baz", "s3"
+    end
+  rescue
+  end
+
+  assert nil == r.get("bar")
+  assert nil == r.get("baz")
+end
+
+test "MULTI/EXEC with a block operating on a wrong kind of key" do |r|
+  begin
+    r.multi do |r|
+      r.set "foo", "s1"
+      r.lpush "foo", "s2"
+      r.get "foo"
+    end
+  rescue RuntimeError
+  end
+
+  assert "s1" == r.get("foo")
+end
+
+test "MULTI with a block yielding the client" do |r|
+  r.multi do |multi|
+    multi.set "foo", "s1"
+  end
+
+  assert "s1" == r.get("foo")
+end
+
+test "WATCH with an unmodified key" do |r|
+  r.watch "foo"
+  r.multi do |multi|
+    multi.set "foo", "s1"
+  end
+
+  assert "s1" == r.get("foo")
+end
+
+test "WATCH with a modified key" do |r|
+  r.watch "foo"
+  r.set "foo", "s1"
+  res = r.multi do |multi|
+    multi.set "foo", "s2"
+  end
+
+  assert nil == res
+  assert "s1" == r.get("foo")
+end
+
+test "UNWATCH with a modified key" do |r|
+  r.watch "foo"
+  r.set "foo", "s1"
+  r.unwatch
+  r.multi do |multi|
+    multi.set "foo", "s2"
+  end
+
+  assert "s2" == r.get("foo")
+end
+