ohm 0.0.34 → 0.0.35

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 34
-  version: 0.0.34
+  - 35
+  version: 0.0.35
 platform: ruby
 authors: 
 - Michel Martens
@@ -15,10 +15,36 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-03 00:00:00 -03:00
+date: 2010-04-09 00:00:00 -03:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 4
+        version: 1.0.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: contest
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        version: "0.1"
+  type: :development
+  version_requirements: *id002
 description: Ohm is a library that allows to store an object in Redis, a persistent key-value database. It includes an extensible list of validations and has very good performance.
 email: 
 - michel@soveran.com
@@ -33,13 +59,11 @@ files:
 - lib/ohm/collection.rb
 - lib/ohm/compat-1.8.6.rb
 - lib/ohm/key.rb
-- lib/ohm/redis.rb
 - lib/ohm/validations.rb
 - lib/ohm.rb
 - README.markdown
 - LICENSE
 - Rakefile
-- Thorfile
 - test/1.8.6_test.rb
 - test/all_tests.rb
 - test/benchmarks.rb
@@ -48,7 +72,6 @@ files:
 - test/indices_test.rb
 - test/model_test.rb
 - test/mutex_test.rb
-- test/redis_test.rb
 - test/test_helper.rb
 - test/validations_test.rb
 - test/test.conf

data/Thorfile

@@ -1,20 +0,0 @@
-# encoding: UTF-8
-
-class Ohm < Thor
-  desc "doc", "Generate YARD documentation"
-  method_options :open => false
-  def doc
-    require "yard"
-
-    opts = ["--protected", "--title", "Ohm – Object-hash mapping library for Redis"]
-
-    YARD::CLI::Yardoc.run(*opts)
-
-    system "open doc/index.html" if options[:open]
-  end
-
-  desc "deploy", "Deploy documentation"
-  def deploy
-    system "rsync -az doc/* ohm.keyvalue.org:deploys/ohm.keyvalue.org/"
-  end
-end

data/lib/ohm/redis.rb

