Don't rely on TestCase#skip since it's not available on 1.8.7.

Author: djanowski

test/commands_on_strings_test.rb

@@ -82,18 +82,18 @@ def test_msetnx_mapped
   end
 
   def test_bitop
-    target_version "2.5.10"
-
-    r.set("foo", "a")
-    r.set("bar", "b")
-
-    r.bitop(:and, "foo&bar", "foo", "bar")
-    assert_equal "\x60", r.get("foo&bar")
-    r.bitop(:or, "foo|bar", "foo", "bar")
-    assert_equal "\x63", r.get("foo|bar")
-    r.bitop(:xor, "foo^bar", "foo", "bar")
-    assert_equal "\x03", r.get("foo^bar")
-    r.bitop(:not, "~foo", "foo")
-    assert_equal "\x9E", r.get("~foo")
+    target_version "2.5.10" do
+      r.set("foo", "a")
+      r.set("bar", "b")
+
+      r.bitop(:and, "foo&bar", "foo", "bar")
+      assert_equal "\x60", r.get("foo&bar")
+      r.bitop(:or, "foo|bar", "foo", "bar")
+      assert_equal "\x63", r.get("foo|bar")
+      r.bitop(:xor, "foo^bar", "foo", "bar")
+      assert_equal "\x03", r.get("foo^bar")
+      r.bitop(:not, "~foo", "foo")
+      assert_equal "\x9E", r.get("~foo")
+    end
   end
 end

test/distributed_commands_on_strings_test.rb

@@ -47,13 +47,13 @@ def test_msetnx_mapped
   end
 
   def test_bitop
-    target_version "2.5.10"
+    target_version "2.5.10" do
+      assert_raise Redis::Distributed::CannotDistribute do
+        r.set("foo", "a")
+        r.set("bar", "b")
 
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.set("foo", "a")
-      r.set("bar", "b")
-
-      r.bitop(:and, "foo&bar", "foo", "bar")
+        r.bitop(:and, "foo&bar", "foo", "bar")
+      end
     end
   end
 end

test/distributed_commands_requiring_clustering_test.rb

@@ -147,18 +147,18 @@ def test_sort_with_store
   end
 
   def test_bitop
-    target_version "2.5.10"
-
-    r.set("{qux}foo", "a")
-    r.set("{qux}bar", "b")
-
-    r.bitop(:and, "{qux}foo&bar", "{qux}foo", "{qux}bar")
-    assert_equal "\x60", r.get("{qux}foo&bar")
-    r.bitop(:or, "{qux}foo|bar", "{qux}foo", "{qux}bar")
-    assert_equal "\x63", r.get("{qux}foo|bar")
-    r.bitop(:xor, "{qux}foo^bar", "{qux}foo", "{qux}bar")
-    assert_equal "\x03", r.get("{qux}foo^bar")
-    r.bitop(:not, "{qux}~foo", "{qux}foo")
-    assert_equal "\x9E", r.get("{qux}~foo")
+    target_version "2.5.10" do
+      r.set("{qux}foo", "a")
+      r.set("{qux}bar", "b")
+
+      r.bitop(:and, "{qux}foo&bar", "{qux}foo", "{qux}bar")
+      assert_equal "\x60", r.get("{qux}foo&bar")
+      r.bitop(:or, "{qux}foo|bar", "{qux}foo", "{qux}bar")
+      assert_equal "\x63", r.get("{qux}foo|bar")
+      r.bitop(:xor, "{qux}foo^bar", "{qux}foo", "{qux}bar")
+      assert_equal "\x03", r.get("{qux}foo^bar")
+      r.bitop(:not, "{qux}~foo", "{qux}foo")
+      assert_equal "\x9E", r.get("{qux}~foo")
+    end
   end
 end

test/distributed_remote_server_control_commands_test.rb

@@ -28,13 +28,13 @@ def test_info
   end
 
   def test_info_commandstats
-    target_version "2.5.7"
+    target_version "2.5.7" do
+      r.nodes.each { |n| n.config(:resetstat) }
+      r.ping # Executed on every node
 
-    r.nodes.each { |n| n.config(:resetstat) }
-    r.ping # Executed on every node
-
-    r.info(:commandstats).each do |info|
-      assert_equal "1", info["ping"]["calls"]
+      r.info(:commandstats).each do |info|
+        assert_equal "1", info["ping"]["calls"]
+      end
     end
   end
 
@@ -52,15 +52,15 @@ def test_echo
   end
 
   def test_time
-    target_version "2.5.4"
+    target_version "2.5.4" do
+      # Test that the difference between the time that Ruby reports and the time
+      # that Redis reports is minimal (prevents the test from being racy).
+      r.time.each do |rv|
+        redis_usec = rv[0] * 1_000_000 + rv[1]
+        ruby_usec = Integer(Time.now.to_f * 1_000_000)
 
