remq 0.0.1a → 0.0.3

data/vendor/bundle/gems/redis-3.0.2/redis.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+$:.unshift File.expand_path("../lib", __FILE__)
+
+require "redis/version"
+
+Gem::Specification.new do |s|
+  s.name = "redis"
+
+  s.version = Redis::VERSION
+
+  s.homepage = "https://github.com/redis/redis-rb"
+
+  s.summary = "A Ruby client library 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.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")
+end

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

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+require "helper"
+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/vendor/bundle/gems/redis-3.0.2/test/command_map_test.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+require "helper"
+
+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/vendor/bundle/gems/redis-3.0.2/test/commands_on_hashes_test.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+
+require "helper"
+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/vendor/bundle/gems/redis-3.0.2/test/commands_on_lists_test.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+require "helper"
+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/vendor/bundle/gems/redis-3.0.2/test/commands_on_sets_test.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+require "helper"
+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/vendor/bundle/gems/redis-3.0.2/test/commands_on_sorted_sets_test.rb

@@ -0,0 +1,109 @@
+# encoding: UTF-8
+
+require "helper"
+require "lint/sorted_sets"
+
+class TestCommandsOnSortedSets < Test::Unit::TestCase
+
+  include Helper::Client
+  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
+
+  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/vendor/bundle/gems/redis-3.0.2/test/commands_on_strings_test.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+
+require "helper"
+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
+end

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

@@ -0,0 +1,99 @@
+# encoding: UTF-8
+
+require "helper"
+require "lint/value_types"
+
+class TestCommandsOnValueTypes < Test::Unit::TestCase
+
+  include Helper::Client
+  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 r.randomkey.to_s.empty?
+
+    r.set("foo", "s1")
+
+    assert_equal "foo", r.randomkey
+
+    r.set("bar", "s2")
+
+    4.times do
+      assert ["foo", "bar"].include?(r.randomkey)
+    end
+  end
+
+  def test_rename
+    r.set("foo", "s1")
+    r.rename "foo", "bar"
+
+    assert_equal "s1", r.get("bar")
+    assert_equal nil, r.get("foo")
+  end
+
+  def test_renamenx
+    r.set("foo", "s1")
+    r.set("bar", "s2")
+
+    assert_equal false, r.renamenx("foo", "bar")
+
+    assert_equal "s1", r.get("foo")
+    assert_equal "s2", 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_flushall
+    redis_mock(:flushall => lambda { "+FLUSHALL" }) do |redis|
+      assert_equal "FLUSHALL", redis.flushall
+    end
+  end
+end