@@ -1,305 +0,0 @@
-# encoding: UTF-8
-
-# Redis client based on RubyRedis, original work of Salvatore Sanfilippo
-# http://github.com/antirez/redis/blob/4a327b4af9885d89b5860548f44569d1d2bde5ab/client-libraries/ruby_2/rubyredis.rb
-#
-# Some improvements where inspired by the Redis-rb library, including the testing suite.
-# http://github.com/ezmobius/redis-rb/
-require 'socket'
-
-module Ohm
-  begin
-    if (RUBY_VERSION >= '1.9')
-      require 'timeout'
-      RedisTimer = Timeout
-    else
-      require 'system_timer'
-      RedisTimer = SystemTimer
-    end
-  rescue LoadError
-    RedisTimer = nil
-  end
-
-  class Redis
-    class ProtocolError < RuntimeError
-      def initialize(reply_type)
-        super("Protocol error, got '#{reply_type}' as initial reply byte")
-      end
-    end
-
-    BULK_COMMANDS = {
-      :echo => true,
-      :getset => true,
-      :lpush => true,
-      :lrem => true,
-      :lset => true,
-      :rpush => true,
-      :sadd => true,
-      :set => true,
-      :setnx => true,
-      :sismember => true,
-      :smove => true,
-      :srem => true,
-      :zadd => true,
-      :zincrby => true,
-      :zrem => true,
-      :zscore => true
-    }
-
-    MULTI_BULK_COMMANDS = {
-      :mset => true,
-      :msetnx => true
-    }
-
-    PROCESSOR_IDENTITY = lambda { |reply| reply }
-    PROCESSOR_CONVERT_TO_BOOL = lambda { |reply| reply == 0 ? false : reply }
-    PROCESSOR_SPLIT_KEYS = lambda { |reply| reply.respond_to?(:split) ? reply.split(" ") : reply }
-    PROCESSOR_INFO = lambda { |reply| Hash[*(reply.lines.map { |l| l.chomp.split(":", 2) }.flatten)] }
-
-    REPLY_PROCESSOR = {
-      :exists => PROCESSOR_CONVERT_TO_BOOL,
-      :sismember=> PROCESSOR_CONVERT_TO_BOOL,
-      :sadd=> PROCESSOR_CONVERT_TO_BOOL,
-      :srem=> PROCESSOR_CONVERT_TO_BOOL,
-      :smove=> PROCESSOR_CONVERT_TO_BOOL,
-      :zadd => PROCESSOR_CONVERT_TO_BOOL,
-      :zrem => PROCESSOR_CONVERT_TO_BOOL,
-      :move=> PROCESSOR_CONVERT_TO_BOOL,
-      :setnx=> PROCESSOR_CONVERT_TO_BOOL,
-      :del=> PROCESSOR_CONVERT_TO_BOOL,
-      :renamenx=> PROCESSOR_CONVERT_TO_BOOL,
-      :expire=> PROCESSOR_CONVERT_TO_BOOL,
-      :keys => PROCESSOR_SPLIT_KEYS,
-      :info => PROCESSOR_INFO
-    }
-
-    REPLY_PROCESSOR.send(:initialize) do |hash, key|
-      hash[key] = PROCESSOR_IDENTITY
-    end
-
-    def initialize(options = {})
-      @host = options[:host] || '127.0.0.1'
-      @port = options[:port] || 6379
-      @db = options[:db] || 0
-      @timeout = options[:timeout] || 0
-      @password = options[:password]
-      connect
-    end
-
-    def version
-      @version ||= info["redis_version"]
-    end
-
-    def support_mset?
-      @support_mset.nil? ?
-        @support_mset = version >= "1.05" :
-        @support_mset
-    end
-
-    def to_s
-      "Redis Client connected to #{@host}:#{@port} against DB #{@db}"
-    end
-
-    # Shorthand for getting all the elements in a list.
-    def list(key)
-      call_command([:lrange, key, 0, -1])
-    end
-
-    # We need to define type because otherwise it will escape method_missing.
-    def type(key)
-      call_command([:type, key])
-    end
-
-    def sort(key, opts = {})
-      cmd = []
-      cmd << "SORT #{key}"
-      cmd << "BY #{opts[:by]}" if opts[:by]
-      cmd << "GET #{[opts[:get]].flatten * ' GET '}" if opts[:get]
-      cmd << "#{opts[:order]}" if opts[:order]
-      cmd << "LIMIT #{Array(opts[:limit]).join(' ')}" if opts[:limit]
-      call_command(cmd)
-    end
-
-  private
-
-    def connect
-      connect_to(@host, @port, @timeout == 0 ? nil : @timeout)
-      call_command([:auth, @password]) if @password
-      call_command([:select, @db]) if @db != 0
-      @sock
-    end
-
-    def connect_to(host, port, timeout = nil)
-
-      # We support connect() timeout only if system_timer is availabe or
-      # if we are running against Ruby >= 1.9. Timeout reading from the
-      # socket instead will be supported anyway.
-      if @timeout != 0 and RedisTimer
-        begin
-          @sock = TCPSocket.new(host, port)
-        rescue Timeout::Error
-          @sock = nil
-          raise Timeout::Error, "Timeout connecting to the server"
-        end
-      else
-        @sock = TCPSocket.new(host, port)
-      end
-
-      @sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
-
-      # If the timeout is set we configure the low level socket options in
-      # order to make sure a blocking read will return after the specified
-      # number of seconds. This hack is from the Memcached Ruby client.
-      if timeout
-        secs = Integer(timeout)
-        usecs = Integer((timeout - secs) * 1_000_000)
-        optval = [secs, usecs].pack("l_2")
-        @sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
-        @sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
-      end
-    rescue Errno::ECONNREFUSED
-      raise Errno::ECONNREFUSED, "Unable to connect to Redis on #{host}:#{port}"
-    end
-
-    def connected?
-      !! @sock
-    end
-
-    def disconnect
-      @sock.close
-      @sock = nil
-      true
-    end
-
-    def reconnect
-      disconnect and connect
-    end
-
-    def method_missing(*argv)
-      call_command(argv)
-    end
-
-    # Wrap raw_call_command to handle reconnection on socket error. We
-    # try to reconnect just one time, otherwise let the error araise.
-    def call_command(argv)
-      connect unless connected?
-      raw_call_command(argv.dup)
-    rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED
-      if reconnect
-        raw_call_command(argv.dup)
-      else
-        raise Errno::ECONNRESET
-      end
-    end
-
-    def raw_call_command(argv)
-      bulk_command?(argv) ?
-        process_bulk_command(argv) :
-        multi_bulk_command?(argv) ?
-          process_multi_bulk_command(argv) :
-          process_command(argv)
-      process_reply(argv[0])
-    end
-
-    def process_command(argv)
-      @sock.write("#{argv.join(" ")}\r\n")
-    end
-
-    def process_bulk_command(argv)
-      bulk = argv.pop.to_s
-      argv.push ssize(bulk)
-      @sock.write("#{argv.join(" ")}\r\n")
-      @sock.write("#{bulk}\r\n")
-    end
-
-    def process_multi_bulk_command(argv)
-      params = argv.pop.to_a.flatten
-      params.unshift(argv[0])
-
-      command = ["*#{params.size}"]
-      params.each do |param|
-        param = param.to_s
-        command << "$#{ssize(param)}"
-        command << param
-      end
-
-      @sock.write(command.map { |cmd| "#{cmd}\r\n"}.join)
-    end
-
-    def bulk_command?(argv)
-      BULK_COMMANDS[argv[0]] and argv.length > 1
-    end
-
-    def multi_bulk_command?(argv)
-      MULTI_BULK_COMMANDS[argv[0]]
-    end
-
-    def process_reply(command)
-      REPLY_PROCESSOR[command][read_reply]
-    end
-
-    def read_reply
-
-      # We read the first byte using read() mainly because gets() is
-      # immune to raw socket timeouts.
-      begin
-        reply_type = @sock.read(1)
-      rescue Errno::EAGAIN
-
-        # We want to make sure it reconnects on the next command after the
-        # timeout. Otherwise the server may reply in the meantime leaving
-        # the protocol in a desync status.
-        @sock = nil
-        raise Errno::EAGAIN, "Timeout reading from the socket"
-      end
-
-      raise Errno::ECONNRESET, "Connection lost" unless reply_type
-
-      format_reply(reply_type, @sock.gets)
-    end
-
-    def format_reply(reply_type, line)
-      case reply_type
-      when "-" then format_error_reply(line)
-      when "+" then format_status_reply(line)
-      when ":" then format_integer_reply(line)
-      when "$" then format_bulk_reply(line)
-      when "*" then format_multi_bulk_reply(line)
-      else raise ProtocolError.new(reply_type)
-      end
-    end
-
-    def format_error_reply(line)
-      raise "-" + line.strip
-    end
-
-    def format_status_reply(line)
-      line.strip
-    end
-
-    def format_integer_reply(line)
-      line.to_i
-    end
-
-    def format_bulk_reply(line)
-      bulklen = line.to_i
-      return if bulklen == -1
-      reply = @sock.read(bulklen)
-      @sock.read(2) # Discard CRLF.
-
-      reply.respond_to?(:force_encoding) ?
-        reply.force_encoding("UTF-8") :
-        reply
-    end
-
-    def format_multi_bulk_reply(line)
-      reply = []
-      line.to_i.times { reply << read_reply }
-      reply
-    end
-
-    def ssize(string)
-      string.respond_to?(:bytesize) ? string.bytesize : string.size
-    end
-  end
-end

