remq 0.0.1a → 0.0.3

data/vendor/bundle/gems/redis-3.0.2/test/lint/strings.rb

@@ -0,0 +1,157 @@
+module Lint
+
+  module Strings
+
+    def test_set_and_get
+      r.set("foo", "s1")
+
+      assert_equal "s1", r.get("foo")
+    end
+
+    def test_set_and_get_with_brackets
+      r["foo"] = "s1"
+
+      assert_equal "s1", r["foo"]
+    end
+
+    def test_set_and_get_with_brackets_and_symbol
+      r[:foo] = "s1"
+
+      assert_equal "s1", r[:foo]
+    end
+
+    def test_set_and_get_with_newline_characters
+      r.set("foo", "1\n")
+
+      assert_equal "1\n", r.get("foo")
+    end
+
+    def test_set_and_get_with_ascii_characters
+      if defined?(Encoding)
+        with_external_encoding("ASCII-8BIT") do
+          (0..255).each do |i|
+            str = "#{i.chr}---#{i.chr}"
+            r.set("foo", str)
+
+            assert_equal str, r.get("foo")
+          end
+        end
+      end
+    end
+
+    def test_setex
+      assert r.setex("foo", 1, "bar")
+      assert_equal "bar", r.get("foo")
+      assert [0, 1].include? r.ttl("foo")
+    end
+
+    def test_psetex
+      return if version < "2.5.4"
+
+      assert r.psetex("foo", 1000, "bar")
+      assert_equal "bar", r.get("foo")
+      assert [0, 1].include? r.ttl("foo")
+    end
+
+    def test_getset
+      r.set("foo", "bar")
+
+      assert_equal "bar", r.getset("foo", "baz")
+      assert_equal "baz", r.get("foo")
+    end
+
+    def test_setnx
+      r.set("foo", "s1")
+
+      assert_equal "s1", r.get("foo")
+
+      r.setnx("foo", "s2")
+
+      assert_equal "s1", r.get("foo")
+    end
+
+    def test_incr
+      assert_equal 1, r.incr("foo")
+      assert_equal 2, r.incr("foo")
+      assert_equal 3, r.incr("foo")
+    end
+
+    def test_incrby
+      assert_equal 1, r.incrby("foo", 1)
+      assert_equal 3, r.incrby("foo", 2)
+      assert_equal 6, r.incrby("foo", 3)
+    end
+
+    def test_incrbyfloat
+      return if version < "2.5.4"
+
+      assert_equal 1.23, r.incrbyfloat("foo", 1.23)
+      assert_equal 2   , r.incrbyfloat("foo", 0.77)
+      assert_equal 1.9 , r.incrbyfloat("foo", -0.1)
+    end
+
+    def test_decr
+      r.set("foo", 3)
+
+      assert_equal 2, r.decr("foo")
+      assert_equal 1, r.decr("foo")
+      assert_equal 0, r.decr("foo")
+    end
+
+    def test_decrby
+      r.set("foo", 6)
+
+      assert_equal 3, r.decrby("foo", 3)
+      assert_equal 1, r.decrby("foo", 2)
+      assert_equal 0, r.decrby("foo", 1)
+    end
+
+    def test_append
+      r.set "foo", "s"
+      r.append "foo", "1"
+
+      assert_equal "s1", r.get("foo")
+    end
+
+    def test_getbit
+      r.set("foo", "a")
+
+      assert_equal 1, r.getbit("foo", 1)
+      assert_equal 1, r.getbit("foo", 2)
+      assert_equal 0, r.getbit("foo", 3)
+      assert_equal 0, r.getbit("foo", 4)
+      assert_equal 0, r.getbit("foo", 5)
+      assert_equal 0, r.getbit("foo", 6)
+      assert_equal 1, r.getbit("foo", 7)
+    end
+
+    def test_setbit
+      r.set("foo", "a")
+
+      r.setbit("foo", 6, 1)
+
+      assert_equal "c", r.get("foo")
+    end
+
+    def test_getrange
+      r.set("foo", "abcde")
+
+      assert_equal "bcd", r.getrange("foo", 1, 3)
+      assert_equal "abcde", r.getrange("foo", 0, -1)
+    end
+
+    def test_setrange
+      r.set("foo", "abcde")
+
+      r.setrange("foo", 1, "bar")
+
+      assert_equal "abare", r.get("foo")
+    end
+
+    def test_strlen
+      r.set "foo", "lorem"
+
+      assert_equal 5, r.strlen("foo")
+    end
+  end
+end

