redis_migrator 0.0.1

data/spec/mock_redis/lib/mock_redis/list_methods.rb

@@ -0,0 +1,187 @@
+require 'mock_redis/assertions'
+require 'mock_redis/utility_methods'
+
+class MockRedis
+  module ListMethods
+    include Assertions
+    include UtilityMethods
+
+    def blpop(*args)
+      lists, timeout = extract_timeout(args)
+      nonempty_list = first_nonempty_list(lists)
+
+      if nonempty_list
+        [nonempty_list, lpop(nonempty_list)]
+      elsif timeout > 0
+        nil
+      else
+        raise MockRedis::WouldBlock, "Can't block forever"
+      end
+    end
+
+    def brpop(*args)
+      lists, timeout = extract_timeout(args)
+      nonempty_list = first_nonempty_list(lists)
+
+      if nonempty_list
+        [nonempty_list, rpop(nonempty_list)]
+      elsif timeout > 0
+        nil
+      else
+        raise MockRedis::WouldBlock, "Can't block forever"
+      end
+    end
+
+    def brpoplpush(source, destination, timeout)
+      assert_valid_timeout(timeout)
+
+      if llen(source) > 0
+        rpoplpush(source, destination)
+      elsif timeout > 0
+        nil
+      else
+        raise MockRedis::WouldBlock, "Can't block forever"
+      end
+    end
+
+    def lindex(key, index)
+      with_list_at(key) {|l| l[index]}
+    end
+
+    def linsert(key, position, pivot, value)
+      unless %w[before after].include?(position.to_s)
+        raise RuntimeError, "ERR syntax error"
+      end
+
+      assert_listy(key)
+      return 0 unless data[key]
+
+      pivot_position = (0..llen(key) - 1).find do |i|
+        data[key][i] == pivot.to_s
+      end
+
+      return -1 unless pivot_position
+
+      insertion_index = if position.to_s == 'before'
+                          pivot_position
+                        else
+                          pivot_position + 1
+                        end
+
+      data[key].insert(insertion_index, value.to_s)
+      llen(key)
+    end
+
+    def llen(key)
+      with_list_at(key, &:length)
+    end
+
+    def lpop(key)
+      with_list_at(key, &:shift)
+    end
+
+    def lpush(key, value)
+      with_list_at(key) {|l| l.unshift(value.to_s)}
+      llen(key)
+    end
+
+    def lpushx(key, value)
+      assert_listy(key)
+      return 0 unless list_at?(key)
+      lpush(key, value)
+    end
+
+    def lrange(key, start, stop)
+      with_list_at(key) {|l| l[start..stop]}
+    end
+
+    def lrem(key, count, value)
+      count = count.to_i
+      value = value.to_s
+
+      with_list_at(key) do |list|
+        indices_with_value = (0..(llen(key) - 1)).find_all do |i|
+          list[i] == value
+        end
+
+        indices_to_delete = if count == 0
+                              indices_with_value.reverse
+                            elsif count > 0
+                              indices_with_value.take(count).reverse
+                            else
+                              indices_with_value.reverse.take(-count)
+                            end
+
+        indices_to_delete.each {|i| list.delete_at(i)}.length
+      end
+    end
+
+    def lset(key, index, value)
+      assert_listy(key)
+
+      unless list_at?(key)
+        raise RuntimeError, "ERR no such key"
+      end
+
+      unless (0...llen(key)).include?(index)
+        raise RuntimeError, "ERR index out of range"
+      end
+
+      data[key][index] = value.to_s
+      'OK'
+    end
+
+    def ltrim(key, start, stop)
+      with_list_at(key) do |list|
+        list.replace(list[start..stop] || []) if list
+        'OK'
+      end
+    end
+
+    def rpop(key)
+      with_list_at(key) {|list| list.pop if list}
+    end
+
+    def rpoplpush(source, destination)
+      value = rpop(source)
+      lpush(destination, value)
+      value
+    end
+
+    def rpush(key, value)
+      with_list_at(key) {|l| l.push(value.to_s)}
+      llen(key)
+    end
+
+    def rpushx(key, value)
+      assert_listy(key)
+      return 0 unless list_at?(key)
+      rpush(key, value)
+    end
+
+    private
+    def list_at?(key)
+      data[key] && listy?(key)
+    end
+
+    def with_list_at(key, &blk)
+      with_thing_at(key, :assert_listy, proc {[]}, &blk)
+    end
+
+    def listy?(key)
+      data[key].nil? || data[key].kind_of?(Array)
+    end
+
+    def assert_listy(key)
+      unless listy?(key)
+        # Not the most helpful error, but it's what redis-rb barfs up
+        raise RuntimeError, "ERR Operation against a key holding the wrong kind of value"
+      end
+    end
+
+    def first_nonempty_list(keys)
+      keys.find{|k| llen(k) > 0}
+    end
+
+  end
+end

