ohm 0.0.3 → 0.0.4

data/lib/ohm/redis.rb

@@ -0,0 +1,245 @@
+require 'socket'
+
+begin
+  if (RUBY_VERSION >= '1.9')
+    require 'timeout'
+    RedisTimer = Timeout
+  else
+    require 'system_timer'
+    RedisTimer = SystemTimer
+  end
+rescue LoadError
+  RedisTimer = nil
+end
+
+module Ohm
+  class Redis
+    class ProtocolError < RuntimeError
+      def initialize(reply_type)
+        super("Protocol error, got '#{reply_type}' as initial reply byte")
+      end
+    end
+
+    BulkCommands = {
+      :set => true,
+      :setnx => true,
+      :rpush => true,
+      :lpush => true,
+      :lset => true,
+      :lrem => true,
+      :sadd => true,
+      :srem => true,
+      :sismember => true,
+      :echo => true,
+      :getset => true,
+      :smove => true
+    }
+
+    ProcessorIdentity = lambda { |reply| reply }
+    ProcessorConvertToBool = lambda { |reply| reply == 0 ? false : reply }
+    ProcessorSplitKeys = lambda { |reply| reply.split(" ") }
+    ProcessorInfo = lambda do |reply|
+      info = Hash.new
+      reply.each_line do |line|
+        key, value = line.split(":", 2).map { |part| part.chomp }
+        info[key.to_sym] = value
+      end
+      info
+    end
+
+    ReplyProcessor = {
+      :exists => ProcessorConvertToBool,
+      :sismember=> ProcessorConvertToBool,
+      :sadd=> ProcessorConvertToBool,
+      :srem=> ProcessorConvertToBool,
+      :smove=> ProcessorConvertToBool,
+      :move=> ProcessorConvertToBool,
+      :setnx=> ProcessorConvertToBool,
+      :del=> ProcessorConvertToBool,
+      :renamenx=> ProcessorConvertToBool,
+      :expire=> ProcessorConvertToBool,
+      :keys => ProcessorSplitKeys,
+      :info => ProcessorInfo
+    }
+
+    ReplyProcessor.send(:initialize) do |hash, key|
+      hash[key] = ProcessorIdentity
+    end
+
+    def initialize(opts={})
+      @host = opts[:host] || '127.0.0.1'
+      @port = opts[:port] || 6379
+      @db = opts[:db] || 0
+      @timeout = opts[:timeout] || 0
+      connect
+    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 #{opts[:limit].join(' ')}" if opts[:limit]
+      call_command(cmd)
+    end
+
+  private
+
+    def connect
+      connect_to(@host, @port, @timeout == 0 ? nil : @timeout)
+      call_command([:select, @db]) if @db != 0
+    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, 0)
+        rescue Timeout::Error
+          @sock = nil
+          raise Timeout::Error, "Timeout connecting to the server"
+        end
+      else
+        @sock = TCPSocket.new(host, port, 0)
+      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
+    end
+
+    def connected?
+      !! @sock
+    end
+
+    def disconnect
+      @sock.close
+    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)
+    rescue Errno::ECONNRESET
+      reconnect
+      raw_call_command(argv)
+    end
+
+    def raw_call_command(argv)
+      bulk = extract_bulk_argument(argv)
+      @sock.write(argv.join(" ") + "\r\n")
+      @sock.write(bulk + "\r\n") if bulk
+      process_reply(argv[0])
+    end
+
+    def bulk_command?(argv)
+      BulkCommands[argv[0]] and argv.length > 1
+    end
+
+    def extract_bulk_argument(argv)
+      if bulk_command?(argv)
+        bulk = argv[-1].to_s
+        argv[-1] = bulk.length
+        bulk
+      end
+    end
+
+    def process_reply(command)
+      ReplyProcessor[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 nil if bulklen == -1
+      reply = @sock.read(bulklen)
+      @sock.read(2) # Discard CRLF.
+      reply
+    end
+
+    def format_multi_bulk_reply(line)
+      reply = []
+      line.to_i.times { reply << read_reply }
+      reply
+    end
+  end
+end

data/lib/ohm/validations.rb

@@ -23,7 +23,7 @@ module Ohm
 
     def assert_present(att)
       if assert_not_nil(att)
-        assert send(att).any?, [att, :empty]
+        assert !send(att).empty?, [att, :empty]
       end
     end
 

data/lib/ohm.rb

@@ -1,13 +1,24 @@
-require "rubygems"
-require "redis"
+require File.join(File.dirname(__FILE__), "ohm", "redis")
 require File.join(File.dirname(__FILE__), "ohm", "validations")
 
 module Ohm
+  def redis
+    @redis
+  end
+
+  def connect(*attrs)
+    @redis = Ohm::Redis.new(*attrs)
+  end
+
+  def flush
+    @redis.flushdb
+  end
+
   def key(*args)
     args.join(":")
   end
 
-  module_function :key
+  module_function :key, :connect, :flush, :redis
 
   module Attributes
     class Collection < Array
@@ -22,29 +33,29 @@ module Ohm
 
     class List < Collection
       def retrieve
-        db.list_range(key, 0, -1)
+        db.list(key)
       end
 
       def << value
-        super(value) if db.push_tail(key, value)
+        super(value) if db.rpush(key, value)
       end
     end
 
     class Set < Collection
       def retrieve
-        db.set_members(key).sort
+        db.smembers(key).sort
       end
 
       def << value
-        super(value) if db.set_add(key, value)
+        super(value) if db.sadd(key, value)
       end
 
       def delete(value)
-        super(value) if db.set_delete(key, value)
+        super(value) if db.srem(key, value)
       end
 
       def include?(value)
-        db.set_member?(key, value)
+        db.sismember(key, value)
       end
     end
   end
@@ -55,7 +66,7 @@ module Ohm
 
       def assert_unique(attrs)
         index_key = index_key_for(attrs, read_locals(attrs))
-        assert(db.set_count(index_key).zero? || db.set_member?(index_key, id), [attrs, :not_unique])
+        assert(db.scard(index_key).zero? || db.sismember(index_key, id), [attrs, :not_unique])
       end
     end
 
@@ -135,10 +146,7 @@ module Ohm
       new(*args).create
     end
 
-    # TODO Add a method that receives several arguments and returns a
-    # string with the values separated by colons.
     def self.find(attribute, value)
-      # filter("#{attribute}:#{value}")
       filter(Ohm.key(attribute, value))
     end
 
@@ -200,7 +208,7 @@ module Ohm
   private
 
     def self.db
-      $redis
+      Ohm.redis
     end
 
     def self.key(*args)
@@ -208,13 +216,13 @@ module Ohm
     end
 
     def self.filter(name)
-      db.set_members(key(name)).map do |id|
+      db.smembers(key(name)).map do |id|
         new(:id => id)
       end
     end
 
     def self.exists?(id)
-      db.set_member?(key(:all), id)
+      db.sismember(key(:all), id)
     end
 
     def initialize_id
@@ -222,21 +230,21 @@ module Ohm
     end
 
     def db
-      self.class.db
+      Ohm.redis
     end
 
     def delete_attributes(atts)
       atts.each do |att|
-        db.delete(key(att))
+        db.del(key(att))
       end
     end
 
     def create_model_membership
-      db.set_add(self.class.key(:all), id)
+      db.sadd(self.class.key(:all), id)
     end
 
     def delete_model_membership
-      db.set_delete(self.class.key(:all), id)
+      db.srem(self.class.key(:all), id)
     end
 
     def save!
@@ -251,13 +259,13 @@ module Ohm
 
     def add_to_indices
       indices.each do |attrs|
-        db.set_add(index_key_for(attrs, read_locals(attrs)), id)
+        db.sadd(index_key_for(attrs, read_locals(attrs)), id)
       end
     end
 
     def delete_from_indices
       indices.each do |attrs|
-        db.set_delete(index_key_for(attrs, read_remotes(attrs)), id)
+        db.srem(index_key_for(attrs, read_remotes(attrs)), id)
       end
     end
 
@@ -270,11 +278,11 @@ module Ohm
     end
 
     def read_remote(att)
-      id && db[key(att)]
+      id && db.get(key(att))
     end
 
     def write_remote(att, value)
-      db[key(att)] = value
+      db.set(key(att), value)
     end
 
     def read_locals(attrs)

data/test/benchmarks.rb

@@ -1,9 +1,12 @@
 require "rubygems"
 require "bench"
 require File.dirname(__FILE__) + "/../lib/ohm"
+require "redis"
 
-$redis = Redis.new(:port => 6381)
-$redis.flush_db
+Ohm.connect(:port => 6381)
+Ohm.flush
+
+$r = Redis.new(:port => 6381)
 
 class Event < Ohm::Model
   attribute :name
@@ -17,36 +20,59 @@ end
 event = Event.create(:name => "Ruby Tuesday")
 array = []
 
-benchmark "redis add to set" do
-  $redis.set_add("foo", 1)
+benchmark "add to set with ohm redis" do
+  Ohm.redis.sadd("foo", 1)
+end
+
+benchmark "add to set with redis" do
+  $r.set_add("foo", 1)
 end
 
-benchmark "ohm add to set" do
+benchmark "add to set with ohm" do
   event.attendees << 1
 end
 
-benchmark "ruby array push" do
-  array.push(1)
+Ohm.redis.sadd("bar", 1)
+Ohm.redis.sadd("bar", 2)
+
+benchmark "retrieve a set of two members with ohm redis" do
+  Ohm.redis.sadd("bar", 3)
+  Ohm.redis.srem("bar", 3)
+  Ohm.redis.smembers("bar")
+end
+
+$r.set_add("bar", 1)
+$r.set_add("bar", 2)
+
+benchmark "retrieve a set of two members with redis" do
+  $r.set_add("bar", 3)
+  $r.set_delete("bar", 3)
+  $r.set_members("bar")
 end
 
-$redis.set_add("bar", 1)
-$redis.set_add("bar", 2)
+Ohm.redis.del("Event:#{event.id}:attendees")
+$r.delete("Event:#{event.id}:attendees")
+
+event.attendees << 1
+event.attendees << 2
 
-benchmark "retrieve a set of two members" do
-  $redis.set_members("bar")
+benchmark "retrieve a set of two members with ohm" do
+  event.attendees << 3
+  event.attendees.delete(3)
+  event.attendees
 end
 
 benchmark "retrieve membership status and set count" do
-  $redis.set_count("bar")
-  $redis.set_member?("bar", "1")
+  Ohm.redis.scard("bar")
+  Ohm.redis.sismember("bar", "1")
 end
 
 benchmark "retrieve set count" do
-  $redis.set_count("bar").zero?
+  Ohm.redis.scard("bar").zero?
 end
 
 benchmark "retrieve membership status" do
-  $redis.set_member?("bar", "1")
+  Ohm.redis.sismember("bar", "1")
 end
 
-run 20_000
+run 10_000

data/test/indices_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require File.join(File.dirname(__FILE__), "test_helper")
 
 class IndicesTest < Test::Unit::TestCase
   class User < Ohm::Model
@@ -9,14 +9,14 @@ class IndicesTest < Test::Unit::TestCase
 
   context "A model with an indexed attribute" do
     setup do
-      $redis.flush_db
+      Ohm.redis.flushdb
 
       @user1 = User.create(:email => "foo")
       @user2 = User.create(:email => "bar")
     end
 
     should "be able to find by the given attribute" do
-      assert_equal [@user1], User.find(:email, "foo").to_a
+      assert_equal [@user1], User.find(:email, "foo")
     end
 
     should "update indices when changing attribute values" do
@@ -24,13 +24,13 @@ class IndicesTest < Test::Unit::TestCase
       @user1.save
 
       assert_equal [], User.find(:email, "foo").to_a
-      assert_equal [@user1], User.find(:email, "baz").to_a
+      assert_equal [@user1], User.find(:email, "baz")
     end
 
     should "remove from the index after deleting" do
       @user2.delete
 
-      assert_equal [], User.find(:email, "bar").to_a
+      assert_equal [], User.find(:email, "bar")
     end
   end
 end

data/test/model_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require File.join(File.dirname(__FILE__), "test_helper")
 
 class Event < Ohm::Model
   attribute :name
@@ -32,8 +32,8 @@ class TestRedis < Test::Unit::TestCase
 
   context "Finding an event" do
     setup do
-      $redis.set_add("Event", 1)
-      $redis["Event:1:name"] = "Concert"
+      Ohm.redis.sadd("Event", 1)
+      Ohm.redis.set("Event:1:name", "Concert")
     end
 
     should "return an instance of Event" do
@@ -45,8 +45,8 @@ class TestRedis < Test::Unit::TestCase
 
   context "Finding a user" do
     setup do
-      $redis.set_add("User:all", 1)
-      $redis["User:1:email"] = "albert@example.com"
+      Ohm.redis.sadd("User:all", 1)
+      Ohm.redis.set("User:1:email", "albert@example.com")
     end
 
     should "return an instance of User" do
@@ -58,8 +58,8 @@ class TestRedis < Test::Unit::TestCase
 
   context "Updating a user" do
     setup do
-      $redis.set_add("User:all", 1)
-      $redis["User:1:email"] = "albert@example.com"
+      Ohm.redis.sadd("User:all", 1)
+      Ohm.redis.set("User:1:email", "albert@example.com")
 
       @user = User[1]
     end
@@ -131,10 +131,10 @@ class TestRedis < Test::Unit::TestCase
 
       @model.delete
 
-      assert_nil $redis[ModelToBeDeleted.key(id)]
-      assert_nil $redis[ModelToBeDeleted.key(id, :name)]
-      assert_equal Set.new, $redis.set_members(ModelToBeDeleted.key(id, :foos))
-      assert_equal Array.new, $redis.list_range(ModelToBeDeleted.key(id, :bars), 0, -1)
+      assert_nil Ohm.redis.get(ModelToBeDeleted.key(id))
+      assert_nil Ohm.redis.get(ModelToBeDeleted.key(id, :name))
+      assert_equal Array.new, Ohm.redis.smembers(ModelToBeDeleted.key(id, :foos))
+      assert_equal Array.new, Ohm.redis.list(ModelToBeDeleted.key(id, :bars))
 
       assert ModelToBeDeleted.all.empty?
     end

data/test/redis_test.rb

@@ -0,0 +1,314 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class Foo
+  attr_accessor :bar
+  def initialize(bar)
+    @bar = bar
+  end
+
+  def ==(other)
+    @bar == other.bar
+  end
+end
+
+class RedisTest < Test::Unit::TestCase
+  describe "redis" do
+    setup do
+      @r ||= Ohm.redis
+      @r.set("foo", "bar")
+    end
+
+    teardown do
+      @r.flushdb
+    end
+
+    should "should be able to GET a key" do
+      assert_equal "bar", @r.get("foo")
+    end
+
+    should "should be able to SET a key" do
+      @r.set("foo", "nik")
+      assert_equal "nik", @r.get("foo")
+    end
+
+    should "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 "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 "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 "should be able to RANDKEY(return a random key)" do
+      assert_not_nil @r.randomkey
+    end
+
+    should "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "should provide info" do
+      [: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 "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 "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 "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 "should bgsave" do
+      assert_nothing_raised do
+        @r.bgsave
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,7 +1,12 @@
 require "rubygems"
-require "ruby-debug"
+
+begin
+  require "ruby-debug"
+rescue LoadError
+end
+
 require "contest"
 require File.dirname(__FILE__) + "/../lib/ohm"
 
-$redis = Redis.new(:port => 6381)
-$redis.flush_db
+Ohm.connect(:port => 6381)
+Ohm.flush

data/test/validations_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require File.join(File.dirname(__FILE__), "test_helper")
 
 class ValidationsTest < Test::Unit::TestCase
   class Event < Ohm::Model

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ohm
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Michel Martens, Damian Janowski
@@ -11,17 +11,8 @@ cert_chain: []
 
 date: 2009-03-13 00:00:00 -02:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: ezmobius-redis-rb
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.0.3
-    version: 
+dependencies: []
+
 description: 
 email: michel@soveran.com
 executables: []
@@ -31,6 +22,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/ohm/redis.rb
 - lib/ohm/validations.rb
 - lib/ohm.rb
 - README.markdown
@@ -42,6 +34,7 @@ files:
 - test/db/redis.pid
 - test/indices_test.rb
 - test/model_test.rb
+- test/redis_test.rb
 - test/test.conf
 - test/test_helper.rb
 - test/validations_test.rb