data/vendor/bundle/gems/redis-3.0.2/test/lint/value_types.rb

@@ -0,0 +1,106 @@
+module Lint
+
+  module ValueTypes
+
+    def assert_in_range(range, value)
+      assert range.include?(value), "expected #{value} to be in #{range.inspect}"
+    end
+
+    def test_exists
+      assert_equal false, r.exists("foo")
+
+      r.set("foo", "s1")
+
+      assert_equal true,  r.exists("foo")
+    end
+
+    def test_type
+      assert_equal "none", r.type("foo")
+
+      r.set("foo", "s1")
+
+      assert_equal "string", r.type("foo")
+    end
+
+    def test_keys
+      r.set("f", "s1")
+      r.set("fo", "s2")
+      r.set("foo", "s3")
+
+      assert_equal ["f","fo", "foo"], r.keys("f*").sort
+    end
+
+    def test_expire
+      r.set("foo", "s1")
+      assert r.expire("foo", 2)
+      assert_in_range 0..2, r.ttl("foo")
+    end
+
+    def test_pexpire
+      return if version < "2.5.4"
+
+      r.set("foo", "s1")
+      assert r.pexpire("foo", 2000)
+      assert_in_range 0..2, r.ttl("foo")
+    end
+
+    def test_expireat
+      r.set("foo", "s1")
+      assert r.expireat("foo", (Time.now + 2).to_i)
+      assert_in_range 0..2, r.ttl("foo")
+    end
+
+    def test_pexpireat
+      return if version < "2.5.4"
+
+      r.set("foo", "s1")
+      assert r.pexpireat("foo", (Time.now + 2).to_i * 1_000)
+      assert_in_range 0..2, r.ttl("foo")
+    end
+
+    def test_persist
+      r.set("foo", "s1")
+      r.expire("foo", 1)
+      r.persist("foo")
+
+      assert(-1 == r.ttl("foo"))
+    end
+
+    def test_ttl
+      r.set("foo", "s1")
+      r.expire("foo", 2)
+      assert_in_range 0..2, r.ttl("foo")
+    end
+
+    def test_pttl
+      return if version < "2.5.4"
+
+      r.set("foo", "s1")
+      r.expire("foo", 2)
+      assert_in_range 1..2000, r.pttl("foo")
+    end
+
+    def test_move
+      r.select 14
+      r.flushdb
+
+      r.set "bar", "s3"
+
+      r.select 15
+
+      r.set "foo", "s1"
+      r.set "bar", "s2"
+
+      assert r.move("foo", 14)
+      assert_equal nil, r.get("foo")
+
+      assert !r.move("bar", 14)
+      assert_equal "s2", r.get("bar")
+
+      r.select 14
+
+      assert_equal "s1", r.get("foo")
+      assert_equal "s3", r.get("bar")
+    end
+  end
+end

data/vendor/bundle/gems/redis-3.0.2/test/persistence_control_commands_test.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+require "helper"
+
+class TestPersistenceControlCommands < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_save
+    redis_mock(:save => lambda { "+SAVE" }) do |redis|
+      assert_equal "SAVE", redis.save
+    end
+  end
+
+  def test_bgsave
+    redis_mock(:bgsave => lambda { "+BGSAVE" }) do |redis|
+      assert_equal "BGSAVE", redis.bgsave
+    end
+  end
+
+  def test_lastsave
+    redis_mock(:lastsave => lambda { "+LASTSAVE" }) do |redis|
+      assert_equal "LASTSAVE", redis.lastsave
+    end
+  end
+end

