ryansch-mock_redis 0.2.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+Gemfile.lock

data/.rspec

@@ -0,0 +1 @@
+-c -d

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+### 0.2.0
+* Support passing a block to `#multi`.
+
+### 0.1.2
+* Fixes for 1.9.2; no functionality changes.
+
+### 0.1.1
+* Fix handling of -inf, +inf, and exclusive endpoints (e.g. "(3") in
+  zrangebyscore, zrevrangebyscore, and zremrangebyscore. ("Fix" here
+  means "write", as it's something that was completely forgotten the
+  first time around.)
+
+### 0.1.0
+* Support `move(key, db)` to move keys between databases.
+
+### 0.0.2
+* Fix gem homepage.
+
+### 0.0.1
+Initial release.

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in mock_redis.gemspec
+gemspec
+
+group :test do
+  gem "ruby-debug", :platforms => :mri_18
+  gem "ruby-debug19", :platforms => :mri_19
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Philotic, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+# MockRedis
+
+A mock redis gem.
+
+MockRedis provides the same interface as redis-rb, but it stores its
+data in memory instead of talking to a Redis server. It is intended
+for use in tests.
+
+## Getting Started
+
+It's as easy as `require 'mock_redis'; mr = MockRedis.new`. Then you can
+call the same methods on it as you can call on a real `Redis` object.
+
+For example:
+
+    >> require 'mock_redis'
+    >> mr = MockRedis.new
+    >> mr.set('some key', 'some value')
+    => "OK"
+    >> mr.get('some key')
+    => "some value"
+
+## Supported Features
+
+mock_redis supports most of the methods that redis-rb does. Examples
+of supported methods:
+
+* String methods: `get`, `set`, `append`, `incr`, etc.
+* List methods: `lpush`, `lpop`, `lrange`, `rpoplpush`, etc.
+* Set methods: `sadd`, `sinter`, `sismember`, etc.
+* Hash methods: `hset`, `hget`, `hgetall`, `hmget`, etc.
+* Sorted set methods: `zadd`, `zrank`, `zunionstore`, etc.
+* Expirations: `expire`, `ttl`, etc.
+* Transactions: `multi`, `exec`, `discard`
+
+## Mostly-Supported Commands
+
+A MockRedis object can't do everything that a real Redis client can
+since it's an in-memory object confined to a single process. MockRedis
+makes every attempt to be Redis-compatible, but there are some
+necessary exceptions.
+
+* Blocking list commands (`#blpop`, `#brpop`, and `#brpoplpush`) work
+  as expected if there is data for them to retrieve. If you use one of
+  these commands with a nonzero timeout and there is no data for it to
+  retrieve, then the command returns immediately. However, if you ask
+  one of these commands for data with a 0 timeout (means "wait
+  forever") and there is no data available, then a
+  `MockRedis::WouldBlock` exception is raised. It's not what a real
+  Redis client would do, but it beats hanging your test run forever.
+
+* `#info` just returns canned values; they don't update over time.
+
+## Unsupported Commands
+
+Some stuff, we just can't do with a single Ruby object in a single
+Ruby process.
+
+* Debugging commands (`#debug('object', key)` and
+  `#debug('segfault')`) aren't available.
+
+* `#object` isn't available since we don't have any Redis internals to
+  poke at.
+
+* `#monitor` isn't available; there's no place for requests to come
+  from, so there's nothing to receive.
+
+* Pubsub commands (`#psubscribe`, `#publish`, `#punsubscribe`) aren't
+  available.
+
+* `#slowlog` isn't available.
+
+## Remaining Work
+
+There are some things we want to have in here, but that we just
+haven't gotten to doing yet. If you're interested in helping out,
+please submit a pull request with your (tested!) implementation.
+
+* `#config(:get|:set|:resetstat)` isn't done. They can just return
+  canned values.
+
+* `#sort` isn't done. We just haven't gotten to it yet. The input
+  validation will be a pain in the butt, but other than that, it
+  shouldn't be too bad.
+
+## Running the Tests
+
+If you want to work on this, you'll probably want to run the
+tests. (Just kidding! There's no probably about it.) These tests were
+written with Redis 2.2.11 running on localhost without any passwords
+required. If you're using a different version of Redis, you may see
+failures due to error message text being different. If you're running
+a really old version of Redis, you'll definitely see failures due to
+stuff that doesn't work!

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w(-fs --color)
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+task :default => :spec

data/lib/mock_redis.rb

@@ -0,0 +1,32 @@
+require 'set'
+
+require 'mock_redis/assertions'
+require 'mock_redis/database'
+require 'mock_redis/expire_wrapper'
+require 'mock_redis/multi_db_wrapper'
+require 'mock_redis/transaction_wrapper'
+require 'mock_redis/undef_redis_methods'
+
+class MockRedis
+  include UndefRedisMethods
+
+  def initialize(*args)
+    @db = TransactionWrapper.new(
+      ExpireWrapper.new(
+        MultiDbWrapper.new(
+          Database.new(*args))))
+  end
+
+  def respond_to?(method, include_private=false)
+    super || @db.respond_to?(method, include_private)
+  end
+
+  def method_missing(method, *args, &block)
+    @db.send(method, *args, &block)
+  end
+
+  def initialize_copy(source)
+    super
+    @db = @db.clone
+  end
+end

data/lib/mock_redis/assertions.rb

@@ -0,0 +1,13 @@
+class MockRedis
+  module Assertions
+    private
+
+    def assert_has_args(args, command)
+      unless args.any?
+        raise RuntimeError,
+        "ERR wrong number of arguments for '#{command}' command"
+      end
+    end
+      
+  end
+end

data/lib/mock_redis/database.rb

@@ -0,0 +1,432 @@
+require 'mock_redis/assertions'
+require 'mock_redis/exceptions'
+require 'mock_redis/hash_methods'
+require 'mock_redis/list_methods'
+require 'mock_redis/set_methods'
+require 'mock_redis/string_methods'
+require 'mock_redis/zset_methods'
+
+class MockRedis
+  class Database
+    include HashMethods
+    include ListMethods
+    include SetMethods
+    include StringMethods
+    include ZsetMethods
+
+    attr_reader :data, :expire_times
+
+    def initialize(*args)
+      @data = {}
+      @expire_times = []
+    end
+
+    def initialize_copy(source)
+      @data = @data.clone
+      @data.keys.each {|k| @data[k] = @data[k].clone}
+      @expire_times = @expire_times.map{|x| x.clone}
+    end
+
+    # Redis commands go below this line and above 'private'
+
+    def auth(_) 'OK' end
+
+    def bgrewriteaof() "Background append only file rewriting started" end
+
+    def bgsave() "Background saving started" end
+
+    def dbsize
+      data.keys.length
+    end
+
+    def del(*keys)
+      keys.
+        find_all{|key| data[key]}.
+        each {|k| persist(k)}.
+        each {|k| data.delete(k)}.
+        length
+    end
+
+    def echo(msg)
+      msg.to_s
+    end
+
+    def expire(key, seconds)
+      expireat(key, Time.now.to_i + seconds.to_i)
+    end
+
+    def expireat(key, timestamp)
+      unless looks_like_integer?(timestamp.to_s)
+        raise RuntimeError, "ERR value is not an integer or out of range"
+      end
+
+      if exists(key)
+        set_expiration(key, Time.at(timestamp.to_i))
+        true
+      else
+        false
+      end
+    end
+
+    def exists(key)
+      data.has_key?(key)
+    end
+
+    def flushdb
+      data.keys.each {|k| del(k)}
+      'OK'
+    end
+
+    def info
+      astats = [
+        ["2", "2699"],
+        ["6", "1"],
+        ["7", "1"],
+        ["8", "17197"],
+        ["9", "109875"],
+        ["10", "94348"],
+        ["11", "32580"],
+        ["12", "52347"],
+        ["13", "86475"],
+        ["14", "58175"],
+        ["15", "53408"],
+        ["16", "876949"],
+        ["17", "71157"],
+        ["18", "5104"],
+        ["19", "2705"],
+        ["20", "2903"],
+        ["21", "1024"],
+        ["22", "2546"],
+        ["23", "952"],
+        ["24", "186080"],
+        ["25", "611"],
+        ["26", "40936"],
+        ["27", "960"],
+        ["28", "1323"],
+        ["29", "14216"],
+        ["30", "52412"],
+        ["31", "21130"],
+        ["32", "47959"],
+        ["33", "6891"],
+        ["34", "9712"],
+        ["35", "3366"],
+        ["36", "5737"],
+        ["37", "11274"],
+        ["38", "8057"],
+        ["39", "2957"],
+        ["40", "51200"],
+        ["42", "8220"],
+        ["43", "8278"],
+        ["44", "6539"],
+        ["45", "764"],
+        ["47", "1018"],
+        ["48", "19250"],
+        ["49", "713"],
+        ["51", "51"],
+        ["53", "2"],
+        ["55", "3922"],
+        ["56", "153"],
+        ["57", "614"],
+        ["58", "1"],
+        ["59", "1775"],
+        ["61", "32865"],
+        ["63", "2530"],
+        ["64", "565"],
+        ["65", "1322"],
+        ["67", "1572"],
+        ["69", "1421"],
+        ["71", "1220"],
+        ["72", "241"],
+        ["73", "5432"],
+        ["74", "1122"],
+        ["75", "2555"],
+        ["77", "1539"],
+        ["78", "612"],
+        ["79", "902"],
+        ["81", "1678"],
+        ["83", "51"],
+        ["84", "612"],
+        ["85", "706"],
+        ["87", "410"],
+        ["88", "5435"],
+        ["89", "813"],
+        ["90", "612"],
+        ["93", "153"],
+        ["94", "612"],
+        ["96", "159"],
+        ["97", "306"],
+        ["99", "153"],
+        ["101", "456"],
+        ["103", "741"],
+        ["105", "447"],
+        ["107", "754"],
+        ["109", "414"],
+        ["111", "475"],
+        ["113", "757"],
+        ["115", "287"],
+        ["117", "420"],
+        ["118", "765"],
+        ["119", "642"],
+        ["120", "159"],
+        ["121", "926"],
+        ["122", "612"],
+        ["123", "251"],
+        ["125", "390"],
+        ["127", "354"],
+        ["128", "617"],
+        ["129", "528"],
+        ["131", "298"],
+        ["132", "612"],
+        ["133", "809"],
+        ["135", "244"],
+        ["136", "306"],
+        ["137", "504"],
+        ["139", "201"],
+        ["141", "1124"],
+        ["143", "139"],
+        ["144", "159"],
+        ["145", "1322"],
+        ["147", "410"],
+        ["149", "253"],
+        ["151", "304"],
+        ["153", "312"],
+        ["155", "249"],
+        ["157", "306"],
+        ["159", "348"],
+        ["161", "255"],
+        ["163", "458"],
+        ["165", "5"],
+        ["167", "306"],
+        ["168", "47"],
+        ["169", "214"],
+        ["171", "250"],
+        ["173", "5"],
+        ["177", "10"],
+        ["179", "158"],
+        ["181", "5"],
+        ["183", "10"],
+        ["185", "51"],
+        ["187", "49"],
+        ["191", "5"],
+        ["192", "47"],
+        ["193", "51"],
+        ["197", "112"],
+        ["199", "5"],
+        ["201", "5"],
+        ["203", "5"],
+        ["209", "5"],
+        ["213", "51"],
+        ["217", "102"],
+        ["225", "357"],
+        ["229", "51"],
+        ["233", "204"],
+        ["237", "51"],
+        ["239", "1"],
+        ["247", "46"],
+        ["255", "102"],
+        [">=256", "6201"],
+      ]
+
+      {
+        "allocation_stats" => astats.map {|(a,b)| "#{a}=#{b}"}.join(','),
+        "aof_enabled" => "0",
+        "arch_bits" => "64",
+        "bgrewriteaof_in_progress" => "0",
+        "bgsave_in_progress" => "0",
+        "blocked_clients" => "0",
+        "changes_since_last_save" => "0",
+        "client_biggest_input_buf" => "0",
+        "client_longest_output_list" => "0",
+        "connected_clients" => "1",
+        "connected_slaves" => "0",
+        "db0" => "keys=8,expires=0",
+        "evicted_keys" => "0",
+        "expired_keys" => "0",
+        "hash_max_zipmap_entries" => "512",
+        "hash_max_zipmap_value" => "64",
+        "keyspace_hits" => "62645",
+        "keyspace_misses" => "29757",
+        "last_save_time" => "1310596333",
+        "loading" => "0",
+        "lru_clock" => "1036434",
+        "mem_fragmentation_ratio" => "2.04",
+        "multiplexing_api" => "kqueue",
+        "process_id" => "14508",
+        "pubsub_channels" => "0",
+        "pubsub_patterns" => "0",
+        "redis_git_dirty" => "0",
+        "redis_git_sha1" => "00000000",
+        "redis_version" => "2.2.11",
+        "role" => "master",
+        "total_commands_processed" => "196800",
+        "total_connections_received" => "4359",
+        "uptime_in_days" => "0",
+        "uptime_in_seconds" => "84215",
+        "use_tcmalloc" => "0",
+        "used_cpu_sys" => "5.54",
+        "used_cpu_sys_childrens" => "0.00",
+        "used_cpu_user" => "7.65",
+        "used_cpu_user_childrens" => "0.02",
+        "used_memory" => "931456",
+        "used_memory_human" => "909.62K",
+        "used_memory_rss" => "1904640",
+        "vm_enabled" => "0",
+      }
+    end
+
+    def keys(format)
+      data.keys.grep(redis_pattern_to_ruby_regex(format))
+    end
+
+    def lastsave
+      Time.now.to_i
+    end
+
+    def persist(key)
+      if exists(key) && has_expiration?(key)
+        remove_expiration(key)
+        true
+      else
+        false
+      end
+    end
+
+    def ping
+      'PONG'
+    end
+
+    def quit
+      'OK'
+    end
+
+    def randomkey
+      data.keys[rand(data.length)]
+    end
+
+    def rename(key, newkey)
+      if key == newkey
+        raise RuntimeError, "ERR source and destination objects are the same"
+      end
+      data[newkey] = data.delete(key)
+      'OK'
+    end
+
+    def renamenx(key, newkey)
+      if key == newkey
+        raise RuntimeError, "ERR source and destination objects are the same"
+      end
+      if exists(newkey)
+        false
+      else
+        rename(key, newkey)
+        true
+      end
+    end
+
+    def save
+      'OK'
+    end
+
+    def ttl(key)
+      if has_expiration?(key)
+        (expiration(key) - Time.now).to_i
+      else
+        -1
+      end
+    end
+
+    def type(key)
+      if !exists(key)
+        'none'
+      elsif hashy?(key)
+        'hash'
+      elsif stringy?(key)
+        'string'
+      elsif listy?(key)
+        'list'
+      elsif sety?(key)
+        'set'
+      elsif zsety?(key)
+        'zset'
+      else
+        raise ArgumentError, "Not sure how #{data[key].inspect} got in here"
+      end
+    end
+
+    private
+
+    def assert_valid_timeout(timeout)
+      if !looks_like_integer?(timeout.to_s)
+        raise RuntimeError, "ERR timeout is not an integer or out of range"
+      elsif timeout < 0
+        raise RuntimeError, "ERR timeout is negative"
+      end
+      timeout
+    end
+
+    def can_incr?(value)
+      value.nil? || looks_like_integer?(value)
+    end
+
+    def extract_timeout(arglist)
+      timeout = assert_valid_timeout(arglist.last)
+      [arglist[0..-2], arglist.last]
+    end
+
+    def expiration(key)
+      expire_times.find {|(_,k)| k == key}.first
+    end
+
+    def has_expiration?(key)
+      expire_times.any? {|(_,k)| k == key}
+    end
+
+    def looks_like_integer?(str)
+      str =~ /^-?\d+$/
+    end
+
+    def redis_pattern_to_ruby_regex(pattern)
+      Regexp.new(
+        "^#{pattern}$".
+        gsub(/([^\\])\?/, "\\1.").
+        gsub(/([^\\])\*/, "\\1.+"))
+    end
+
+    def remove_expiration(key)
+      expire_times.delete_if do |(t, k)|
+        key == k
+      end
+    end
+
+    def set_expiration(key, time)
+      remove_expiration(key)
+
+      expire_times << [time, key]
+      expire_times.sort! do |a, b|
+        a.first <=> b.first
+      end
+    end
+
+    def zero_pad(string, desired_length)
+      padding = "\000" * [(desired_length - string.length), 0].max
+      string + padding
+    end
+
+    public
+    # This method isn't private, but it also isn't a Redis command, so
+    # it doesn't belong up above with all the Redis commands.
+    def expire_keys
+      now = Time.now
+
+      to_delete = expire_times.take_while do |(time, key)|
+        time <= now
+      end
+
+      to_delete.each do |(time, key)|
+        del(key)
+      end
+
+      expire_times.slice!(0, to_delete.length)
+    end
+  end
+end