data/test/redis_test.rb

@@ -1,432 +0,0 @@
-require File.join(File.dirname(__FILE__), "test_helper")
-
-# This test suit is based on the Redis-rb spec,
-# located at http://github.com/ezmobius/redis-rb/
-class Foo
-  attr_accessor :bar
-  def initialize(bar)
-    @bar = bar
-  end
-
-  def ==(other)
-    @bar == other.bar
-  end
-end
-
-class RedisTest < Test::Unit::TestCase
-  setup do
-    @legacy ||= begin
-                  Ohm.redis.info["redis_version"] <= "1.02"
-                end
-  end
-
-  describe "redis" do
-    setup do
-      @r ||= Ohm.redis
-      @r.set("foo", "bar")
-    end
-
-    teardown do
-      @r.flushdb
-    end
-
-    should "be able to GET a key" do
-      assert_equal "bar", @r.get("foo")
-    end
-
-    should "be able to SET a key" do
-      @r.set("foo", "nik")
-      assert_equal "nik", @r.get("foo")
-    end
-
-    should "be able to SETNX(setnx)" do
-      @r.set("foo", "nik")
-      assert_equal "nik", @r.get("foo")
-      @r.setnx("foo", "bar")
-      assert_equal "nik", @r.get("foo")
-    end
-
-    should "be able to MSET keys" do
-      unless @legacy
-        @r.mset(:foo => "foobar", :bar => 1000)
-        assert_equal ["foobar", "1000"], @r.mget("foo", "bar")
-        assert_equal ["foobar", "1000", nil], @r.mget("foo", "bar", "baz")
-      end
-    end
-
-    should "be able to MGET keys" do
-      @r.set("foo", 1000)
-      @r.set("bar", 2000)
-      assert_equal ["1000", "2000"], @r.mget("foo", "bar")
-      assert_equal ["1000", "2000", nil], @r.mget("foo", "bar", "baz")
-    end
-
-    should "be able to INCR(increment) a key" do
-      @r.del("counter")
-      assert_equal 1, @r.incr("counter")
-      assert_equal 2, @r.incr("counter")
-      assert_equal 3, @r.incr("counter")
-    end
-
-    should "be able to DECR(decrement) a key" do
-      @r.del("counter")
-      assert_equal 1, @r.incr("counter")
-      assert_equal 2, @r.incr("counter")
-      assert_equal 3, @r.incr("counter")
-      assert_equal 2, @r.decr("counter")
-      assert_equal 0, @r.decrby("counter", 2)
-    end
-
-    should "be able to RANDKEY(return a random key)" do
-      assert_not_nil @r.randomkey
-    end
-
-    should "be able to RENAME a key" do
-      @r.del "foo"
-      @r.del "bar"
-      @r.set("foo", "hi")
-      @r.rename "foo", "bar"
-      assert_equal "hi", @r.get("bar")
-    end
-
-    should "be able to RENAMENX(rename unless the new key already exists) a key" do
-      @r.del "foo"
-      @r.del "bar"
-      @r.set("foo", "hi")
-      @r.set("bar", "ohai")
-
-      @r.renamenx "foo", "bar"
-
-      assert_equal "ohai", @r.get("bar")
-    end
-
-    should "be able to EXISTS(check if key exists)" do
-      @r.set("foo", "nik")
-      assert @r.exists("foo")
-      @r.del "foo"
-      assert_equal false, @r.exists("foo")
-    end
-
-    should "be able to KEYS(glob for keys)" do
-      @r.keys("f*").each do |key|
-        @r.del key
-      end
-      @r.set("f", "nik")
-      @r.set("fo", "nak")
-      @r.set("foo", "qux")
-      assert_equal ["f","fo", "foo"], @r.keys("f*").sort
-    end
-
-    should "be able to check the TYPE of a key" do
-      @r.set("foo", "nik")
-      assert_equal "string", @r.type("foo")
-      @r.del "foo"
-      assert_equal "none", @r.type("foo")
-    end
-
-    should "be able to push to the head of a list" do
-      @r.lpush "list", "hello"
-      @r.lpush "list", 42
-      assert_equal "list", @r.type("list")
-      assert_equal 2, @r.llen("list")
-      assert_equal "42", @r.lpop("list")
-      @r.del("list")
-    end
-
-    should "be able to push to the tail of a list" do
-      @r.rpush "list", "hello"
-      assert_equal "list", @r.type("list")
-      assert_equal 1, @r.llen("list")
-      @r.del("list")
-    end
-
-    should "be able to pop the tail of a list" do
-      @r.rpush "list", "hello"
-      @r.rpush "list", "goodbye"
-      assert_equal "list", @r.type("list")
-      assert_equal 2, @r.llen("list")
-      assert_equal "goodbye", @r.rpop("list")
-      @r.del("list")
-    end
-
-    should "be able to pop the head of a list" do
-      @r.rpush "list", "hello"
-      @r.rpush "list", "goodbye"
-      assert_equal "list", @r.type("list")
-      assert_equal 2, @r.llen("list")
-      assert_equal "hello", @r.lpop("list")
-      @r.del("list")
-    end
-
-    should "be able to get the length of a list" do
-      @r.rpush "list", "hello"
-      @r.rpush "list", "goodbye"
-      assert_equal "list", @r.type("list")
-      assert_equal 2, @r.llen("list")
-      @r.del("list")
-    end
-
-    should "be able to get a range of values from a list" do
-      @r.rpush "list", "hello"
-      @r.rpush "list", "goodbye"
-      @r.rpush "list", "1"
-      @r.rpush "list", "2"
-      @r.rpush "list", "3"
-      assert_equal "list", @r.type("list")
-      assert_equal 5, @r.llen("list")
-      assert_equal ["1", "2", "3"], @r.lrange("list", 2, -1)
-      @r.del("list")
-    end
-
-    should "be able to get all the values from a list" do
-      @r.rpush "list", "1"
-      @r.rpush "list", "2"
-      @r.rpush "list", "3"
-      assert_equal "list", @r.type("list")
-      assert_equal 3, @r.llen("list")
-      assert_equal ["1", "2", "3"], @r.list("list")
-      @r.del("list")
-    end
-
-    should "be able to trim a list" do
-      @r.rpush "list", "hello"
-      @r.rpush "list", "goodbye"
-      @r.rpush "list", "1"
-      @r.rpush "list", "2"
-      @r.rpush "list", "3"
-      assert_equal "list", @r.type("list")
-      assert_equal 5, @r.llen("list")
-      @r.ltrim "list", 0, 1
-      assert_equal 2, @r.llen("list")
-      assert_equal ["hello", "goodbye"], @r.lrange("list", 0, -1)
-      @r.del("list")
-    end
-
-    should "be able to get a value by indexing into a list" do
-      @r.rpush "list", "hello"
-      @r.rpush "list", "goodbye"
-      assert_equal "list", @r.type("list")
-      assert_equal 2, @r.llen("list")
-      assert_equal "goodbye", @r.lindex("list", 1)
-      @r.del("list")
-    end
-
-    should "be able to set a value by indexing into a list" do
-      @r.rpush "list", "hello"
-      @r.rpush "list", "hello"
-      assert_equal "list", @r.type("list")
-      assert_equal 2, @r.llen("list")
-      assert @r.lset("list", 1, "goodbye")
-      assert_equal "goodbye", @r.lindex("list", 1)
-      @r.del("list")
-    end
-
-    should "be able to remove values from a list LREM" do
-      @r.rpush "list", "hello"
-      @r.rpush "list", "goodbye"
-      assert_equal "list", @r.type("list")
-      assert_equal 2, @r.llen("list")
-      assert_equal 1, @r.lrem("list", 1, "hello")
-      assert_equal ["goodbye"], @r.lrange("list", 0, -1)
-      @r.del("list")
-    end
-
-    should "be able to pop values from a list and push them onto a temp list with RPOPLPUSH" do
-      unless @legacy
-        @r.rpush "list", 'one'
-        @r.rpush "list", 'two'
-        @r.rpush "list", 'three'
-        assert_equal "list", @r.type('list')
-        assert_equal 3, @r.llen('list')
-        assert_equal %w(one two three), @r.lrange('list',0,-1)
-        assert_equal [], @r.lrange('tmp',0,-1)
-        assert_equal "three", @r.rpoplpush('list', 'tmp')
-        assert_equal %w(three), @r.lrange('tmp',0,-1)
-        assert_equal "two", @r.rpoplpush('list', 'tmp')
-        assert_equal %w(two three), @r.lrange('tmp',0,-1)
-        assert_equal "one", @r.rpoplpush('list', 'tmp')
-        assert_equal %w(one two three), @r.lrange('tmp',0,-1)
-      end
-    end
-
-    should "be able add members to a set" do
-      @r.sadd "set", "key1"
-      @r.sadd "set", "key2"
-      assert_equal "set", @r.type("set")
-      assert_equal 2, @r.scard("set")
-      assert_equal ["key1", "key2"], @r.smembers("set").sort
-      @r.del("set")
-    end
-
-    should "be able delete members to a set" do
-      @r.sadd "set", "key1"
-      @r.sadd "set", "key2"
-      assert_equal "set", @r.type("set")
-      assert_equal 2, @r.scard("set")
-      assert_equal ["key1", "key2"], @r.smembers("set").sort
-      @r.srem("set", "key1")
-      assert_equal 1, @r.scard("set")
-      assert_equal ["key2"], @r.smembers("set")
-      @r.del("set")
-    end
-
-    should "be able count the members of a set" do
-      @r.sadd "set", "key1"
-      @r.sadd "set", "key2"
-      assert_equal "set", @r.type("set")
-      assert_equal 2, @r.scard("set")
-      @r.del("set")
-    end
-
-    should "be able test for set membership" do
-      @r.sadd "set", "key1"
-      @r.sadd "set", "key2"
-      assert_equal "set", @r.type("set")
-      assert_equal 2, @r.scard("set")
-      assert @r.sismember("set", "key1")
-      assert @r.sismember("set", "key2")
-      assert_equal false, @r.sismember("set", "notthere")
-      @r.del("set")
-    end
-
-    should "be able to do set intersection" do
-      @r.sadd "set", "key1"
-      @r.sadd "set", "key2"
-      @r.sadd "set2", "key2"
-      assert_equal ["key2"], @r.sinter("set", "set2")
-      @r.del("set")
-    end
-
-    should "be able to do set intersection and store the results in a key" do
-      @r.sadd "set", "key1"
-      @r.sadd "set", "key2"
-      @r.sadd "set2", "key2"
-      @r.sinterstore("newone", "set", "set2")
-      assert_equal ["key2"], @r.smembers("newone")
-      @r.del("set")
-    end
-
-    should "be able to do crazy SORT queries" do
-      @r.set("dog_1", "louie")
-      @r.rpush "dogs", 1
-      @r.set("dog_2", "lucy")
-      @r.rpush "dogs", 2
-      @r.set("dog_3", "max")
-      @r.rpush "dogs", 3
-      @r.set("dog_4", "taj")
-      @r.rpush "dogs", 4
-      assert_equal ["louie"], @r.sort("dogs", :get => "dog_*", :limit => [0,1])
-      assert_equal ["taj"], @r.sort("dogs", :get => "dog_*", :limit => [0,1], :order => "desc alpha")
-    end
-
-    should "be able add members to a zset ZADD" do
-      unless @legacy
-        @r.zadd 'zset', 1, 'set'
-        assert_equal %w(set), @r.zrange('zset', 0, 1)
-        assert_equal 1, @r.zcard('zset')
-        @r.del('zset')
-      end
-    end
-
-    should "be able count the members of a zset ZCARD" do
-      unless @legacy
-        @r.zadd 'zset', 1, 'foo'
-        @r.zcard('zset')
-        @r.del('zset')
-      end
-    end
-
-
-    should "be able delete members of a zset ZREM" do
-      unless @legacy
-        @r.zadd 'zset', 1, 'set'
-        assert_equal 1, @r.zcard('zset')
-        @r.zadd 'zset', 2, 'set2'
-        assert_equal 2, @r.zcard('zset')
-        @r.zrem 'zset', 'set'
-        assert_equal 1, @r.zcard('zset')
-        @r.del('zset')
-      end
-    end
-
-    should "be able to get a range of values from a zset ZRANGE" do
-      unless @legacy
-        @r.zadd 'zset', 1, 'set'
-        @r.zadd 'zset', 2, 'set2'
-        @r.zadd 'zset', 3, 'set3'
-        assert_equal 3, @r.zcard('zset')
-        assert_equal %w(set set2 set3), @r.zrange('zset', 0, 3)
-        @r.del('set')
-        @r.del('set2')
-        @r.del('set3')
-        @r.del('zset')
-      end
-    end
-
-    should "be able to get a reverse range of values from a zset ZREVRANGE" do
-      unless @legacy
-        @r.zadd 'zset', 1, 'set'
-        @r.zadd 'zset', 2, 'set2'
-        @r.zadd 'zset', 3, 'set3'
-        assert_equal 3, @r.zcard('zset')
-        assert_equal %w(set3 set2 set), @r.zrevrange('zset', 0, 3)
-        @r.del('zset')
-      end
-    end
-
-    should "be able to get a range by score of values from a zset ZRANGEBYSCORE" do
-      unless @legacy
-        @r.zadd 'zset', 1, 'set'
-        @r.zadd 'zset', 2, 'set2'
-        @r.zadd 'zset', 3, 'set3'
-        @r.zadd 'zset', 4, 'set4'
-        assert_equal 4, @r.zcard('zset')
-        assert_equal %w(set2 set3), @r.zrangebyscore('zset', 2, 3)
-        @r.del('zset')
-      end
-    end
-
-    should "increment by a certain amount the score of a zset ZINCRBY" do
-      assert_equal 0, @r.zcard("league")
-
-      @r.zincrby "league", 1, "foo"
-      assert_equal "1", @r.zscore("league", "foo")
-
-      assert_equal 1, @r.zcard("league")
-
-      @r.zincrby "league", 10, "foo"
-      assert_equal "11", @r.zscore("league", "foo")
-
-      @r.set "bar", "2"
-      assert_raises(RuntimeError) do
-        @r.zincrby "bar", 2, "baz"
-      end
-    end
-
-    should "provide info" do
-      %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
-
-    should "be able to flush the database" do
-      @r.set("key1", "keyone")
-      @r.set("key2", "keytwo")
-      assert_equal ["foo", "key1", "key2"], @r.keys("*").sort #foo from before
-      @r.flushdb
-      assert_equal [], @r.keys("*")
-    end
-
-    should "be able to provide the last save time" do
-      savetime = @r.lastsave
-      assert_equal Time, Time.at(savetime).class
-      assert Time.at(savetime) <= Time.now
-    end
-
-    should "bgsave" do
-      assert_nothing_raised do
-        @r.bgsave
-      end
-    end
-  end
-end