memcache-client 1.2.1 → 1.3.0

data/History.txt

@@ -1,3 +1,19 @@
+= 1.3.0
+
+* Apply patch #6507, add stats command.  Submitted by Tyler Kovacs.
+* Apply patch #6509, parallel implementation of #get_multi.  Submitted
+  by Tyler Kovacs.
+* Validate keys.  Disallow spaces in keys or keys that are too long.
+* Perform more validation of server responses.  MemCache now reports
+  errors if the socket was not in an expected state.  (Please file
+  bugs if you find some.)
+* Add #incr and #decr.
+* Add raw argument to #set and #get to retrieve #incr and #decr
+  values.
+* Also put on MemCacheError when using Cache::get with block.
+* memcache.rb no longer sets $TESTING to a true value if it was
+  previously defined.  Bug #8213 by Matijs van Zuijlen.
+
 = 1.2.1
 
 * Fix bug #7048, MemCache#servers= referenced changed local variable.

data/LICENSE.txt

@@ -1,5 +1,5 @@
-All original code copyright 2005, 2006 Bob Cottrell, Eric Hodel, The
-Robot Co-op.  All rights reserved.
+All original code copyright 2005, 2006, 2007 Bob Cottrell, Eric Hodel,
+The Robot Co-op.  All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
@@ -13,8 +13,6 @@ are met:
 3. Neither the names of the authors nor the names of their contributors
    may be used to endorse or promote products derived from this software
    without specific prior written permission.
-4. Redistribution in Rails or any sub-projects of Rails is not allowed
-   until Rails runs without warnings with the ``-w'' flag enabled.
 
 THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
 OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

data/README.txt

@@ -4,9 +4,13 @@ Rubyforge Project:
 
 http://rubyforge.org/projects/rctools/
 
+File bugs:
+
+http://rubyforge.org/tracker/?func=add&group_id=1513&atid=5921
+
 == About
 
-memcache-client is a fast memcached client.
+memcache-client is a client for Danga Interactive's memcached.
 
 == Installing memcache-client
 
@@ -30,14 +34,14 @@ See MemCache.new for details.
 === Using memcache-client with Rails
 
 Rails will automatically load the memcache-client gem, but you may