data/vendor/bundle/gems/redis-3.0.2/test/pipelining_commands_test.rb

@@ -0,0 +1,195 @@
+# encoding: UTF-8
+
+require "helper"
+
+class TestPipeliningCommands < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_bulk_commands
+    r.pipelined do
+      r.lpush "foo", "s1"
+      r.lpush "foo", "s2"
+    end
+
+    assert_equal 2, r.llen("foo")
+    assert_equal "s2", r.lpop("foo")
+    assert_equal "s1", r.lpop("foo")
+  end
+
+  def test_multi_bulk_commands
+    r.pipelined do
+      r.mset("foo", "s1", "bar", "s2")
+      r.mset("baz", "s3", "qux", "s4")
+    end
+
+    assert_equal "s1", r.get("foo")
+    assert_equal "s2", r.get("bar")
+    assert_equal "s3", r.get("baz")
+    assert_equal "s4", r.get("qux")
+  end
+
+  def test_bulk_and_multi_bulk_commands_mixed
+    r.pipelined do
+      r.lpush "foo", "s1"
+      r.lpush "foo", "s2"
+      r.mset("baz", "s3", "qux", "s4")
+    end
+
+    assert_equal 2, r.llen("foo")
+    assert_equal "s2", r.lpop("foo")
+    assert_equal "s1", r.lpop("foo")
+    assert_equal "s3", r.get("baz")
+    assert_equal "s4", r.get("qux")
+  end
+
+  def test_multi_bulk_and_bulk_commands_mixed
+    r.pipelined do
+      r.mset("baz", "s3", "qux", "s4")
+      r.lpush "foo", "s1"
+      r.lpush "foo", "s2"
+    end
+
+    assert_equal 2, r.llen("foo")
+    assert_equal "s2", r.lpop("foo")
+    assert_equal "s1", r.lpop("foo")
+    assert_equal "s3", r.get("baz")
+    assert_equal "s4", r.get("qux")
+  end
+
+  def test_pipelined_with_an_empty_block
+    assert_nothing_raised do
+      r.pipelined do
+      end
+    end
+
+    assert_equal 0, r.dbsize
+  end
+
+  def test_returning_the_result_of_a_pipeline
+    result = r.pipelined do
+      r.set "foo", "bar"
+      r.get "foo"
+      r.get "bar"
+    end
+
+    assert_equal ["OK", "bar", nil], result
+  end
+
+  def test_assignment_of_results_inside_the_block
+    r.pipelined do
+      @first = r.sadd("foo", 1)
+      @second = r.sadd("foo", 1)
+    end
+
+    assert_equal true, @first.value
+    assert_equal false, @second.value
+  end
+
+  # Although we could support accessing the values in these futures,
+  # it doesn't make a lot of sense.
+  def test_assignment_of_results_inside_the_block_with_errors
+    assert_raise(Redis::CommandError) do
+      r.pipelined do
+        r.doesnt_exist
+        @first = r.sadd("foo", 1)
+        r.doesnt_exist
+        @second = r.sadd("foo", 1)
+        r.doesnt_exist
+      end
+    end
+
+    assert_raise(Redis::FutureNotReady) { @first.value }
+    assert_raise(Redis::FutureNotReady) { @second.value }
+  end
+
+  def test_assignment_of_results_inside_a_nested_block
+    r.pipelined do
+      @first = r.sadd("foo", 1)
+
+      r.pipelined do
+        @second = r.sadd("foo", 1)
+      end
+    end
+
+    assert_equal true, @first.value
+    assert_equal false, @second.value
+  end
+
+  def test_futures_raise_when_confused_with_something_else
+    r.pipelined do
+      @result = r.sadd("foo", 1)
+    end
+
+    assert_raise(NoMethodError) { @result.to_s }
+  end
+
+  def test_futures_raise_when_trying_to_access_their_values_too_early
+    r.pipelined do
+      assert_raise(Redis::FutureNotReady) do
+        r.sadd("foo", 1).value
+      end
+    end
+  end
+
+  def test_returning_the_result_of_an_empty_pipeline
+    result = r.pipelined do
+    end
+
+    assert_equal [], result
+  end
+
+  def test_nesting_pipeline_blocks
+    r.pipelined do
+      r.set("foo", "s1")
+      r.pipelined do
+        r.set("bar", "s2")
+      end
+    end
+
+    assert_equal "s1", r.get("foo")
+    assert_equal "s2", r.get("bar")
+  end
+
+  def test_info_in_a_pipeline_returns_hash
+    result = r.pipelined do
+      r.info
+    end
+
+    assert result.first.kind_of?(Hash)
+  end
+
+  def test_config_get_in_a_pipeline_returns_hash
+    result = r.pipelined do
+      r.config(:get, "*")
+    end
+
+    assert result.first.kind_of?(Hash)
+  end
+
+  def test_hgetall_in_a_pipeline_returns_hash
+    r.hmset("hash", "field", "value")
+    result = r.pipelined do
+      r.hgetall("hash")
+    end
+
+    assert_equal result.first, { "field" => "value" }
+  end
+
+  def test_keys_in_a_pipeline
+    r.set("key", "value")
+    result = r.pipelined do
+      r.keys("*")
+    end
+
+    assert_equal ["key"], result.first
+  end
+
+  def test_pipeline_yields_a_connection
+    r.pipelined do |p|
+      p.set("foo", "bar")
+    end
+
+    assert_equal "bar", r.get("foo")
+  end
+end

data/vendor/bundle/gems/redis-3.0.2/test/publish_subscribe_test.rb

@@ -0,0 +1,153 @@
+# encoding: UTF-8
+
+require "helper"
+
+class TestPublishSubscribe < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_subscribe_and_unsubscribe
+    @subscribed = false
+    @unsubscribed = 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
+      end
+    end
+
+    # Wait until the subscription is active before publishing
+    Wire.pass while !@subscribed
+
+    Redis.new(OPTIONS).publish("foo", "s1")
+
+    wire.join
+
+    assert @subscribed
+    assert_equal 1, @t1
+    assert @unsubscribed
+    assert_equal 0, @t2
+    assert_equal "s1", @message
+  end
+
+  def test_psubscribe_and_punsubscribe
+    @subscribed = false
+    @unsubscribed = false
+
+    wire = Wire.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
+
+    # Wait until the subscription is active before publishing
+    Wire.pass while !@subscribed
+
+    Redis.new(OPTIONS).publish("foo", "s1")
+
+    wire.join
+
+    assert @subscribed
+    assert_equal 1, @t1
+    assert @unsubscribed
+    assert_equal 0, @t2
+    assert_equal "s1", @message
+  end
+
+  def test_subscribe_within_subscribe
+    @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
+      end
+    end
+
+    wire.join
+
+    assert_equal ["foo", "bar"], @channels
+  end
+
+  def test_other_commands_within_a_subscribe
+    assert_raise Redis::CommandError do
+      r.subscribe("foo") do |on|
+        on.subscribe do |channel, total|
+          r.set("bar", "s2")
+        end
+      end
+    end
+  end
+
+  def test_subscribe_without_a_block
+    assert_raise LocalJumpError do
+      r.subscribe("foo")
+    end
+  end
+
+  def test_unsubscribe_without_a_subscribe
+    assert_raise RuntimeError do
+      r.unsubscribe
+    end
+
+    assert_raise RuntimeError do
+      r.punsubscribe
+    end
+  end
+
+  def test_subscribe_past_a_timeout
+    # For some reason, a thread here doesn't reproduce the issue.
+    sleep = %{sleep #{OPTIONS[:timeout] * 2}}
+    publish = %{echo "publish foo bar\r\n" | nc localhost #{OPTIONS[:port]}}
+    cmd = [sleep, publish].join("; ")
+
+    IO.popen(cmd, "r+") do |pipe|
+      received = false
+
+      r.subscribe "foo" do |on|
+        on.message do |channel, message|
+          received = true
+          r.unsubscribe
+        end
+      end
+
+      assert received
+    end
+  end
+end