redis 4.0.1 → 4.8.1

data/test/lint/strings.rb

@@ -1,246 +0,0 @@
-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_newline_characters
-      r.set("foo", "1\n")
-
-      assert_equal "1\n", r.get("foo")
-    end
-
-    def test_set_and_get_with_non_string_value
-      value = ["a", "b"]
-
-      r.set("foo", value)
-
-      assert_equal value.to_s, r.get("foo")
-    end
-
-    def test_set_and_get_with_ascii_characters
-      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
-
-    def test_set_with_ex
-      target_version "2.6.12" do
-        r.set("foo", "bar", :ex => 2)
-        assert_in_range 0..2, r.ttl("foo")
-      end
-    end
-
-    def test_set_with_px
-      target_version "2.6.12" do
-        r.set("foo", "bar", :px => 2000)
-        assert_in_range 0..2, r.ttl("foo")
-      end
-    end
-
-    def test_set_with_nx
-      target_version "2.6.12" do
-        r.set("foo", "qux", :nx => true)
-        assert !r.set("foo", "bar", :nx => true)
-        assert_equal "qux", r.get("foo")
-
-        r.del("foo")
-        assert r.set("foo", "bar", :nx => true)
-        assert_equal "bar", r.get("foo")
-      end
-    end
-
-    def test_set_with_xx
-      target_version "2.6.12" do
-        r.set("foo", "qux")
-        assert r.set("foo", "bar", :xx => true)
-        assert_equal "bar", r.get("foo")
-
-        r.del("foo")
-        assert !r.set("foo", "bar", :xx => true)
-      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_setex_with_non_string_value
-      value = ["b", "a", "r"]
-
-      assert r.setex("foo", 1, value)
-      assert_equal value.to_s, r.get("foo")
-      assert [0, 1].include? r.ttl("foo")
-    end
-
-    def test_psetex
-      target_version "2.5.4" do
-        assert r.psetex("foo", 1000, "bar")
-        assert_equal "bar", r.get("foo")
-        assert [0, 1].include? r.ttl("foo")
-      end
-    end
-
-    def test_psetex_with_non_string_value
-      target_version "2.5.4" do
-        value = ["b", "a", "r"]
-
-        assert r.psetex("foo", 1000, value)
-        assert_equal value.to_s, r.get("foo")
-        assert [0, 1].include? r.ttl("foo")
-      end
-    end
-
-    def test_getset
-      r.set("foo", "bar")
-
-      assert_equal "bar", r.getset("foo", "baz")
-      assert_equal "baz", r.get("foo")
-    end
-
-    def test_getset_with_non_string_value
-      r.set("foo", "zap")
-
-      value = ["b", "a", "r"]
-
-      assert_equal "zap", r.getset("foo", value)
-      assert_equal value.to_s, r.get("foo")
-    end
-
-    def test_setnx
-      r.set("foo", "qux")
-      assert !r.setnx("foo", "bar")
-      assert_equal "qux", r.get("foo")
-
-      r.del("foo")
-      assert r.setnx("foo", "bar")
-      assert_equal "bar", r.get("foo")
-    end
-
-    def test_setnx_with_non_string_value
-      value = ["b", "a", "r"]
-
-      r.set("foo", "qux")
-      assert !r.setnx("foo", value)
-      assert_equal "qux", r.get("foo")
-
-      r.del("foo")
-      assert r.setnx("foo", value)
-      assert_equal value.to_s, 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
-      target_version "2.5.4" do
-        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
-    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_bitcount
-      target_version "2.5.10" do
-        r.set("foo", "abcde")
-
-        assert_equal 10, r.bitcount("foo", 1, 3)
-        assert_equal 17, r.bitcount("foo", 0, -1)
-      end
-    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_setrange_with_non_string_value
-      r.set("foo", "abcde")
-
-      value = ["b", "a", "r"]
-
-      r.setrange("foo", 2, value)
-
-      assert_equal "ab#{value.to_s}", r.get("foo")
-    end
-
-    def test_strlen
-      r.set "foo", "lorem"
-
-      assert_equal 5, r.strlen("foo")
-    end
-  end
-end

data/test/lint/value_types.rb

@@ -1,130 +0,0 @@
-module Lint
-
-  module ValueTypes
-
-    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
-      target_version "2.5.4" do
-        r.set("foo", "s1")
-        assert r.pexpire("foo", 2000)
-        assert_in_range 0..2, r.ttl("foo")
-      end
-    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
-      target_version "2.5.4" do
-        r.set("foo", "s1")
-        assert r.pexpireat("foo", (Time.now + 2).to_i * 1_000)
-        assert_in_range 0..2, r.ttl("foo")
-      end
-    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
-      target_version "2.5.4" do
-        r.set("foo", "s1")
-        r.expire("foo", 2)
-        assert_in_range 1..2000, r.pttl("foo")
-      end
-    end
-
-    def test_dump_and_restore
-      target_version "2.5.7" do
-        r.set("foo", "a")
-        v = r.dump("foo")
-        r.del("foo")
-
-        assert r.restore("foo", 1000, v)
-        assert_equal "a", r.get("foo")
-        assert [0, 1].include? r.ttl("foo")
-
-        r.rpush("bar", ["b", "c", "d"])
-        w = r.dump("bar")
-        r.del("bar")
-
-        assert r.restore("bar", 1000, w)
-        assert_equal ["b", "c", "d"], r.lrange("bar", 0, -1)
-        assert [0, 1].include? r.ttl("bar")
-
-        r.set("bar", "somethingelse")
-        assert_raises(Redis::CommandError) { r.restore("bar", 1000, w) } # ensure by default replace is false
-        assert_raises(Redis::CommandError) { r.restore("bar", 1000, w, :replace => false) }
-        assert_equal "somethingelse", r.get("bar")
-        assert r.restore("bar", 1000, w, :replace => true)
-        assert_equal ["b", "c", "d"], r.lrange("bar", 0, -1)
-        assert [0, 1].include? r.ttl("bar")
-      end
-    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/test/persistence_control_commands_test.rb

@@ -1,24 +0,0 @@
-require_relative "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/test/pipelining_commands_test.rb

@@ -1,238 +0,0 @@
-require_relative "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)
-        @second = r.sadd("foo", 1)
-      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_futures_can_be_identified
-    r.pipelined do
-      @result = r.sadd("foo", 1)
-    end
-
-    assert_equal true, @result.is_a?(Redis::Future)
-    assert_equal true, @result.is_a?(::BasicObject)
-    assert_equal Redis::Future, @result.class
-  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
-
-  def test_pipeline_select
-    r.select 1
-    r.set("db", "1")
-
-    r.pipelined do |p|
-      p.select 2
-      p.set("db", "2")
-    end
-
-    r.select 1
-    assert_equal "1", r.get("db")
-
-    r.select 2
-    assert_equal "2", r.get("db")
-  end
-
-  def test_pipeline_select_client_db
-    r.select 1
-    r.pipelined do |p2|
-      p2.select 2
-    end
-
-    assert_equal 2, r._client.db
-  end
-
-  def test_nested_pipeline_select_client_db
-    r.select 1
-    r.pipelined do |p2|
-      p2.select 2
-      p2.pipelined do |p3|
-        p3.select 3
-      end
-    end
-
-    assert_equal 3, r._client.db
-  end
-end