data/spec/mock_redis/lib/mock_redis/multi_db_wrapper.rb

@@ -0,0 +1,86 @@
+require 'mock_redis/undef_redis_methods'
+
+class MockRedis
+  class MultiDbWrapper
+    include UndefRedisMethods
+
+    def initialize(db)
+      @db_index = 0
+
+      @prototype_db = db.clone
+
+      @databases = Hash.new {|h,k| h[k] = @prototype_db.clone}
+      @databases[@db_index] = db
+    end
+
+    def respond_to?(method, include_private=false)
+      super || current_db.respond_to?(method, include_private)
+    end
+
+    def method_missing(method, *args)
+      current_db.send(method, *args)
+    end
+
+    def initialize_copy(source)
+      super
+      @databases = @databases.clone
+      @databases.keys.each do |k|
+        @databases[k] = @databases[k].clone
+      end
+    end
+
+    # Redis commands
+    def flushall
+      @databases.values.each(&:flushdb)
+      'OK'
+    end
+
+    def move(key, db_index)
+      src = current_db
+      dest = db(db_index)
+
+      if !src.exists(key) || dest.exists(key)
+        false
+      else
+        case current_db.type(key)
+        when 'hash'
+          dest.hmset(key, *(src.hgetall(key).map{|k,v| [k,v]}.flatten))
+        when 'list'
+          while value = src.rpop(key)
+            dest.lpush(key, value)
+          end
+        when 'set'
+          while value = src.spop(key)
+            dest.sadd(key, value)
+          end
+        when 'string'
+          dest.set(key, src.get(key))
+        when 'zset'
+          src.zrange(key, 0, -1, :with_scores => true).each_slice(2) do |(m,s)|
+            dest.zadd(key, s, m)
+          end
+        else
+          raise ArgumentError,
+          "Can't move a key of type #{current_db.type(key).inspect}"
+        end
+
+        src.del(key)
+        true
+      end
+    end
+
+    def select(db_index)
+      @db_index = db_index.to_i
+      'OK'
+    end
+
+    private
+    def current_db
+      @databases[@db_index]
+    end
+
+    def db(index)
+      @databases[index]
+    end
+  end
+end

data/spec/mock_redis/lib/mock_redis/set_methods.rb

@@ -0,0 +1,126 @@
+require 'mock_redis/assertions'
+require 'mock_redis/utility_methods'
+
+class MockRedis
+  module SetMethods
+    include Assertions
+    include UtilityMethods
+
+    def sadd(key, member)
+      with_set_at(key) {|s| !!s.add?(member.to_s)}
+    end
+
+    def scard(key)
+      with_set_at(key) {|s| s.length}
+    end
+
+    def sdiff(*keys)
+      assert_has_args(keys, 'sdiff')
+      with_sets_at(*keys) {|*sets| sets.reduce(&:-)}.to_a
+    end
+
+    def sdiffstore(destination, *keys)
+      assert_has_args(keys, 'sdiffstore')
+      with_set_at(destination) do |set|
+        set.replace(sdiff(*keys))
+      end
+      scard(destination)
+    end
+
+    def sinter(*keys)
+      assert_has_args(keys, 'sinter')
+
+      with_sets_at(*keys) do |*sets|
+        sets.reduce(&:&).to_a
+      end
+    end
+
+    def sinterstore(destination, *keys)
+      assert_has_args(keys, 'sinterstore')
+      with_set_at(destination) do |set|
+        set.replace(sinter(*keys))
+      end
+      scard(destination)
+    end
+
+    def sismember(key, member)
+      with_set_at(key) {|s| s.include?(member.to_s)}
+    end
+
+    def smembers(key)
+      with_set_at(key, &:to_a)
+    end
+
+    def smove(src, dest, member)
+      member = member.to_s
+
+      with_sets_at(src, dest) do |src_set, dest_set|
+        if src_set.delete?(member)
+          dest_set.add(member)
+          true
+        else
+          false
+        end
+      end
+    end
+
+    def spop(key)
+      with_set_at(key) do |set|
+        member = set.first
+        set.delete(member)
+        member
+      end
+    end
+
+    def srandmember(key)
+      members = with_set_at(key, &:to_a)
+      members[rand(members.length)]
+    end
+
+    def srem(key, member)
+      with_set_at(key) {|s| !!s.delete?(member.to_s)}
+    end
+
+    def sunion(*keys)
+      assert_has_args(keys, 'sunion')
+      with_sets_at(*keys) {|*sets| sets.reduce(&:+).to_a}
+    end
+
+    def sunionstore(destination, *keys)
+      assert_has_args(keys, 'sunionstore')
+      with_set_at(destination) do |dest_set|
+        dest_set.replace(sunion(*keys))
+      end
+      scard(destination)
+    end
+
+    private
+    def with_set_at(key, &blk)
+      with_thing_at(key, :assert_sety, proc {Set.new}, &blk)
+    end
+
+    def with_sets_at(*keys, &blk)
+      if keys.length == 1
+        with_set_at(keys.first, &blk)
+      else
+        with_set_at(keys.first) do |set|
+          with_sets_at(*(keys[1..-1])) do |*sets|
+            blk.call(*([set] + sets))
+          end
+        end
+      end
+    end
+
+    def sety?(key)
+      data[key].nil? || data[key].kind_of?(Set)
+    end
+
+    def assert_sety(key)
+      unless sety?(key)
+        # Not the most helpful error, but it's what redis-rb barfs up
+        raise RuntimeError, "ERR Operation against a key holding the wrong kind of value"
+      end
+    end
+
+  end
+end

