fakeredis 0.1.0

data/lib/fakeredis/server.rb

@@ -0,0 +1,65 @@
+module FakeRedis
+  class Redis
+    module ServerMethods
+
+      def bgreriteaof ; end
+
+      def bgsave ; end
+
+      def config_get(param) ; end
+
+      def config_set(param, value) ; end
+
+      def config_resetstat ; end
+
+      def dbsize
+        @data.keys.count
+      end
+
+      def debug_object(key)
+        return @data[key].inspect
+      end
+
+      def flushdb
+        @data = {}
+        @expires = {}
+      end
+
+      alias flushall flushdb
+
+      def info
+        server_info = {
+          "redis_version" => "0.07",
+          "connected_clients" => "1",
+          "connected_slaves" => "0",
+          "used_memory" => "3187",
+          "changes_since_last_save" => "0",
+          "last_save_time" => "1237655729",
+          "total_connections_received" => "1",
+          "total_commands_processed" => "1",
+          "uptime_in_seconds" => "36000",
+          "uptime_in_days" => 0
+        }
+        return server_info
+      end
+
+      def lastsave
+        Time.now.to_i
+      end
+
+      def monitor ; end
+
+      def save ; end
+
+      def shutdown ; end
+
+      def slaveof(host, port) ; end
+
+      def sync ; end
+
+      alias reset flushdb
+    end
+
+    include ServerMethods
+  end
+end

data/lib/fakeredis/sets.rb

@@ -0,0 +1,122 @@
+module FakeRedis
+  class Redis
+    module SetsMethods
+      def sadd(key, value)
+        fail_unless_set(key)
+        case set = @data[key]
+          when nil then @data[key] = Set.new([value.to_s])
+          when Set then set.add(value.to_s)
+        end
+      end
+
+      def scard(key)
+        fail_unless_set(key)
+        case set = @data[key]
+          when nil then 0
+          when Set then set.size
+        end
+      end
+
+      def sdiff(key1, *keys)
+        [key1, *keys].each { |k| fail_unless_set(k) }
+        keys = keys.map { |k| @data[k] || Set.new }
+        keys.inject(@data[key1]) do |memo, set|
+          memo - set
+        end.to_a
+      end
+
+      def sdiffstore(destination, key1, *keys)
+        fail_unless_set(destination)
+        result = sdiff(key1, *keys)
+        @data[destination] = Set.new(result)
+      end
+
+      def sinter(*keys)
+        keys.each { |k| fail_unless_set(k) }
+        return Set.new if keys.any? { |k| @data[k].nil? }
+        keys = keys.map { |k| @data[k] || Set.new }
+        keys.inject do |set, key|
+          set & key
+        end.to_a
+      end
+
+      def sinterstore(destination, *keys)
+        fail_unless_set(destination)
+        result = sinter(*keys)
+        @data[destination] = Set.new(result)
+      end
+
+      def sismember(key, value)
+        fail_unless_set(key)
+        case set = @data[key]
+          when nil then false
+          when Set then set.include?(value.to_s)
+        end
+      end
+
+      def smembers(key)
+        fail_unless_set(key)
+        case set = @data[key]
+          when nil then []
+          when Set then set.to_a
+        end
+      end
+
+      def smove(source, destination, value)
+        fail_unless_set(destination)
+        if elem = self.srem(source, value)
+          self.sadd(destination, value)
+        end
+      end
+
+      def spop(key)
+        fail_unless_set(key)
+        elem = srandmember(key)
+        srem(key, elem)
+        elem
+      end
+
+      def srandmember(key)
+        fail_unless_set(key)
+        case set = @data[key]
+          when nil then nil
+          when Set then set.to_a[rand(set.size)]
+        end
+      end
+
+      def srem(key, value)
+        fail_unless_set(key)
+        case set = @data[key]
+          when nil then return
+          when Set then set.delete(value.to_s)
+        end
+      end
+
+      def sunion(*keys)
+        keys.each { |k| fail_unless_set(k) }
+        keys = keys.map { |k| @data[k] || Set.new }
+        keys.inject(Set.new) do |set, key|
+          set | key
+        end.to_a
+      end
+
+      def sunionstore(destination, *keys)
+        fail_unless_set(destination)
+        result = sunion(*keys)
+        @data[destination] = Set.new(result)
+      end
+
+      private
+
+      def is_a_set?(key)
+        @data[key].is_a?(Set) || @data[key].nil?
+      end
+
+      def fail_unless_set(key)
+        fail "Not a set" unless is_a_set?(key)
+      end
+    end
+
+    include SetsMethods
+  end
+end

data/lib/fakeredis/sorted_sets.rb

@@ -0,0 +1,108 @@
+module FakeRedis
+  class Redis
+    module SortedSetsMethods
+      class Elem < String
+        attr_accessor :score
+        def initialize(str="", score)
+          super(str)
+          @score = score
+        end
+        def <=>(other)
+          @score <=> other.score
+        end
+      end
+
+      class CustomSortedSet < SortedSet
+        attr_accessor :indexed_set
+        def add(o)
+          super(o)
+          @indexed_set ||= Set.new
+          @indexed_set.add(o)
+        end
+
+        def delete(o)
+          super(o)
+          @indexed_set ||= Set.new
+          @indexed_set.delete(o)
+        end
+      end
+
+      def zadd(key, score, value)
+        fail_unless_sorted_set(key)
+        case set = @data[key]
+          when nil then @data[key] = CustomSortedSet.new([Elem.new(value.to_s, score)])
+          when CustomSortedSet then set.delete(value.to_s) ; set.add(Elem.new(value.to_s, score))
+        end
+      end
+
+      def zcard(key)
+        fail_unless_sorted_set(key)
+        case set = @data[key]
+          when nil then 0
+          when CustomSortedSet then set.size
+        end
+      end
+
+      def zcount(key, min, max)
+        fail_unless_sorted_set(key)
+        case set = @data[key]
+          when nil then 0
+          when CustomSortedSet then set.select{|x| x.score >= min && x.score <= max }.size
+        end
+      end
+
+      def zincrby(key, incr, value)
+        fail_unless_sorted_set(key)
+        case set = @data[key]
+          when nil then @data[key] = CustomSortedSet.new([Elem.new(value.to_s, incr)])
+          when CustomSortedSet then 
+            score = set.to_a.select{|x| x == value.to_s}.first.score
+            set.delete(value.to_s)
+            set.add(Elem.new(value.to_s, score+incr))
+        end
+      end
+
+      def zrange(key, start, stop)
+        fail_unless_sorted_set(key)
+        case set = @data[key]
+          when nil then []
+          when CustomSortedSet then set.indexed_set.to_a[start..stop]
+        end
+      end
+
+      def zrangescore(key, start, stop)
+        fail_unless_sorted_set(key)
+        case set = @data[key]
+          when nil then []
+          when CustomSortedSet then set.to_a.reverse[start..stop]
+        end
+      end
+
+      def zrank(key, value)
+        fail_unless_sorted_set(key)
+        case set = @data[key]
+          when nil then nil
+          when CustomSortedSet then set.to_a.index(value)
+        end
+      end
+
+      def zscore(key, value)
+        case set = @data[key]
+          when nil then 0
+          when CustomSortedSet then set.to_a.select{|x| x == value.to_s}.first.score
+        end
+      end
+
+      private
+
+      def is_a_sorted_set?(key)
+        @data[key].is_a?(CustomSortedSet) || @data[key].nil?
+      end
+
+      def fail_unless_sorted_set(key)
+        fail "Not a sorted set" unless is_a_sorted_set?(key)
+      end
+    end
+    include SortedSetsMethods
+  end
+end

data/lib/fakeredis/strings.rb

@@ -0,0 +1,112 @@
+module FakeRedis
+  class Redis
+    module StringsMethods
+
+      def append(key, value)
+        @data[key] = (@data[key] || "")
+        @data[key] = @data[key] + value.to_s
+      end
+
+      def decr(key)
+        @data[key] = (@data[key] || "0")
+        @data[key] = (@data[key].to_i - 1).to_s
+      end
+
+      def decrby(key, by)
+        @data[key] = (@data[key] || "0")
+        @data[key] = (@data[key].to_i - by.to_i).to_s
+      end
+
+      def get(key)
+        #return if expired?(key)
+        @data[key]
+      end
+
+      def getbit(key, offset)
+        #return if expired?(key)
+        return unless @data[key]
+        @data[key].unpack('B8')[0].split("")[offset]
+      end
+
+      def getrange(key, start, ending)
+        return unless @data[key]
+        @data[key][start..ending]
+      end
+
+      def getset(key, value)
+        return unless @data[key]
+        old_value = @data[key]
+        @data[key] = value
+        return old_value
+      end
+
+      def incr(key)
+        @data[key] = (@data[key] || "0")
+        @data[key] = (@data[key].to_i + 1).to_s
+      end
+
+      def incrby(key, by)
+        @data[key] = (@data[key] || "0")
+        @data[key] = (@data[key].to_i + by.to_i).to_s
+      end
+
+      def mget(*keys)
+        @data.values_at(*keys)
+      end
+
+      def mset(*pairs)
+        pairs.each_slice(2) do |pair|
+          @data[pair[0].to_s] = pair[1].to_s
+        end
+        "OK"
+      end
+
+      def msetnx(*pairs)
+        keys = []
+        pairs.each_with_index{|item, index| keys << item.to_s if index % 2 == 0}
+        return if keys.any?{|key| @data.key?(key) }
+        mset(*pairs)
+        true
+      end
+
+      def set(key, value)
+        @data[key] = value.to_s
+        "OK"
+      end
+
+      def setbit(key, offset, bit)
+        return unless @data[key]
+        old_val = @data[key].unpack('B*')[0].split("")
+        old_val[offset] = bit.to_s
+        new_val = ""
+        old_val.each_slice(8){|b| new_val = new_val + b.join("").to_i(2).chr }
+        @data[key] = new_val
+      end
+
+      def setex(key, seconds, value)
+        @data[key] = value
+        expire(key, seconds)
+      end
+
+      def setnx(key, value)
+        set(key, value) unless @data.key?(key)
+      end
+
+      def setrange(key, offset, value)
+        return unless @data[key]
+        s = @data[key][offset,value.size]
+        @data[key][s] = value
+      end
+
+      def strlen(key)
+        return unless @data[key]
+        @data[key].size
+      end
+
+      alias [] get
+      alias []= set
+    end
+
+    include StringsMethods
+  end
+end

data/lib/fakeredis/transactions.rb

@@ -0,0 +1,13 @@
+module FakeRedis
+  class Redis
+    module TransactionsMethods
+
+      def multi
+        yield if block_given?
+      end
+
+    end
+
+    include TransactionsMethods
+  end
+end

data/lib/fakeredis/version.rb

@@ -0,0 +1,3 @@
+module FakeRedis
+  VERSION = "0.1.0"
+end

data/spec/connection_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module FakeRedis
+  describe "ConnectionMethods" do
+
+    before(:each) do
+      @client = FakeRedis::Redis.new
+    end
+
+    it "should authenticate to the server" do
+      @client.auth("pass").should == true
+    end
+
+    it "should echo the given string" do
+      @client.echo("something").should == "something"
+    end
+
+    it "should ping the server" do
+      @client.ping.should == "PONG"
+    end
+  end
+end