-    # Test that the difference between the time that Ruby reports and the time
-    # that Redis reports is minimal (prevents the test from being racy).
-    r.time.each do |rv|
-      redis_usec = rv[0] * 1_000_000 + rv[1]
-      ruby_usec = Integer(Time.now.to_f * 1_000_000)
-
-      assert 500_000 > (ruby_usec - redis_usec).abs
+        assert 500_000 > (ruby_usec - redis_usec).abs
+      end
     end
   end
 end

test/distributed_scripting_test.rb

@@ -11,92 +11,92 @@ def to_sha(script)
   end
 
   def test_script_exists
-    target_version "2.5.9" # 2.6-rc1
-
-    a = to_sha("return 1")
-    b = a.succ
-
-    assert_equal [true], r.script(:exists, a)
-    assert_equal [false], r.script(:exists, b)
-    assert_equal [[true]], r.script(:exists, [a])
-    assert_equal [[false]], r.script(:exists, [b])
-    assert_equal [[true, false]], r.script(:exists, [a, b])
+    target_version "2.5.9" do # 2.6-rc1
+      a = to_sha("return 1")
+      b = a.succ
+
+      assert_equal [true], r.script(:exists, a)
+      assert_equal [false], r.script(:exists, b)
+      assert_equal [[true]], r.script(:exists, [a])
+      assert_equal [[false]], r.script(:exists, [b])
+      assert_equal [[true, false]], r.script(:exists, [a, b])
+    end
   end
 
   def test_script_flush
-    target_version "2.5.9" # 2.6-rc1
-
-    sha = to_sha("return 1")
-    assert r.script(:exists, sha).first
-    assert_equal ["OK"], r.script(:flush)
-    assert !r.script(:exists, sha).first
+    target_version "2.5.9" do # 2.6-rc1
+      sha = to_sha("return 1")
+      assert r.script(:exists, sha).first
+      assert_equal ["OK"], r.script(:flush)
+      assert !r.script(:exists, sha).first
+    end
   end
 
   def test_script_kill
-    target_version "2.5.9" # 2.6-rc1
-
-    redis_mock(:script => lambda { |arg| "+#{arg.upcase}" }) do |redis|
-      assert_equal ["KILL"], redis.script(:kill)
+    target_version "2.5.9" do # 2.6-rc1
+      redis_mock(:script => lambda { |arg| "+#{arg.upcase}" }) do |redis|
+        assert_equal ["KILL"], redis.script(:kill)
+      end
     end
   end
 
   def test_eval
-    target_version "2.5.9" # 2.6-rc1
+    target_version "2.5.9" do # 2.6-rc1
+      assert_raises(Redis::Distributed::CannotDistribute) do
+        r.eval("return #KEYS")
+      end
 
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.eval("return #KEYS")
-    end
+      assert_raises(Redis::Distributed::CannotDistribute) do
+        r.eval("return KEYS", ["k1", "k2"])
+      end
 
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.eval("return KEYS", ["k1", "k2"])
+      assert_equal ["k1"], r.eval("return KEYS", ["k1"])
+      assert_equal ["a1", "a2"], r.eval("return ARGV", ["k1"], ["a1", "a2"])
     end
-
-    assert_equal ["k1"], r.eval("return KEYS", ["k1"])
-    assert_equal ["a1", "a2"], r.eval("return ARGV", ["k1"], ["a1", "a2"])
   end
 
   def test_eval_with_options_hash
-    target_version "2.5.9" # 2.6-rc1
+    target_version "2.5.9" do # 2.6-rc1
+      assert_raises(Redis::Distributed::CannotDistribute) do
+        r.eval("return #KEYS", {})
+      end
 
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.eval("return #KEYS", {})
-    end
+      assert_raises(Redis::Distributed::CannotDistribute) do
+        r.eval("return KEYS", { :keys => ["k1", "k2"] })
+      end
 
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.eval("return KEYS", { :keys => ["k1", "k2"] })
+      assert_equal ["k1"], r.eval("return KEYS", { :keys => ["k1"] })
+      assert_equal ["a1", "a2"], r.eval("return ARGV", { :keys => ["k1"], :argv => ["a1", "a2"] })
     end
-
-    assert_equal ["k1"], r.eval("return KEYS", { :keys => ["k1"] })
-    assert_equal ["a1", "a2"], r.eval("return ARGV", { :keys => ["k1"], :argv => ["a1", "a2"] })
   end
 
   def test_evalsha
-    target_version "2.5.9" # 2.6-rc1
+    target_version "2.5.9" do # 2.6-rc1
+      assert_raises(Redis::Distributed::CannotDistribute) do
+        r.evalsha(to_sha("return #KEYS"))
+      end
 
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.evalsha(to_sha("return #KEYS"))
-    end
+      assert_raises(Redis::Distributed::CannotDistribute) do
+        r.evalsha(to_sha("return KEYS"), ["k1", "k2"])
+      end
 
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.evalsha(to_sha("return KEYS"), ["k1", "k2"])
+      assert_equal ["k1"], r.evalsha(to_sha("return KEYS"), ["k1"])
+      assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), ["k1"], ["a1", "a2"])
     end
-
-    assert_equal ["k1"], r.evalsha(to_sha("return KEYS"), ["k1"])
-    assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), ["k1"], ["a1", "a2"])
   end
 
   def test_evalsha_with_options_hash
-    target_version "2.5.9" # 2.6-rc1
+    target_version "2.5.9" do # 2.6-rc1
+      assert_raises(Redis::Distributed::CannotDistribute) do
+        r.evalsha(to_sha("return #KEYS"), {})
+      end
 
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.evalsha(to_sha("return #KEYS"), {})
-    end
+      assert_raises(Redis::Distributed::CannotDistribute) do
+        r.evalsha(to_sha("return KEYS"), { :keys => ["k1", "k2"] })
+      end
 
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.evalsha(to_sha("return KEYS"), { :keys => ["k1", "k2"] })
+      assert_equal ["k1"], r.evalsha(to_sha("return KEYS"), { :keys => ["k1"] })
+      assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), { :keys => ["k1"], :argv => ["a1", "a2"] })
     end
-
-    assert_equal ["k1"], r.evalsha(to_sha("return KEYS"), { :keys => ["k1"] })
-    assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), { :keys => ["k1"], :argv => ["a1", "a2"] })
   end
 end

test/helper.rb

@@ -156,7 +156,11 @@ def assert_in_range(range, value)
     end
 
     def target_version(target)
-      skip("Requires Redis > #{target}") if version < target
+      if version < target
+        skip("Requires Redis > #{target}") if respond_to?(:skip)
+      else
+        yield
+      end
     end
   end
 

test/internals_test.rb

@@ -128,16 +128,16 @@ def test_tcp_keepalive
   end
 
   def test_time
-    target_version "2.5.4"
+    target_version "2.5.4" do
+      # Test that the difference between the time that Ruby reports and the time
+      # that Redis reports is minimal (prevents the test from being racy).
+      rv = r.time
 
-    # Test that the difference between the time that Ruby reports and the time
-    # that Redis reports is minimal (prevents the test from being racy).
-    rv = r.time
+      redis_usec = rv[0] * 1_000_000 + rv[1]
+      ruby_usec = Integer(Time.now.to_f * 1_000_000)
 
-    redis_usec = rv[0] * 1_000_000 + rv[1]
-    ruby_usec = Integer(Time.now.to_f * 1_000_000)
-
-    assert 500_000 > (ruby_usec - redis_usec).abs
+      assert 500_000 > (ruby_usec - redis_usec).abs
+    end
   end
 
   def test_connection_timeout

test/lint/hashes.rb

@@ -31,18 +31,18 @@ def test_hdel
     end
 
     def test_variadic_hdel
-      target_version "2.3.9"
+      target_version "2.3.9" do
+        r.hset("foo", "f1", "s1")
+        r.hset("foo", "f2", "s2")
 
-      r.hset("foo", "f1", "s1")
-      r.hset("foo", "f2", "s2")
-
-      assert_equal "s1", r.hget("foo", "f1")
-      assert_equal "s2", r.hget("foo", "f2")
+        assert_equal "s1", r.hget("foo", "f1")
+        assert_equal "s2", r.hget("foo", "f2")
 
-      assert_equal 2, r.hdel("foo", ["f1", "f2"])
+        assert_equal 2, r.hdel("foo", ["f1", "f2"])
 
-      assert_equal nil, r.hget("foo", "f1")
-      assert_equal nil, r.hget("foo", "f2")
+        assert_equal nil, r.hget("foo", "f1")
+        assert_equal nil, r.hget("foo", "f2")
+      end
     end
 
     def test_hexists
@@ -144,19 +144,19 @@ def test_hincrby
     end
 
     def test_hincrbyfloat
-      target_version "2.5.4"
+      target_version "2.5.4" do
+        r.hincrbyfloat("foo", "f1", 1.23)
 
-      r.hincrbyfloat("foo", "f1", 1.23)
+        assert_equal "1.23", r.hget("foo", "f1")
 
-      assert_equal "1.23", r.hget("foo", "f1")
+        r.hincrbyfloat("foo", "f1", 0.77)
 
-      r.hincrbyfloat("foo", "f1", 0.77)
+        assert_equal "2", r.hget("foo", "f1")
 
-      assert_equal "2", r.hget("foo", "f1")
+        r.hincrbyfloat("foo", "f1", -0.1)
 
-      r.hincrbyfloat("foo", "f1", -0.1)
-
-      assert_equal "1.9", r.hget("foo", "f1")
+        assert_equal "1.9", r.hget("foo", "f1")
+      end
     end
   end
 end