test-unit-mock 0.30

data/test-unit-mock.gemspec

@@ -0,0 +1,20 @@
+require 'date'
+Gem::Specification.new do |s|
+  s.name = %q{test-unit-mock}
+  s.version = "0.30"
+  s.date = Date.today.to_s
+  s.summary = %q{Test::Unit::Mock is a class for conveniently building mock objects in Test::Unit test cases.}
+  s.author = %q{Michael Granger}
+  s.email = %q{ged@FaerieMUD.org}
+  s.homepage = %q{http://www.deveiate.org/code/Test-Unit-Mock.html}
+  s.files = Dir.glob('**/*') 
+  s.require_path = %q{.}
+  s.autorequire = %q{mock}
+  s.has_rdoc = true
+  s.rdoc_options = ["--main", "README"]
+  s.extra_rdoc_files = ["README"]
+  s.test_files = %w{test.rb}
+  s.require_path = %q{.}
+  s.add_dependency('algorithm-diff', '>= 0.0.0')
+  s.required_ruby_version = Gem::Version::Requirement.new(">= 1.6.8")
+end

data/test.rb

@@ -0,0 +1,327 @@
+#!/usr/bin/ruby
+# :nodoc: all
+#
+#	Test suite for Test::Unit::MockObject
+#
+#
+
+$LOAD_PATH.unshift '.'
+
+require 'test/unit'
+require 'mock'
+
+require 'utils'
+include UtilityFunctions
+
+### Set up a class to be mocked
+class TestClass
+	def initialize( arg1 )
+		@arg1 = arg1
+	end
+
+	attr_accessor :arg1
+
+	def first
+		return "This is the first method"
+	end
+
+	def second( arg1 )
+		return "This is the second method (#{arg1})"
+	end
+
+	def third( arg1, arg2="default" )
+		return "This is the third method (#{arg1}, #{arg2})"
+	end
+
+	def fourth( arg1="default" )
+		return "This is the fourth method (#{arg1})"
+	end
+
+	def fifth( *args )
+		return "This is the fifth method (#{args.collect do |arg| arg.inspect end.join(',')})"
+	end
+
+end
+
+
+### The test case
+class TUMockTestCase < Test::Unit::TestCase
+
+	# Testing and setup methods that are exected to be available from MockObject
+	# instances. Does not include double-underscored and non-camelCased aliases,
+	# which are auto-generated by the test.
+	Interface = [
+		# Setup methods
+		:setReturnValues,
+		:setCallOrder,
+		:strictCallOrder=,
+		:strictCallOrder?,
+
+		# Testing methods
+		:callTrace,
+		:activate,
+		:verify,
+		:activate,
+		:clear,
+		:reset,
+	]
+
+	#################################################################
+	###	C L A S S   M E T H O D S
+	#################################################################
+
+	@@methodCounter = 0
+	@setupMethods = []
+	@teardownMethods = []
+
+	class << self
+		attr_accessor :setupMethods
+		attr_accessor :teardownMethods
+	end
+
+	
+	### Append a setup block for the current testcase
+	def self::addSetupBlock( &block )
+		@@methodCounter += 1
+		newMethodName = "setup_#{@@methodCounter}".intern
+		define_method( newMethodName, &block )
+		self.setupMethods.push newMethodName
+	end
+
+
+	### Prepend a teardown block for the current testcase
+	def self::addTeardownBlock( &block )
+		@@methodCounter += 1
+		newMethodName = "teardown_#{@@methodCounter}".intern
+		define_method( newMethodName, &block )
+		self.teardownMethods.unshift newMethodName
+	end
+
+
+	#################################################################
+	###	I N S T A N C E   M E T H O D S
+	#################################################################
+
+	### Set up a test before running
+	def setup
+		self.class.setupMethods.each {|sblock|
+			self.send( sblock )
+		}
+	end
+	alias_method :set_up, :setup
+
+	### Tear down a test after it runs
+	def teardown
+		self.class.teardownMethods.each {|tblock|
+			self.send( tblock )
+		}
+	end
+	alias_method :tear_down, :teardown
+
+
+	#################################################################
+	###	T E S T   M E T H O D S
+	#################################################################
+
+	### Test to be sure the mockup class and factory method are loaded.
+	def test_00_loaded
+		assert_instance_of Class, Test::Unit::Mockup
+		assert_respond_to Test::Unit, :MockObject
+	end
+
+
+	### Test mock object creation/interface
+	def test_10_Constructor
+		mockClass = nil
+		mo = nil
+
+		assert_nothing_raised { mockClass = Test::Unit::MockObject(TestClass) }
+		assert_instance_of Class, mockClass
+		
+		assert_nothing_raised { mo = mockClass::new }
+		assert_instance_of TestClass, mo
+		assert_kind_of TestClass, mo
+		assert mo.is_a?( TestClass ),
+			"Mock object doesn't fake the is_a? method"
+		assert mo.__class <= Test::Unit::Mockup,
+			"Mock object real type not a Test::Unit::Mockup derivative"
+
+		Interface.each {|meth|
+
+			# Test the regular method and the double-underscore one.
+			assert_respond_to mo, meth
+			assert_respond_to mo, "__#{meth.to_s}".intern
+
+			# Test for non-camelCased alias
+			if /[A-Z]/ =~ meth.to_s
+				# Oh, the irony.
+				nonCamelCaseMethod = meth.to_s.gsub( /([A-Z])/ ) {|match|
+					"_" + match.downcase
+				}.intern
+
+				assert_respond_to mo, nonCamelCaseMethod
+			end
+
+		}
+
+		self.class.addSetupBlock {
+			@mockObject = Test::Unit::MockObject(TestClass).new
+		}
+		self.class.addTeardownBlock {
+			@mockObject = nil
+		}
+	end
+
+
+	### Test the mocked methods
+	def test_15_FakedMethods
+		fakedMethod = nil
+		rval = nil
+
+		TestClass.instance_methods(false).each {|methName|
+			realMethod = TestClass.instance_method( methName )
+			
+			assert_nothing_raised { fakedMethod = @mockObject.method(methName) }
+			assert_instance_of Method, fakedMethod
+			assert_equal realMethod.arity, fakedMethod.arity
+		}
+
+		@mockObject.activate
+
+		# Now test calling with and without correct arity
+		assert_raises( ArgumentError ) { @mockObject.first("foo") }
+		assert_nothing_raised { @mockObject.first }
+
+		assert_raises( ArgumentError ) { @mockObject.second }
+		assert_nothing_raised { @mockObject.second("foo") }
+
+		assert_raises( ArgumentError ) { @mockObject.third }
+		assert_nothing_raised { @mockObject.third("foo") }
+
+		assert_nothing_raised { @mockObject.fourth("foo") }
+		assert_nothing_raised { @mockObject.fourth }
+
+		assert_nothing_raised { @mockObject.fifth }
+		assert_nothing_raised { @mockObject.fifth("foo") }
+		assert_nothing_raised { @mockObject.fifth("foo", "bar", 1, 11, $stderr, 1..18) }
+
+		# Test for call trace
+		assert_nothing_raised { rval = @mockObject.callTrace }
+		assert_instance_of Array, rval
+		assert_equal 8, rval.length
+
+		debugMsg "Call trace: "
+		rval.each {|trace| debugMsg trace}
+
+	end
+
+
+	### Test the methods that aren't mocked (those that aren't already tested
+	### above)
+	def test_17_UnmockedMethods
+		rval = nil
+
+		# inspect
+		assert_nothing_raised { rval = @mockObject.inspect }
+		assert_match( /#<Class:0x[a-f0-9]+>:0x[a-f0-9]+ /, rval )
+
+		# class
+		assert_nothing_raised { rval = @mockObject.class }
+		assert_equal TestClass, rval
+
+		# method, send, respond_to?
+		assert_nothing_raised { rval = @mockObject.send(:inspect) }
+		assert_not_nil rval
+		assert_nothing_raised { rval = @mockObject.method(:inspect) }
+		assert_instance_of Method, rval
+		assert_nothing_raised { rval = @mockObject.respond_to?(:fifth) }
+		assert_equal true, rval
+	end
+
+
+	### Test the mock setup methods
+	def test_20_SetupMethods
+		assert_nothing_raised {
+			@mockObject.setReturnValues( :first	=> 1,
+										 :second => 2,
+										 :third => 3 )
+		}
+		assert_nothing_raised {
+			@mockObject.setReturnValues( :fourth => 4,
+										 :second => 'II' )
+		}
+
+		assert_equal 1, @mockObject.first
+		assert_equal 'II', @mockObject.second(:foo)
+		assert_equal 3, @mockObject.third(:foo)
+		assert_equal 4, @mockObject.fourth
+		assert_equal true, @mockObject.fifth
+	end
+
+
+	### Test the call-order verification with "strict" mode turned off
+	def test_30_TestCallOrder
+		assert_nothing_raised {
+			@mockObject.setCallOrder( :first, :second, :third, :fourth, :fifth )
+		}
+
+		# Test a successful run with an extra call
+		assert_raises( RuntimeError ) { @mockObject.verify }
+		assert_nothing_raised { @mockObject.activate }
+
+		@mockObject.first
+		@mockObject.second(:foo)
+		@mockObject.arg1
+		@mockObject.third(:foo)
+		@mockObject.fourth
+		@mockObject.fifth
+
+		assert_raises( RuntimeError ) { @mockObject.activate }
+		assert_nothing_raised { @mockObject.verify }
+
+		# Test a failure
+		@mockObject.clear
+		@mockObject.activate
+
+		@mockObject.first
+		@mockObject.second(:foo)
+		@mockObject.arg1
+		@mockObject.fourth
+		@mockObject.fifth
+
+		assert_raises( Test::Unit::AssertionFailedError ) { @mockObject.verify }
+	end
+
+
+	### Test call-order verification with "strict" mode turned on
+	def test_35_TestStrictCallOrder
+		@mockObject.setCallOrder( :first, :second, :third, :fourth, :fifth )
+		assert_nothing_raised { @mockObject.strictCallOrder = true }
+
+		# Test a failure: an extra method
+		@mockObject.activate
+
+		@mockObject.first
+		@mockObject.second(:foo)
+		@mockObject.arg1
+		@mockObject.third(:foo)
+		@mockObject.fourth
+		@mockObject.fifth
+
+		assert_raises( Test::Unit::AssertionFailedError ) { @mockObject.verify }
+
+		# Test a failure for a missing method
+		@mockObject.clear
+		@mockObject.activate
+
+		@mockObject.first
+		@mockObject.second(:foo)
+		@mockObject.arg1
+		@mockObject.fourth
+		@mockObject.fifth
+
+		assert_raises( Test::Unit::AssertionFailedError ) { @mockObject.verify }
+	end
+
+end
+

data/utils.rb

@@ -0,0 +1,345 @@
+#
+#	Install/distribution utility functions
+#	$Id: utils.rb,v 1.2 2003/03/04 23:35:14 deveiant Exp $
+#
+#	Copyright (c) 2001-2003, The FaerieMUD Consortium.
+#
+#	This is free software. You may use, modify, and/or redistribute this
+#	software under the terms of the Perl Artistic License. (See
+#	http://language.perl.com/misc/Artistic.html)
+#
+
+
+BEGIN {
+	begin
+		require 'readline'
+		include Readline
+	rescue LoadError => e
+		$stderr.puts "Faking readline..."
+		def readline( prompt )
+			$stderr.print prompt.chomp
+			return $stdin.gets.chomp
+		end
+	end
+}
+
+module UtilityFunctions
+
+	# The list of regexen that eliminate files from the MANIFEST
+	ANTIMANIFEST = [
+		/makedist\.rb/,
+		/\bCVS\b/,
+		/~$/,
+		/^#/,
+		%r{docs/html},
+		%r{docs/man},
+		/^TEMPLATE/,
+		/\.cvsignore/,
+		/\.s?o$/
+	]
+
+	# Set some ANSI escape code constants (Shamelessly stolen from Perl's
+	# Term::ANSIColor by Russ Allbery <rra@stanford.edu> and Zenin <zenin@best.com>
+	AnsiAttributes = {
+		'clear'      => 0,
+		'reset'      => 0,
+		'bold'       => 1,
+		'dark'       => 2,
+		'underline'  => 4,
+		'underscore' => 4,
+		'blink'      => 5,
+		'reverse'    => 7,
+		'concealed'  => 8,
+
+		'black'      => 30,   'on_black'   => 40, 
+		'red'        => 31,   'on_red'     => 41, 
+		'green'      => 32,   'on_green'   => 42, 
+		'yellow'     => 33,   'on_yellow'  => 43, 
+		'blue'       => 34,   'on_blue'    => 44, 
+		'magenta'    => 35,   'on_magenta' => 45, 
+		'cyan'       => 36,   'on_cyan'    => 46, 
+		'white'      => 37,   'on_white'   => 47
+	}
+
+	ErasePreviousLine = "\033[A\033[K"
+
+
+	###############
+	module_function
+	###############
+
+	# Create a string that contains the ANSI codes specified and return it
+	def ansiCode( *attributes )
+		attr = attributes.collect {|a| AnsiAttributes[a] ? AnsiAttributes[a] : nil}.compact.join(';')
+		if attr.empty? 
+			return ''
+		else
+			return "\e[%sm" % attr
+		end
+	end
+
+	# Test for the presence of the specified <tt>library</tt>, and output a
+	# message describing the test using <tt>nicename</tt>. If <tt>nicename</tt>
+	# is <tt>nil</tt>, the value in <tt>library</tt> is used to build a default.
+	def testForLibrary( library, nicename=nil )
+		nicename ||= library
+		message( "Testing for the #{nicename} library..." )
+		if $:.detect {|dir| File.exists?(File.join(dir,"#{library}.rb")) || File.exists?(File.join(dir,"#{library}.so"))}
+			message( "found.\n" )
+			return true
+		else
+			message( "not found.\n" )
+			return false
+		end
+	end
+
+	# Test for the presence of the specified <tt>library</tt>, and output a
+	# message describing the problem using <tt>nicename</tt>. If
+	# <tt>nicename</tt> is <tt>nil</tt>, the value in <tt>library</tt> is used
+	# to build a default. If <tt>raaUrl</tt> and/or <tt>downloadUrl</tt> are
+	# specified, they are also use to build a message describing how to find the
+	# required library. If <tt>fatal</tt> is <tt>true</tt>, a missing library
+	# will cause the program to abort.
+	def testForRequiredLibrary( library, nicename=nil, raaUrl=nil, downloadUrl=nil, fatal=true )
+		nicename ||= library
+		unless testForLibrary( library, nicename )
+			msgs = [ "You are missing the required #{nicename} library.\n" ]
+			msgs << "RAA: #{raaUrl}\n" if raaUrl
+			msgs << "Download: #{downloadUrl}\n" if downloadUrl
+			if fatal
+				abort msgs.join('')
+			else
+				errorMessage msgs.join('')
+			end
+		end
+		return true
+	end
+
+	### Output <tt>msg</tt> as a ANSI-colored program/section header (white on
+	### blue).
+	def header( msg )
+		msg.chomp!
+		$stderr.puts ansiCode( 'bold', 'white', 'on_blue' ) + msg + ansiCode( 'reset' )
+		$stderr.flush
+	end
+
+	### Output <tt>msg</tt> to STDERR and flush it.
+	def message( msg )
+		$stderr.print msg
+		$stderr.flush
+	end
+
+	### Output the specified <tt>msg</tt> as an ANSI-colored error message
+	### (white on red).
+	def errorMessage( msg )
+		message ansiCode( 'bold', 'white', 'on_red' ) + msg + ansiCode( 'reset' )
+	end
+
+	### Output the specified <tt>msg</tt> as an ANSI-colored debugging message
+	### (yellow on blue).
+	def debugMsg( msg )
+		return unless $DEBUG
+		msg.chomp!
+		$stderr.puts ansiCode( 'bold', 'yellow', 'on_blue' ) + ">>> #{msg}" + ansiCode( 'reset' )
+		$stderr.flush
+	end
+
+	### Erase the previous line (if supported by your terminal) and output the
+	### specified <tt>msg</tt> instead.
+	def replaceMessage( msg )
+		print ErasePreviousLine
+		message( msg )
+	end
+
+	### Output a divider made up of <tt>length</tt> hyphen characters.
+	def divider( length=75 )
+		puts "\r" + ("-" * length )
+	end
+	alias :writeLine :divider
+
+	### Output the specified <tt>msg</tt> colored in ANSI red and exit with a
+	### status of 1.
+	def abort( msg )
+		print ansiCode( 'bold', 'red' ) + "Aborted: " + msg.chomp + ansiCode( 'reset' ) + "\n\n"
+		Kernel.exit!( 1 )
+	end
+
+	### Output the specified <tt>promptString</tt> as a prompt (in green) and
+	### return the user's input with leading and trailing spaces removed.
+	def prompt( promptString )
+		promptString.chomp!
+		return readline( ansiCode('bold', 'green') + "#{promptString}: " + ansiCode('reset') ).strip
+	end
+
+	### Prompt the user with the given <tt>promptString</tt> via #prompt,
+	### substituting the given <tt>default</tt> if the user doesn't input
+	### anything.
+	def promptWithDefault( promptString, default )
+		response = prompt( "%s [%s]" % [ promptString, default ] )
+		if response.empty?
+			return default
+		else
+			return response
+		end
+	end
+
+	### Search for the program specified by the given <tt>progname</tt> in the
+	### user's <tt>PATH</tt>, and return the full path to it, or <tt>nil</tt> if
+	### no such program is in the path.
+	def findProgram( progname )
+		ENV['PATH'].split(File::PATH_SEPARATOR).each {|d|
+			file = File.join( d, progname )
+			return file if File.executable?( file )
+		}
+		return nil
+	end
+
+	### Using the CVS log for the given <tt>file</tt> attempt to guess what the
+	### next release version might be. This only works if releases are tagged
+	### with tags like 'RELEASE_x_y'.
+	def extractNextVersionFromTags( file )
+		message "Attempting to extract next release version from CVS tags for #{file}...\n"
+		raise RuntimeError, "No such file '#{file}'" unless File.exists?( file )
+		cvsPath = findProgram( 'cvs' ) or
+			raise RuntimeError, "Cannot find the 'cvs' program. Aborting."
+
+		output = %x{#{cvsPath} log #{file}}
+		release = [ 0, 0 ]
+		output.scan( /RELEASE_(\d+)_(\d+)/ ) {|match|
+			if $1.to_i > release[0] || $2.to_i > release[1]
+				release = [ $1.to_i, $2.to_i ]
+				replaceMessage( "Found %d.%02d...\n" % release )
+			end
+		}
+
+		if release[1] >= 99
+			release[0] += 1
+			release[1] = 1
+		else
+			release[1] += 1
+		end
+
+		return "%d.%02d" % release
+	end
+
+	### Extract the project name (CVS Repository name) for the given directory.
+	def extractProjectName
+		File.open( "CVS/Repository", "r").readline.chomp
+	end
+
+	### Read the specified <tt>manifestFile</tt>, which is a text file
+	### describing which files to package up for a distribution. The manifest
+	### should consist of one or more lines, each containing one filename or
+	### shell glob pattern.
+	def readManifest( manifestFile="MANIFEST" )
+		message "Building manifest..."
+		raise "Missing #{manifestFile}, please remake it" unless File.exists? manifestFile
+
+		manifest = IO::readlines( manifestFile ).collect {|line|
+			line.chomp
+		}.select {|line|
+			line !~ /^(\s*(#.*)?)?$/
+		}
+
+		filelist = []
+		for pat in manifest
+			$stderr.puts "Adding files that match '#{pat}' to the file list" if $VERBOSE
+			filelist |= Dir.glob( pat ).find_all {|f| FileTest.file?(f)}
+		end
+
+		message "found #{filelist.length} files.\n"
+		return filelist
+	end
+
+	### Given a <tt>filelist</tt> like that returned by #readManifest, remove
+	### the entries therein which match the Regexp objects in the given
+	### <tt>antimanifest</tt> and return the resultant Array.
+	def vetManifest( filelist, antimanifest=ANITMANIFEST )
+		origLength = filelist.length
+		message "Vetting manifest..."
+
+		for regex in antimanifest
+			if $VERBOSE
+				message "\n\tPattern /#{regex.source}/ removed: " +
+					filelist.find_all {|file| regex.match(file)}.join(', ')
+			end
+			filelist.delete_if {|file| regex.match(file)}
+		end
+
+		message "removed #{origLength - filelist.length} files from the list.\n"
+		return filelist
+	end
+
+	### Combine a call to #readManifest with one to #vetManifest.
+	def getVettedManifest( manifestFile="MANIFEST", antimanifest=ANTIMANIFEST )
+		vetManifest( readManifest(manifestFile), antimanifest )
+	end
+
+	### Given a documentation <tt>catalogFile</tt>, which is in the same format
+	### as that described by #readManifest, read and expand it, and then return
+	### a list of those files which appear to have RDoc documentation in
+	### them. If <tt>catalogFile</tt> is nil or does not exist, the MANIFEST
+	### file is used instead.
+	def findRdocableFiles( catalogFile="docs/CATALOG" )
+		startlist = []
+		if File.exists? catalogFile
+			message "Using CATALOG file (%s).\n" % catalogFile
+			startlist = getVettedManifest( catalogFile )
+		else
+			message "Using default MANIFEST\n"
+			startlist = getVettedManifest()
+		end
+
+		message "Looking for RDoc comments in:\n" if $VERBOSE
+		startlist.select {|fn|
+			message "  #{fn}: " if $VERBOSE
+			found = false
+			File::open( fn, "r" ) {|fh|
+				fh.each {|line|
+					if line =~ /^(\s*#)?\s*=/ || line =~ /:\w+:/ || line =~ %r{/\*}
+						found = true
+						break
+					end
+				}
+			}
+
+			message( (found ? "yes" : "no") + "\n" ) if $VERBOSE
+			found
+		}
+	end
+
+	### Open a file and filter each of its lines through the given block a
+	### <tt>line</tt> at a time. The return value of the block is used as the
+	### new line, or omitted if the block returns <tt>nil</tt> or
+	### <tt>false</tt>.
+	def editInPlace( file ) # :yields: line
+		raise "No block specified for editing operation" unless block_given?
+
+		tempName = "#{file}.#{$$}"
+		File::open( tempName, File::RDWR|File::CREAT, 0600 ) {|tempfile|
+			File::unlink( tempName )
+			File::open( file, File::RDONLY ) {|fh|
+				fh.each {|line|
+					newline = yield( line ) or next
+					tempfile.print( newline )
+				}
+			}
+
+			tempfile.seek(0)
+
+			File::open( file, File::TRUNC|File::WRONLY, 0644 ) {|newfile|
+				newfile.print( tempfile.read )
+			}
+		}
+	end
+
+	### Execute the specified shell <tt>command</tt>, read the results, and
+	### return them. Like a %x{} that returns an Array instead of a String.
+	def shellCommand( *command )
+		raise "Empty command" if command.empty?
+
+		cmdpipe = IO::popen( command.join(' '), 'r' )
+		return cmdpipe.readlines
+	end
+
+end