-need to uninstall Ruby-memcache, I don't know which one it will pick
-by default.
+need to uninstall Ruby-memcache, I don't know which one will get
+picked by default.
 
 Add your environment-specific caches to config/environment/*.  If you run both
-development and production on the same machine be sure to use different
-namespaces.  Be careful when running tests using memcache, you may get strange
-results.  It will be less of a headache to simply use a readonly memcache when
-testing.
+development and production on the same memcached server sets, be sure
+to use different namespaces.  Be careful when running tests using
+memcache, you may get strange results.  It will be less of a headache
+to simply use a readonly memcache when testing.
 
 memcache-client also comes with a wrapper called Cache in memcache_util.rb for
 use with Rails.  To use it be sure to assign your memcache connection to

data/lib/memcache.rb

@@ -1,4 +1,4 @@
-$TESTING = defined? $TESTING
+$TESTING = defined? $TESTING && $TESTING
 
 require 'socket'
 require 'thread'
@@ -34,14 +34,15 @@ end
 # A Ruby client library for memcached.
 #
 # This is intended to provide access to basic memcached functionality.  It
-# does not attempt to be complete implementation of the entire API.
+# does not attempt to be complete implementation of the entire API, but it is
+# approaching a complete implementation.
 
 class MemCache
 
   ##
   # The version of MemCache you are using.
 
-  VERSION = '1.2.1'
+  VERSION = '1.3.0'
 
   ##
   # Default options for the cache object.
@@ -82,12 +83,14 @@ class MemCache
   ##
   # Accepts a list of +servers+ and a list of +opts+.  +servers+ may be
   # omitted.  See +servers=+ for acceptable server list arguments.
-  # 
+  #
   # Valid options for +opts+ are:
   #
   #   [:namespace]   Prepends this value to all keys added or retrieved.
   #   [:readonly]    Raises an exeception on cache writes when true.
   #   [:multithread] Wraps cache access in a Mutex for thread safety.
+  #
+  # Other options are ignored.
 
   def initialize(*args)
     servers = []
@@ -119,11 +122,11 @@ class MemCache
   end
 
   ##
-  # Return a string representation of the cache object.
+  # Returns a string representation of the cache object.
 
   def inspect
-    sprintf("<MemCache: %s servers, %s buckets, ns: %p, ro: %p>",
-            @servers.length, @buckets.length, @namespace, @readonly)
+    "<MemCache: %d servers, %d buckets, ns: %p, ro: %p>" %
+      [@servers.length, @buckets.length, @namespace, @readonly]
   end
 
   ##
@@ -134,7 +137,7 @@ class MemCache
   end
 
   ##
-  # Returns whether the cache was created read only.
+  # Returns whether or not the cache object was created read only.
 
   def readonly?
     @readonly
@@ -172,14 +175,28 @@ class MemCache
   end
 
   ##
-  # Retrieves +key+ from memcache.
+  # Deceremets the value for +key+ by +amount+ and returns the new value.
+  # +key+ must already exist.  If +key+ is not an integer, it is assumed to be
+  # 0.  +key+ can not be decremented below 0.
 
-  def get(key)
-    raise MemCacheError, 'No active servers' unless active?
-    cache_key = make_cache_key key
-    server = get_server_for_key cache_key
+  def decr(key, amount = 1)
+    server, cache_key = request_setup key
 
-    raise MemCacheError, 'No connection to server' if server.socket.nil?
+    if @multithread then
+      threadsafe_cache_decr server, cache_key, amount
+    else
+      cache_decr server, cache_key, amount
+    end
+  rescue TypeError, SocketError, SystemCallError, IOError => err
+    handle_error server, err
+  end
+
+  ##
+  # Retrieves +key+ from memcache.  If +raw+ is false, the value will be
+  # unmarshalled.
+
+  def get(key, raw = false)
+    server, cache_key = request_setup key
 
     value = if @multithread then
               threadsafe_cache_get server, cache_key
@@ -189,51 +206,102 @@ class MemCache
 
     return nil if value.nil?
 
-    # Return the unmarshaled value.
-    return Marshal.load(value)
-  rescue ArgumentError, TypeError, SystemCallError, IOError => err
-    server.close
-    new_err = MemCacheError.new err.message
-    new_err.set_backtrace err.backtrace
-    raise new_err
+    value = Marshal.load value unless raw
+
+    return value
+  rescue TypeError, SocketError, SystemCallError, IOError => err
+    handle_error server, err
   end
 
   ##
-  # Retrieves +keys+ and returns a Hash mapping keys to values.
+  # Retrieves multiple values from memcached in parallel, if possible.
+  #
+  # The memcached protocol supports the ability to retrieve multiple
+  # keys in a single request.  Pass in an array of keys to this method
+  # and it will:
+  #
+  # 1. map the key to the appropriate memcached server
+  # 2. send a single request to each server that has one or more key values
+  #
+  # Returns a hash of values.
+  #
+  #   cache["a"] = 1
+  #   cache["b"] = 2
+  #   cache.get_multi "a", "b" # => { "a" => 1, "b" => 2 }
 
   def get_multi(*keys)
-    values = {}
-    keys.flatten.each { |key| values[key] = get key }
-    values
+    raise MemCacheError, 'No active servers' unless active?
+
+    keys.flatten!
+    key_count = keys.length
+    cache_keys = {}
+    server_keys = Hash.new { |h,k| h[k] = [] }
+
+    # map keys to servers
+    keys.each do |key|
+      server, cache_key = request_setup key
+      cache_keys[cache_key] = key
+      server_keys[server] << cache_key
+    end
+
+    results = {}
+
+    server_keys.each do |server, keys|
+      keys = keys.join ' '
+      values = if @multithread then
+                 threadsafe_cache_get_multi server, keys
+               else
+                 cache_get_multi server, keys
+               end
+      values.each do |key, value|
+        results[cache_keys[key]] = Marshal.load value
+      end
+    end
+
+    return results
+  rescue TypeError, SocketError, SystemCallError, IOError => err
+    handle_error server, err
   end
 
   ##
-  # Add +key+ to the cache with value +value+ that expires in +expiry+
-  # seconds.
+  # Increments the value for +key+ by +amount+ and retruns the new value.
+  # +key+ must already exist.  If +key+ is not an integer, it is assumed to be
+  # 0.
 
-  def set(key, value, expiry = 0)
-    @mutex.lock if @multithread
+  def incr(key, amount = 1)
+    server, cache_key = request_setup key
 
-    raise MemCacheError, "No active servers" unless self.active?
-    raise MemCacheError, "Update of readonly cache" if @readonly
-    cache_key = make_cache_key(key)
-    server = get_server_for_key(cache_key)
+    if @multithread then
+      threadsafe_cache_incr server, cache_key, amount
+    else
+      cache_incr server, cache_key, amount
+    end
+  rescue TypeError, SocketError, SystemCallError, IOError => err
+    handle_error server, err
+  end
 
-    sock = server.socket
-    raise MemCacheError, "No connection to server" if sock.nil?
+  ##
+  # Add +key+ to the cache with value +value+ that expires in +expiry+
+  # seconds.  If +raw+ is true, +value+ will not be Marshalled.
 
-    marshaled_value = Marshal.dump value
-    command = "set #{cache_key} 0 #{expiry} #{marshaled_value.size}\r\n#{marshaled_value}\r\n"
+  def set(key, value, expiry = 0, raw = false)
+    raise MemCacheError, "Update of readonly cache" if @readonly
+    server, cache_key = request_setup key
+    socket = server.socket
+
+    value = Marshal.dump value unless raw
+    command = "set #{cache_key} 0 #{expiry} #{value.size}\r\n#{value}\r\n"
 
     begin
-      sock.write command
-      sock.gets
-    rescue SystemCallError, IOError => err
+      @mutex.lock if @multithread
+      socket.write command
+      socket.gets
+    rescue SocketError, SystemCallError, IOError => err
       server.close
       raise MemCacheError, err.message
+    ensure
+      @mutex.unlock if @multithread
     end
-  ensure
-    @mutex.unlock if @multithread
   end
 
   ##
@@ -252,7 +320,7 @@ class MemCache
     begin
       sock.write "delete #{cache_key} #{expiry}\r\n"
       sock.gets
-    rescue SystemCallError, IOError => err
+    rescue SocketError, SystemCallError, IOError => err
       server.close
       raise MemCacheError, err.message
     end
@@ -269,6 +337,65 @@ class MemCache
     @servers.each { |server| server.close }
   end
 
+  ##
+  # Returns statistics for each memcached server.  An explanation of the
+  # statistics can be found in the memcached docs:
+  #
+  # http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt
+  #
+  # Example:
+  #
+  #   >> pp CACHE.stats
+  #   {"localhost:11211"=>
+  #     {"bytes"=>"4718",
+  #      "pid"=>"20188",
+  #      "connection_structures"=>"4",
+  #      "time"=>"1162278121",
+  #      "pointer_size"=>"32",
+  #      "limit_maxbytes"=>"67108864",
+  #      "cmd_get"=>"14532",
+  #      "version"=>"1.2.0",
+  #      "bytes_written"=>"432583",
+  #      "cmd_set"=>"32",
+  #      "get_misses"=>"0",
+  #      "total_connections"=>"19",
+  #      "curr_connections"=>"3",
+  #      "curr_items"=>"4",
+  #      "uptime"=>"1557",
+  #      "get_hits"=>"14532",
+  #      "total_items"=>"32",
+  #      "rusage_system"=>"0.313952",
+  #      "rusage_user"=>"0.119981",
+  #      "bytes_read"=>"190619"}}
+  #   => nil
+
+  def stats
+    raise MemCacheError, "No active servers" unless active?
+    server_stats = {}
+
+    @servers.each do |server|
+      sock = server.socket
+      raise MemCacheError, "No connection to server" if sock.nil?
+
+      value = nil
+      begin
+        sock.write "stats\r\n"
+        stats = {}
+        while line = sock.gets
+          break if line == "END\r\n"
+          line =~ /^STAT ([\w]+) ([\d.]+)/
+          stats[$1] = $2
+        end
+        server_stats["#{server.host}:#{server.port}"] = stats.clone
+      rescue SocketError, SystemCallError, IOError => err
+        server.close
+        raise MemCacheError, err.message
+      end
+    end
+
+    server_stats
+  end
+
   ##
   # Shortcut to get a value from the cache.
 
@@ -300,6 +427,9 @@ class MemCache
   # Pick a server to handle the request based on a hash of the key.
 
   def get_server_for_key(key)
+    raise ArgumentError, "illegal character in key #{key.inspect}" if
+      key =~ /\s/
+    raise ArgumentError, "key too long #{key.inspect}" if key.length > 250
     raise MemCacheError, "No servers available" if @servers.empty?
     return @servers.first if @servers.length == 1
 
@@ -322,6 +452,18 @@ class MemCache
     (key.crc32_ITU_T >> 16) & 0x7fff
   end
 
+  ##
+  # Performs a raw decr for +cache_key+ from +server+.  Returns nil if not
+  # found.
+
+  def cache_decr(server, cache_key, amount)
+    socket = server.socket
+    socket.write "decr #{cache_key} #{amount}\r\n"
+    text = socket.gets
+    return nil if text == "NOT_FOUND\r\n"
+    return text.to_i
+  end
+
   ##
   # Fetches the raw data for +cache_key+ from +server+.  Returns nil on cache
   # miss.
@@ -329,19 +471,99 @@ class MemCache
   def cache_get(server, cache_key)
     socket = server.socket
     socket.write "get #{cache_key}\r\n"
-    text = socket.gets # "VALUE <key> <flags> <bytes>\r\n"
-    return nil if text == "END\r\n"
+    keyline = socket.gets # "VALUE <key> <flags> <bytes>\r\n"
+    return nil if keyline == "END\r\n"
 
-    text =~ /(\d+)\r/
+    unless keyline =~ /(\d+)\r/ then
+      server.close
+      raise MemCacheError, "unexpected response #{keyline.inspect}"
+    end
     value = socket.read $1.to_i
     socket.read 2 # "\r\n"
     socket.gets   # "END\r\n"
     return value
   end
 
-  def threadsafe_cache_get(socket, cache_key) # :nodoc:
+  ##
+  # Fetches +cache_keys+ from +server+ using a multi-get.
+
+  def cache_get_multi(server, cache_keys)
+    values = {}
+    socket = server.socket
+    socket.write "get #{cache_keys}\r\n"
+
+    while keyline = socket.gets
+      break if keyline == "END\r\n"
+      unless keyline =~ /^VALUE (.+) (.+) (.+)/ then
+        server.close
+        raise MemCacheError, "unexpected response #{keyline.inspect}"
+      end
+      key, data_length = $1, $3
+      values[$1] = socket.read data_length.to_i
+      socket.read(2) # "\r\n"
+    end
+
+    return values
+  end
+
+  ##
+  # Performs a raw incr for +cache_key+ from +server+.  Returns nil if not
+  # found.
+
+  def cache_incr(server, cache_key, amount)
+    socket = server.socket
+    socket.write "incr #{cache_key} #{amount}\r\n"
+    text = socket.gets
+    return nil if text == "NOT_FOUND\r\n"
+    return text.to_i
+  end
+
+  ##
+  # Handles +error+ from +server+.
+
+  def handle_error(server, error)
+    server.close if server
+    new_error = MemCacheError.new error.message
+    new_error.set_backtrace error.backtrace
+    raise new_error
+  end
+
+  ##
+  # Performs setup for making a request with +key+ from memcached.  Returns
+  # the server to fetch the key from and the complete key to use.
+
+  def request_setup(key)
+    raise MemCacheError, 'No active servers' unless active?
+    cache_key = make_cache_key key
+    server = get_server_for_key cache_key
+    raise MemCacheError, 'No connection to server' if server.socket.nil?
+    return server, cache_key
+  end
+
+  def threadsafe_cache_decr(server, cache_key, amount) # :nodoc:
+    @mutex.lock
+    cache_decr server, cache_key, amount
+  ensure
+    @mutex.unlock
+  end
+
+  def threadsafe_cache_get(server, cache_key) # :nodoc:
+    @mutex.lock
+    cache_get server, cache_key
+  ensure
+    @mutex.unlock
+  end
+
+  def threadsafe_cache_get_multi(socket, cache_key) # :nodoc:
+    @mutex.lock
+    cache_get_multi socket, cache_key
+  ensure
+    @mutex.unlock
+  end
+
+  def threadsafe_cache_incr(server, cache_key, amount) # :nodoc:
     @mutex.lock
-    cache_get socket, cache_key
+    cache_incr server, cache_key, amount
   ensure
     @mutex.unlock
   end
@@ -414,8 +636,7 @@ class MemCache
     # Return a string representation of the server object.
 
     def inspect
-      sprintf("<MemCache::Server: %s:%d [%d] (%s)>",
-              @host, @port, @weight, @status)
+      "<MemCache::Server: %s:%d [%d] (%s)>" % [@host, @port, @weight, @status]
     end
 
     ##
@@ -425,7 +646,7 @@ class MemCache
     # been exceeded.
 
     def alive?
-      !self.socket.nil?
+      !!socket
     end
 
     ##

data/lib/memcache_util.rb

@@ -14,20 +14,25 @@ module Cache
 
   def self.get(key, expiry = 0)
     start_time = Time.now
-    result = CACHE.get key
+    value = CACHE.get key
     elapsed = Time.now - start_time
     ActiveRecord::Base.logger.debug('MemCache Get (%0.6f)  %s' % [elapsed, key])
-    if result.nil? and block_given? then
+    if value.nil? and block_given? then
       value = yield
       put key, value, expiry
     end
-    return result
+    value
   rescue MemCache::MemCacheError => err
     ActiveRecord::Base.logger.debug "MemCache Error: #{err.message}"
+    if block_given? then
+      value = yield
+      put key, value, expiry
+    end
+    value
   end
 
   ##
-  # Places +value+ in the cache at +key+, with an optional +expiry+ time in
+  # Sets +value+ in the cache at +key+, with an optional +expiry+ time in
   # seconds.
 
   def self.put(key, value, expiry = 0)
@@ -35,8 +40,10 @@ module Cache
     CACHE.set key, value, expiry
     elapsed = Time.now - start_time
     ActiveRecord::Base.logger.debug('MemCache Set (%0.6f)  %s' % [elapsed, key])
+    value
   rescue MemCache::MemCacheError => err
     ActiveRecord::Base.logger.debug "MemCache Error: #{err.message}"
+    nil
   end
 
   ##
@@ -48,8 +55,10 @@ module Cache
     elapsed = Time.now - start_time
     ActiveRecord::Base.logger.debug('MemCache Delete (%0.6f)  %s' %
                                     [elapsed, key])
+    nil
   rescue MemCache::MemCacheError => err
     ActiveRecord::Base.logger.debug "MemCache Error: #{err.message}"
+    nil
   end
 
   ##
@@ -58,6 +67,7 @@ module Cache
   def self.reset
     CACHE.reset
     ActiveRecord::Base.logger.debug 'MemCache Connections Reset'
+    nil
   end
 
 end

data/test/test_mem_cache.rb

@@ -43,9 +43,15 @@ class FakeServer
 
   def initialize(socket = nil)
     @socket = socket || FakeSocket.new
+    @closed = false
   end
 
   def close
+    @closed = true
+  end
+
+  def alive?
+    !@closed
   end
 
 end
@@ -66,6 +72,26 @@ class TestMemCache < Test::Unit::TestCase
                  server.socket.written.string
   end
 
+  def test_cache_get_bad_state
+    server = FakeServer.new
+    server.socket.data.write "bogus response\r\n"
+    server.socket.data.rewind
+
+    @cache.servers = []
+    @cache.servers << server
+
+    e = assert_raise MemCache::MemCacheError do
+      @cache.cache_get(server, 'my_namespace:key')
+    end
+
+    assert_equal "unexpected response \"bogus response\\r\\n\"", e.message
+
+    deny server.alive?
+
+    assert_equal "get my_namespace:key\r\n",
+                 server.socket.written.string
+  end
+
   def test_cache_get_miss
     socket = FakeSocket.new
     socket.data.write "END\r\n"
@@ -78,6 +104,26 @@ class TestMemCache < Test::Unit::TestCase
                  socket.written.string
   end
 
+  def test_cache_get_multi_bad_state
+    server = FakeServer.new
+    server.socket.data.write "bogus response\r\n"
+    server.socket.data.rewind
+
+    @cache.servers = []
+    @cache.servers << server
+
+    e = assert_raise MemCache::MemCacheError do
+      @cache.cache_get_multi(server, ['my_namespace:key'])
+    end
+
+    assert_equal "unexpected response \"bogus response\\r\\n\"", e.message
+
+    deny server.alive?
+
+    assert_equal "get my_namespace:key\r\n",
+                 server.socket.written.string
+  end
+
   def test_crc32_ITU_T
     assert_equal 0, ''.crc32_ITU_T
     assert_equal 1260851911, 'my_namespace:key'.crc32_ITU_T
@@ -140,6 +186,54 @@ class TestMemCache < Test::Unit::TestCase
     end
   end
 
+  def test_decr
+    server = FakeServer.new
+    server.socket.data.write "5\r\n"
+    server.socket.data.rewind
+
+    @cache.servers = []
+    @cache.servers << server
+
+    value = @cache.decr 'key'
+
+    assert_equal "decr my_namespace:key 1\r\n",
+                 @cache.servers.first.socket.written.string
+
+    assert_equal 5, value
+  end
+
+  def test_decr_not_found
+    server = FakeServer.new
+    server.socket.data.write "NOT_FOUND\r\n"
+    server.socket.data.rewind
+
+    @cache.servers = []
+    @cache.servers << server
+
+    value = @cache.decr 'key'
+
+    assert_equal "decr my_namespace:key 1\r\n",
+                 @cache.servers.first.socket.written.string
+
+    assert_equal nil, value
+  end
+
+  def test_decr_space_padding
+    server = FakeServer.new
+    server.socket.data.write "5 \r\n"
+    server.socket.data.rewind
+
+    @cache.servers = []
+    @cache.servers << server
+
+    value = @cache.decr 'key'
+
+    assert_equal "decr my_namespace:key 1\r\n",
+                 @cache.servers.first.socket.written.string
+
+    assert_equal 5, value
+  end
+
   def test_get
     util_setup_fake_server
 
@@ -151,6 +245,14 @@ class TestMemCache < Test::Unit::TestCase
     assert_equal '0123456789', value
   end
 
+  def test_get_bad_key
+    util_setup_fake_server
+    assert_raise ArgumentError do @cache.get 'k y' end
+
+    util_setup_fake_server
+    assert_raise ArgumentError do @cache.get 'k' * 250 end
+  end
+
   def test_get_cache_get_IOError
     socket = Object.new
     def socket.write(arg) raise IOError, 'some io error'; end
@@ -200,15 +302,44 @@ class TestMemCache < Test::Unit::TestCase
   end
 
   def test_get_multi
-    util_setup_fake_server
+    server = FakeServer.new
+    server.socket.data.write "VALUE my_namespace:key 0 14\r\n"
+    server.socket.data.write "\004\b\"\0170123456789\r\n"
+    server.socket.data.write "VALUE my_namespace:keyb 0 14\r\n"
+    server.socket.data.write "\004\b\"\0179876543210\r\n"
+    server.socket.data.write "END\r\n"
+    server.socket.data.rewind
+
+    @cache.servers = []
+    @cache.servers << server
+
+    values = @cache.get_multi 'key', 'keyb'
+
+    assert_equal "get my_namespace:key my_namespace:keyb\r\n",
+                 server.socket.written.string
+
+    expected = { 'key' => '0123456789', 'keyb' => '9876543210' }
+
+    assert_equal expected.sort, values.sort
+  end
+
+  def test_get_raw
+    server = FakeServer.new
+    server.socket.data.write "VALUE my_namespace:key 0 10\r\n"
+    server.socket.data.write "0123456789\r\n"
+    server.socket.data.write "END\r\n"
+    server.socket.data.rewind
+
+    @cache.servers = []
+    @cache.servers << server
 
-    values = @cache.get_multi 'keya', 'keyb'
 
-    assert_equal "get my_namespace:keya\r\nget my_namespace:keyb\r\n",
+    value = @cache.get 'key', true
+
+    assert_equal "get my_namespace:key\r\n",
                  @cache.servers.first.socket.written.string
 
-    expected = { 'keya' => '0123456789', 'keyb' => nil }
-    assert_equal expected, values
+    assert_equal '0123456789', value
   end
 
   def test_get_server_for_key
@@ -239,6 +370,70 @@ class TestMemCache < Test::Unit::TestCase
     assert_equal 'No servers available', e.message
   end
 
+  def test_get_server_for_key_spaces
+    e = assert_raise ArgumentError do
+      @cache.get_server_for_key 'space key'
+    end
+    assert_equal 'illegal character in key "space key"', e.message
+  end
+
+  def test_get_server_for_key_length
+    @cache.get_server_for_key 'x' * 250
+    long_key = 'x' * 251
+    e = assert_raise ArgumentError do
+      @cache.get_server_for_key long_key
+    end
+    assert_equal "key too long #{long_key.inspect}", e.message
+  end
+
+  def test_incr
+    server = FakeServer.new
+    server.socket.data.write "5\r\n"
+    server.socket.data.rewind
+
+    @cache.servers = []
+    @cache.servers << server
+
+    value = @cache.incr 'key'
+
+    assert_equal "incr my_namespace:key 1\r\n",
+                 @cache.servers.first.socket.written.string
+
+    assert_equal 5, value
+  end
+
+  def test_incr_not_found
+    server = FakeServer.new
+    server.socket.data.write "NOT_FOUND\r\n"
+    server.socket.data.rewind
+
+    @cache.servers = []
+    @cache.servers << server
+
+    value = @cache.incr 'key'
+
+    assert_equal "incr my_namespace:key 1\r\n",
+                 @cache.servers.first.socket.written.string
+
+    assert_equal nil, value
+  end
+
+  def test_incr_space_padding
+    server = FakeServer.new
+    server.socket.data.write "5 \r\n"
+    server.socket.data.rewind
+
+    @cache.servers = []
+    @cache.servers << server
+
+    value = @cache.incr 'key'
+
+    assert_equal "incr my_namespace:key 1\r\n",
+                 @cache.servers.first.socket.written.string
+
+    assert_equal 5, value
+  end
+
   def test_make_cache_key
     assert_equal 'my_namespace:key', @cache.make_cache_key('key')
     @cache.namespace = nil
@@ -253,6 +448,72 @@ class TestMemCache < Test::Unit::TestCase
     assert_equal 'cannot convert Object into MemCache::Server', e.message
   end
 
+  def test_set
+    server = FakeServer.new
+    server.socket.data.write "STORED\r\n"
+    server.socket.data.rewind
+    @cache.servers = []
+    @cache.servers << server
+
+    @cache.set 'key', 'value'
+
+    expected = "set my_namespace:key 0 0 9\r\n\004\b\"\nvalue\r\n"
+    assert_equal expected, server.socket.written.string
+  end
+
+  def test_set_expiry
+    server = FakeServer.new
+    server.socket.data.write "STORED\r\n"
+    server.socket.data.rewind
+    @cache.servers = []
+    @cache.servers << server
+
+    @cache.set 'key', 'value', 5
+
+    expected = "set my_namespace:key 0 5 9\r\n\004\b\"\nvalue\r\n"
+    assert_equal expected, server.socket.written.string
+  end
+
+  def test_set_raw
+    server = FakeServer.new
+    server.socket.data.write "STORED\r\n"
+    server.socket.data.rewind
+    @cache.servers = []
+    @cache.servers << server
+
+    @cache.set 'key', 'value', 0, true
+
+    expected = "set my_namespace:key 0 0 5\r\nvalue\r\n"
+    assert_equal expected, server.socket.written.string
+  end
+
+  def test_set_readonly
+    cache = MemCache.new :readonly => true
+
+    e = assert_raise MemCache::MemCacheError do
+      cache.set 'key', 'value'
+    end
+
+    assert_equal 'Update of readonly cache', e.message
+  end
+
+  def test_stats
+    socket = FakeSocket.new
+    socket.data.write "STAT pid 20188\r\nSTAT total_items 32\r\rEND\r\n"
+    socket.data.rewind
+    server = FakeServer.new socket
+    def server.host() "localhost"; end
+    def server.port() 11211; end
+
+    @cache.servers = []
+    @cache.servers << server
+
+    expected = {"localhost:11211"=>{"pid"=>"20188", "total_items"=>"32"}}
+    assert_equal expected, @cache.stats
+
+    assert_equal "stats\r\n", socket.written.string
+  end
+
   def test_basic_threaded_operations_should_work
     cache = MemCache.new :multithread => true,
                          :namespace => 'my_namespace',
@@ -276,10 +537,10 @@ class TestMemCache < Test::Unit::TestCase
       cache.set "test", "test value"
     end
   end
- 
+
   def util_setup_fake_server
     server = FakeServer.new
-    server.socket.data.write "VALUE my_namepsace:key 0 14\r\n"
+    server.socket.data.write "VALUE my_namespace:key 0 14\r\n"
     server.socket.data.write "\004\b\"\0170123456789\r\n"
     server.socket.data.write "END\r\n"
     server.socket.data.rewind

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0.7
+rubygems_version: 0.9.2
 specification_version: 1
 name: memcache-client
 version: !ruby/object:Gem::Version 
-  version: 1.2.1
-date: 2006-12-06 00:00:00 -08:00
+  version: 1.3.0
+date: 2007-03-06 00:00:00 -08:00
 summary: A Ruby memcached client
 require_paths: 
 - lib
@@ -52,20 +52,20 @@ requirements: []
 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: hoe
+  name: ZenTest
   version_requirement: 
   version_requirements: !ruby/object:Gem::Version::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.1.5
+        version: 3.4.2
     version: 
 - !ruby/object:Gem::Dependency 
-  name: ZenTest
+  name: hoe
   version_requirement: 
   version_requirements: !ruby/object:Gem::Version::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 3.4.2
+        version: 1.2.0
     version: