Ruby-MemCache 0.0.1

data/test.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/ruby
+#
+#	Test suite for Arrow
+#
+#
+
+BEGIN {
+	basedir = File::dirname( File::expand_path(__FILE__) )
+	$LOAD_PATH.unshift "#{basedir}/lib", "#{basedir}/tests"
+
+	require "#{basedir}/utils"
+	include UtilityFunctions
+}
+
+verboseOff {
+	require 'mctestcase'
+	require 'find'
+	require 'test/unit'
+	require 'test/unit/testsuite'
+	require 'test/unit/ui/console/testrunner'
+	require 'optparse'
+}
+
+# Turn off output buffering
+$stderr.sync = $stdout.sync = true
+$DebugPattern = nil
+$Memcached = true
+
+# Initialize variables
+safelevel = 0
+patterns = []
+requires = []
+
+# Parse command-line switches
+ARGV.options {|oparser|
+	oparser.banner = "Usage: #$0 [options] [TARGETS]\n"
+
+	oparser.on( "--debug[=PATTERN]", "-d[=PATTERN]", String,
+		"Turn debugging on (for tests which match PATTERN)" ) {|arg|
+		if arg
+			if $DebugPattern
+				$DebugPattern = Regexp::union( $DebugPattern, Regexp::new(arg) )
+			else
+				$DebugPattern = Regexp::new( arg )
+			end
+			puts "Turned debugging on for %p." % $DebugPattern
+		else
+			$DEBUG = true
+			debugMsg "Turned debugging on globally."
+		end
+	}
+
+	oparser.on( "--verbose", "-v", TrueClass, "Make progress verbose" ) {
+		$VERBOSE = true
+		debugMsg "Turned verbose on."
+	}
+
+	oparser.on( "--no-memcached", "-n", TrueClass,
+		"Skip the tests which require a running memcached." ) {
+		$Memcached = false
+		debugMsg "Skipping memcached-based tests"
+	}
+
+	# Handle the 'help' option
+	oparser.on( "--help", "-h", "Display this text." ) {
+		$stderr.puts oparser
+		exit!(0)
+	}
+
+	oparser.parse!
+}
+
+# Parse test patterns
+ARGV.each {|pat| patterns << Regexp::new( pat, Regexp::IGNORECASE )}
+$stderr.puts "#{patterns.length} patterns given on the command line"
+
+### Load all the tests from the tests dir
+Find.find("tests") {|file|
+	Find.prune if /\/\./ =~ file or /~$/ =~ file
+	Find.prune if /TEMPLATE/ =~ file
+	next if File.stat( file ).directory?
+
+ 	unless patterns.empty?
+ 		Find.prune unless patterns.find {|pat| pat =~ file}
+ 	end
+
+	debugMsg "Considering '%s': " % file
+	next unless file =~ /\.tests.rb$/
+	debugMsg "Requiring '%s'..." % file
+	require "#{file}"
+	requires << file
+}
+
+$stderr.puts "Required #{requires.length} files."
+unless patterns.empty?
+	$stderr.puts "[" + requires.sort.join( ", " ) + "]"
+end
+
+# Build the test suite
+class MemCacheTests
+	class << self
+		def suite
+			suite = Test::Unit::TestSuite.new( "MemCache" )
+
+			if suite.respond_to?( :add )
+				ObjectSpace.each_object( Class ) {|klass|
+					suite.add( klass.suite ) if klass < MemCache::TestCase
+				}
+			else
+				ObjectSpace.each_object( Class ) {|klass|
+					suite << klass.suite if klass < MemCache::TestCase
+				}			
+			end
+
+			return suite
+		end
+	end
+end
+
+# Run tests
+$SAFE = safelevel
+Test::Unit::UI::Console::TestRunner.new( MemCacheTests ).start
+
+
+
+

data/tests/errorhandling.tests.rb

@@ -0,0 +1,120 @@
+#!/usr/bin/ruby -w
+#
+# Unit test for error-handling
+# $Id: errorhandling.tests.rb 20 2004-10-05 05:40:52Z ged $
+#
+# Copyright (c) 2004 RubyCrafters, LLC. Most rights reserved.
+# 
+# This work is licensed under the Creative Commons Attribution-ShareAlike
+# License. To view a copy of this license, visit
+# http://creativecommons.org/licenses/by-sa/1.0/ or send a letter to Creative
+# Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.
+#
+# 
+
+unless defined? MemCache::TestCase
+	testsdir = File::dirname( File::expand_path(__FILE__) )
+	basedir = File::dirname( testsdir )
+	$LOAD_PATH.unshift "#{basedir}/lib" unless
+		$LOAD_PATH.include?( "#{basedir}/lib" )
+	$LOAD_PATH.unshift "#{basedir}/tests" unless
+		$LOAD_PATH.include?( "#{basedir}/tests" )
+
+	require 'mctestcase'
+end
+
+
+### Collection of tests for the M class.
+class MemCache::ErrorHandlingTestCase < MemCache::TestCase
+
+	ConnectErrorServer = 'localhost:61654'
+
+	### Set up memcache instance or skip
+	def setup
+		if @config
+			server = [ @config[:server], @config[:port] ].join(":")
+			@memcache = MemCache::new( server )
+			@memcache.clear
+			@memcache.debug = $DEBUG
+		else
+			skip( "No memcached to test against." )
+		end
+
+		super
+	end
+		
+
+	#################################################################
+	###	T E S T S
+	#################################################################
+
+	def test_00_connection_error
+		printTestHeader "ErrorHandling: Connection error"
+
+		# Test to be sure connection errors result in servers being marked dead.
+		cache = MemCache::new( ConnectErrorServer )
+		server = cache.method(:get_server).call( :any_key_should_work )
+
+		assert !server.alive?, "Server should be dead"
+	end
+
+
+	def test_10_general_error
+		printTestHeader "ErrorHandling: General error"
+		rval = nil
+		
+		# Grab the server object that the cache will use (:foo is an arbitrary
+		# key to hash on -- in theory anything should work).
+		server = @memcache.method( :get_server ).call( :foo )
+
+		# Now send an illegal command directly via #send and expect an
+		# "ERROR\r\n" message to be sent back and an exception to be raised
+		# because of it.
+		assert_raises( MemCache::InternalError ) {
+			@memcache.method( :send ).call( server => "bargle" )
+		}
+	end
+
+
+
+	### Test to be sure the error strings can be get/set without triggering
+	### exceptions (tests the error-condition matching code).
+	def test_99_false_positive
+		printTestHeader "ErrorHandling: False positives"
+		rval = nil
+
+		strings = {
+			:general => "ERROR\r\n",
+			:server  => "SERVER_ERROR false positive\r\n",
+			:client  => "CLIENT_ERROR false positive\r\n",
+		}
+
+		# Set key and value
+		strings.each do |key, str|
+
+			# Key
+			debugMsg "Setting %p = %p" % [ str, key ]
+			assert_nothing_raised { @memcache[ str ] = key }
+
+			# Value
+			debugMsg "Setting %p = %p" % [ key, str ]
+			assert_nothing_raised { @memcache[ key ] = str }
+		end
+
+		# Get key and value
+		strings.each do |key, str|
+
+			# Key
+			debugMsg "Fetching %p" % [ str ]
+			assert_nothing_raised { rval = @memcache[ str ] }
+			assert_nil_or_equal key, rval, "Error message as key"
+
+			# Value
+			debugMsg "Fetching %p" % [ key ]
+			assert_nothing_raised { rval = @memcache[ key ] }
+			assert_nil_or_equal str, rval, "Symbol as key"
+		end
+	end
+
+end
+

data/tests/getset.tests.rb

@@ -0,0 +1,365 @@
+#!/usr/bin/ruby -w
+#
+# Unit test for the get/set operations on the MemCache class
+# $Id: getset.tests.rb 30 2004-11-13 17:32:06Z ged $
+#
+# Copyright (c) 2004 RubyCrafters, LLC. Most rights reserved.
+# 
+# This work is licensed under the Creative Commons Attribution-ShareAlike
+# License. To view a copy of this license, visit
+# http://creativecommons.org/licenses/by-sa/1.0/ or send a letter to Creative
+# Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.
+#
+# 
+
+unless defined? MemCache::TestCase
+	testsdir = File::dirname( File::expand_path(__FILE__) )
+	basedir = File::dirname( testsdir )
+	$LOAD_PATH.unshift "#{basedir}/lib" unless
+		$LOAD_PATH.include?( "#{basedir}/lib" )
+	$LOAD_PATH.unshift "#{basedir}/tests" unless
+		$LOAD_PATH.include?( "#{basedir}/tests" )
+
+	require 'mctestcase'
+end
+
+
+### Collection of tests for the MemCache class.
+class MemCacheTestCase < MemCache::TestCase
+
+
+	TestDataMatrix = {
+		'alooo'		=> 'bar',
+		:foo		=> [:bar, :baz, :boing],
+		{:ark => 1}	=> "giraffe of doom",
+		Time::now	=> 0,
+		"INDIGO"	=> :i,
+		23.12		=> "quickly accelerated",
+	}
+
+
+	### Set up memcache instance or skip
+	def setup
+		if @config
+			server = [ @config[:server], @config[:port] ].join(":")
+			@memcache = MemCache::new( server )
+			@memcache.clear
+			@memcache.debug = $DEBUG
+		else
+			skip( "No memcached to test against." )
+		end
+
+		super
+	end
+		
+
+
+	#################################################################
+	###	T E S T S
+	#################################################################
+
+	### Test setting via #set, get via #get
+	def test_10_getset_methods
+		printTestHeader "Get/Set; Methods"
+		rval = obj = nil
+
+		# Set without expiration
+		TestDataMatrix.each do |key, val|
+			assert_nothing_raised { rval = @memcache.set(key, val) }
+			assert_equal true, rval, "For set(%p, %p)" % [key,val]
+		end
+
+		# Set with expiration
+		TestDataMatrix.each do |key, val|
+			assert_nothing_raised { rval = @memcache.set(key, val, 3600) }
+			assert_equal true, rval, "For set( %p, %p, 3600 )" % [key,val]
+		end
+
+		# Get
+		TestDataMatrix.each do |key, val|
+			assert_nothing_raised { rval = @memcache.get(key) }
+			assert_nil_or_equal val, rval
+		end
+	end
+
+
+	### Test setting via #[]=, get via #[]
+	def test_20_index_methods
+		printTestHeader "Get/Set: Index Methods"
+		rval = obj = nil
+
+		# Set
+		TestDataMatrix.each do |key, val|
+			assert_nothing_raised { rval = (@memcache[ key ] = val) }
+			assert_equal val, rval, "For [%p]=%p" % [key,val]
+		end
+
+		# Get
+		TestDataMatrix.each do |key, val|
+			assert_nothing_raised { rval = @memcache[ key ] }
+			assert_nil_or_equal val, rval, "For [%p]" % [key]
+		end
+	end
+
+
+	# Multi-set, multi-get
+	def test_30_multi_setget
+		printTestHeader "Get/Set: Multi-set/-get"
+		rval = obj = nil
+
+		keys = TestDataMatrix.keys.sort_by {|obj| obj.hash}
+		values = TestDataMatrix.values_at( *keys )
+
+		# Multi-set via index operator slice
+		assert_nothing_raised do
+			rval = (@memcache[ *keys ] = values)
+		end
+		assert_instance_of Array, rval
+
+		# Multi-set via #set_many
+		assert_nothing_raised do
+			rval = @memcache.set_many( TestDataMatrix )
+		end
+		assert_instance_of Array, rval
+
+		# Multi-get via index operator slice
+		assert_nothing_raised do
+			rval = @memcache[ *keys ]
+		end
+		assert_instance_of Array, rval
+		values.each_with_index do |val, i|
+			assert_nil_or_equal val, rval[i],
+				"For key = <%p>" % keys[i]
+		end
+
+		# Multi-get via get(...)
+		assert_nothing_raised do
+			rval = @memcache.get( *keys )
+		end
+		assert_instance_of Array, rval
+		values.each_with_index do |val, i|
+			assert_nil_or_equal val, rval[i],
+				"For key = <%p>" % keys[i]
+		end
+
+	end
+
+
+	# Delete
+	def test_40_delete
+		printTestHeader "Get/Set: Delete"
+		rval = obj = nil
+
+		@memcache.set_many( TestDataMatrix )
+
+		# Without expiry
+		TestDataMatrix.each do |key,val|
+			assert_nothing_raised { rval = @memcache.delete(key) }
+			assert_equal true, rval, "Results of #delete(%p)" % [key]
+
+			rval = @memcache.get( key )
+			assert_nil rval, "Get %p after #delete with no expiry" % [key]
+		end
+
+		# Re-delete should return false
+		#TestDataMatrix.each do |key,val|
+		#	assert_nothing_raised { rval = @memcache.delete(key) }
+		#	assert_equal false, rval, "Results of #delete(%p)" % [key]
+		#end
+
+		@memcache.set_many( TestDataMatrix )
+
+		# With expiry
+		TestDataMatrix.each do |key,val|
+			assert_nothing_raised { rval = @memcache.delete(key, 15) }
+			assert_equal true, rval, "Results of #delete(%p, 15)" % [key]
+
+			rval = @memcache.get( key )
+			assert_nil rval, "Get %p after #delete with expiry" % [key]
+		end
+	end
+
+
+	# Either 'delete' or 'add' as far as I can tell is fundamentally broken in
+	# memcached. Deleting an item with an expiration of '0' should, according to
+	# the protocol doc, cause the next 'add' to succeed:
+	#   " The parameter <time> is optional, and, if absent, defaults to 0 (which
+	#     means that the item will be deleted immediately and further storage
+	#     commands with this key will succeed)."
+	# This however is not what happens. It instead replies 'NOT_STORED' for at
+	# least several seconds:
+	#
+	# The script (which can also be found in experiments/add.script):
+	#   delete foo
+	#   set foo 4 0 3
+	#   bar
+	#   delete foo
+	#   add foo 12 0 2
+	#   12
+	#   quit
+	#
+	# When run against a memcached:
+	#   $ cat experiments/add.script | nc -vv localhost 11211
+	#   localhost [127.0.0.1] 11211 (?) open
+	#   NOT_FOUND
+	#   STORED
+	#   DELETED
+	#   NOT_STORED
+	#    sent 70, rcvd 40
+	# 
+	# And memcached's verbose output:
+	#   <3 server listening
+	#   <5 new client connection
+	#   <5 delete foo
+	#   >5 NOT_FOUND
+	#   <5 set foo 4 0 3
+	#   >5 STORED
+	#   <5 delete foo
+	#   >5 DELETED
+	#   <5 add foo 12 0 2
+	#   >5 NOT_STORED
+	#   <5 quit
+	#   <5 connection closed.
+
+	# Add
+	#def test_50_add
+	#	printTestHeader "Get/Set: Add"
+	#	rval = obj = nil
+	#
+	#	@memcache.clear
+	#
+	#	# Without expiration
+	#	TestDataMatrix.each do |key, val|
+	#		@memcache.delete( key )
+	#		assert_nothing_raised { rval = @memcache.add(key, val) }
+	#		assert_equal true, rval, "First #add"
+	#
+	#		assert_nothing_raised { rval = @memcache.add(key, val) }
+	#		assert_equal false, rval, "Second #add"
+	#	end
+	#
+	#	# Get
+	#	TestDataMatrix.each do |key, val|
+	#		assert_nothing_raised { rval = @memcache.get(key) }
+	#		assert_nil_or_equal val, rval
+	#	end
+	#
+	#	@memcache.clear
+	#
+	#	# With expiration
+	#	TestDataMatrix.each do |key, val|
+ 	#		@memcache.delete( key )
+	#		assert_nothing_raised { rval = @memcache.add(key, val, 3600) }
+	#		assert_equal true, rval, "First #add"
+	#
+	#		assert_nothing_raised { rval = @memcache.add(key, val, 3600) }
+	#		assert_equal false, rval, "Second #add"
+	#	end
+	#
+	#	# Get
+	#	TestDataMatrix.each do |key, val|
+	#		assert_nothing_raised { rval = @memcache.get(key) }
+	#		assert_nil_or_equal val, rval
+	#	end
+	#end
+
+
+	# Replace
+	def test_60_replace
+		printTestHeader "Get/Set: Replace"
+		rval = obj = nil
+
+		@memcache.clear
+
+		# Without expiration
+		TestDataMatrix.each do |key, val|
+ 			@memcache.delete( key )
+			assert_nothing_raised { rval = @memcache.replace(key, val) }
+			assert_equal false, rval, "First #replace"
+
+			@memcache.set( key, "value to be replaced" )
+			assert_nothing_raised { rval = @memcache.replace(key, val) }
+			assert_equal true, rval, "Second #replace"
+		end
+
+		# Get
+		TestDataMatrix.each do |key, val|
+			assert_nothing_raised { rval = @memcache.get(key) }
+			assert_nil_or_equal val, rval
+		end
+
+		@memcache.clear
+
+		# With expiration
+		TestDataMatrix.each do |key, val|
+ 			@memcache.delete( key )
+			assert_nothing_raised { rval = @memcache.replace(key, val, 3600) }
+			assert_equal false, rval, "First #replace"
+
+			@memcache.set( key, "value to be replaced" )
+			assert_nothing_raised { rval = @memcache.replace(key, val, 3600) }
+			assert_equal true, rval, "Second #replace"
+		end
+
+		# Get
+		TestDataMatrix.each do |key, val|
+			assert_nothing_raised { rval = @memcache.get(key) }
+			assert_nil_or_equal val, rval
+		end
+	end
+
+
+	# Incr, decr
+	def test_70_incrdecr
+		printTestHeader "Get/Set: Replace"
+		rval = obj = nil
+		
+		@memcache.clear
+		@memcache.delete( :counter )
+
+		# Incr without set should return nil
+		assert_nothing_raised do rval = @memcache.incr( :counter ) end
+		assert_nil rval, "Result of incrementing an unknown key"
+
+		# ...same with a value
+		assert_nothing_raised do rval = @memcache.incr( :counter, 3 ) end
+		assert_nil rval, "Result of incrementing an unknown key"
+
+		# Decr without set should return nil
+		assert_nothing_raised do rval = @memcache.decr( :counter ) end
+		assert_nil rval, "Result of decrementing an unknown key"
+
+		# ...same with a value
+		assert_nothing_raised do rval = @memcache.decr( :counter, 3 ) end
+		assert_nil rval, "Result of decrementing an unknown key"
+
+		@memcache.set( :counter, 0 )
+
+		# Incr after set should increment -- no value == 1
+		assert_nothing_raised do rval = @memcache.incr( :counter ) end
+		assert_equal 1, rval, "Result of incrementing without a value"
+
+		# ...and with a value
+		assert_nothing_raised do rval = @memcache.incr( :counter, 3 ) end
+		assert_equal 4, rval, "Result of incrementing with value = 3"
+
+		# Decr after set should decrement -- no value == 1
+		assert_nothing_raised do rval = @memcache.decr( :counter ) end
+		assert_equal 3, rval, "Result of decrementing without a value"
+
+		# ...and with a value
+		assert_nothing_raised do rval = @memcache.decr( :counter, 3 ) end
+		assert_equal 0, rval, "Result of decrementing with value = 3"
+
+		# Decr will not go below 0, with a value
+		assert_nothing_raised do rval = @memcache.decr( :counter ) end
+		assert_equal 0, rval, "Result of decrementing below 0 without a value"
+
+		# ...and without
+		assert_nothing_raised do rval = @memcache.decr( :counter, 3 ) end
+		assert_equal 0, rval, "Result of decrementing below 0 with value = 3"
+		
+	end
+
+end
+