data/spec/mock_redis/lib/mock_redis/string_methods.rb

@@ -0,0 +1,203 @@
+require 'mock_redis/assertions'
+
+class MockRedis
+  module StringMethods
+    include Assertions
+
+    def append(key, value)
+      assert_stringy(key)
+      data[key] ||= ""
+      data[key] << value
+      data[key].length
+    end
+
+    def decr(key)
+      decrby(key, 1)
+    end
+
+    def decrby(key, n)
+      incrby(key, -n)
+    end
+
+    def get(key)
+      assert_stringy(key)
+      data[key]
+    end
+
+    def [](key)
+      get(key)
+    end
+
+    def getbit(key, offset)
+      assert_stringy(key)
+
+      offset_of_byte = offset / 8
+      offset_within_byte = offset % 8
+
+      # String#getbyte would be lovely, but it's not in 1.8.7.
+      byte = (data[key] || "").each_byte.drop(offset_of_byte).first
+
+      if byte
+        (byte & (2**7 >> offset_within_byte)) > 0 ? 1 : 0
+      else
+        0
+      end
+    end
+
+    def getrange(key, start, stop)
+      assert_stringy(key)
+      (data[key] || "")[start..stop]
+    end
+
+    def getset(key, value)
+      retval = get(key)
+      set(key, value)
+      retval
+    end
+
+    def incr(key)
+      incrby(key, 1)
+    end
+
+    def incrby(key, n)
+      assert_stringy(key)
+      unless can_incr?(data[key])
+        raise RuntimeError, "ERR value is not an integer or out of range"
+      end
+
+      unless looks_like_integer?(n.to_s)
+        raise RuntimeError, "ERR value is not an integer or out of range"
+      end
+
+      new_value = data[key].to_i + n.to_i
+      data[key] = new_value.to_s
+      # for some reason, redis-rb doesn't return this as a string.
+      new_value
+    end
+
+    def mget(*keys)
+      assert_has_args(keys, 'mget')
+
+      keys.map do |key|
+        get(key) if stringy?(key)
+      end
+    end
+
+    def mset(*kvpairs)
+      assert_has_args(kvpairs, 'mset')
+      if kvpairs.length.odd?
+        raise RuntimeError, "ERR wrong number of arguments for MSET"
+      end
+
+      kvpairs.each_slice(2) do |(k,v)|
+        set(k,v)
+      end
+
+      "OK"
+    end
+
+    def msetnx(*kvpairs)
+      assert_has_args(kvpairs, 'msetnx')
+
+      if kvpairs.each_slice(2).any? {|(k,v)| exists(k)}
+        0
+      else
+        mset(*kvpairs)
+        1
+      end
+    end
+
+    def set(key, value)
+      data[key] = value.to_s
+      'OK'
+    end
+
+    def []=(key, value)
+      set(key, value)
+    end
+
+    def setbit(key, offset, value)
+      assert_stringy(key, "ERR bit is not an integer or out of range")
+      retval = getbit(key, offset)
+
+      str = data[key] || ""
+
+      offset_of_byte = offset / 8
+      offset_within_byte = offset % 8
+
+      if offset_of_byte >= str.bytesize
+        str = zero_pad(str, offset_of_byte+1)
+      end
+
+      char_index = byte_index = offset_within_char = 0
+      str.each_char do |c|
+        if byte_index < offset_of_byte
+          char_index += 1
+          byte_index += c.bytesize
+        else
+          offset_within_char = byte_index - offset_of_byte
+          break
+        end
+      end
+
+      char = str[char_index]
+      char = char.chr if char.respond_to?(:chr)  # ruby 1.8 vs 1.9
+      char_as_number = char.each_byte.reduce(0) do |a, byte|
+        (a << 8) + byte
+      end
+      char_as_number |=
+        (2**((char.bytesize * 8)-1) >>
+        (offset_within_char * 8 + offset_within_byte))
+      str[char_index] = char_as_number.chr
+
+      data[key] = str
+      retval
+    end
+
+    def setex(key, seconds, value)
+      set(key, value)
+      expire(key, seconds)
+      'OK'
+    end
+
+    def setnx(key, value)
+      if exists(key)
+        false
+      else
+        set(key, value)
+        true
+      end
+    end
+
+    def setrange(key, offset, value)
+      assert_stringy(key)
+      value = value.to_s
+      old_value = (data[key] || "")
+
+      prefix = zero_pad(old_value[0...offset], offset)
+      data[key] = prefix + value + (old_value[(offset + value.length)..-1] || "")
+      data[key].length
+    end
+
+    def strlen(key)
+      assert_stringy(key)
+      (data[key] || "").bytesize
+    end
+
+
+
+
+    private
+    def stringy?(key)
+      data[key].nil? || data[key].kind_of?(String)
+    end
+
+    def assert_stringy(key,
+        message="ERR Operation against a key holding the wrong kind of value")
+      unless stringy?(key)
+        raise RuntimeError, message
+      end
+    end
+
+  end
+end

data/spec/mock_redis/lib/mock_redis/transaction_wrapper.rb

@@ -0,0 +1,80 @@
+require 'mock_redis/undef_redis_methods'
+
+class MockRedis
+  class TransactionWrapper
+    include UndefRedisMethods
+
+    def respond_to?(method, include_private=false)
+      super || @db.respond_to?(method)
+    end
+
+    def initialize(db)
+      @db = db
+      @queued_commands = []
+      @in_multi = false
+    end
+
+    def method_missing(method, *args)
+      if @in_multi
+        @queued_commands << [method, *args]
+        'QUEUED'
+      else
+        @db.expire_keys
+        @db.send(method, *args)
+      end
+    end
+
+    def initialize_copy(source)
+      super
+      @db = @db.clone
+      @queued_commands = @queued_commands.clone
+    end
+
+    def discard
+      unless @in_multi
+        raise RuntimeError, "ERR DISCARD without MULTI"
+      end
+      @in_multi = false
+      @queued_commands = []
+      'OK'
+    end
+
+    def exec
+      unless @in_multi
+        raise RuntimeError, "ERR EXEC without MULTI"
+      end
+      @in_multi = false
+      responses = @queued_commands.map do |cmd|
+        begin
+          send(*cmd)
+        rescue => e
+          e
+        end
+      end
+      @queued_commands = []
+      responses
+    end
+
+    def multi
+      if @in_multi
+        raise RuntimeError, "ERR MULTI calls can not be nested"
+      end
+      @in_multi = true
+      if block_given?
+        yield(self)
+        self.exec
+      else
+        'OK'
+      end
+    end
+
+    def unwatch
+      'OK'
+    end
+
+    def watch(_)
+      'OK'
+    end
+
+  end
+end

data/spec/mock_redis/lib/mock_redis/undef_redis_methods.rb

@@ -0,0 +1,11 @@
+class MockRedis
+  module UndefRedisMethods
+    def self.included(klass)
+      if klass.instance_methods.map(&:to_s).include?('type')
+        klass.send(:undef_method, 'type')
+      end
+      klass.send(:undef_method, 'exec')
+      klass.send(:undef_method, 'select')
+    end
+  end
+end

data/spec/mock_redis/lib/mock_redis/utility_methods.rb

@@ -0,0 +1,25 @@
+class MockRedis
+  module UtilityMethods
+    private
+
+    def with_thing_at(key, assertion, empty_thing_generator)
+      begin
+        send(assertion, key)
+        data[key] ||= empty_thing_generator.call
+        data_key_ref = data[key]
+        ret = yield data[key]
+        data[key] = data_key_ref if data[key].nil?
+        ret
+      ensure
+        clean_up_empties_at(key)
+      end
+    end
+
+    def clean_up_empties_at(key)
+      if data[key] && data[key].empty?
+        del(key)
+      end
+    end
+
+  end
+end

data/spec/mock_redis/lib/mock_redis/version.rb

@@ -0,0 +1,3 @@
+class MockRedis
+  VERSION = '0.4.1'
+end