genie 0.1

data/genie-0.1/tests/helpers.rb

@@ -0,0 +1,45 @@
+# This file contains some classes used to simplify
+# some of the tests.
+#
+# Author: A. Griesser
+
+# Registered commands that can be looked up by semantics.
+class RC < Command
+@@registry = Hash.new
+def initialize(semantics)
+  @@registry[semantics]=self
+	super
+end
+def self.[](sem); @@registry[sem]; end
+end
+
+# Makes both a MetaInfo and a Command (an RC to be exact).
+def make(semantics, log=nil)
+	CommandMetainfo.new(semantics).max_attempts=2
+	answer = RC.new(semantics)
+	answer.target=DebugTarget.new(log)
+	answer
+end
+
+# Simpler than the FakeTarget in test_commands.
+class DebugTarget
+attr_accessor :log
+def initialize(log=nil)
+  self.log = log || Array.new
+end
+def method_missing(aSymbol, *args)
+	log << [aSymbol].concat(args)
+	'Result_'+aSymbol.to_s
+end
+def to_a; log; end
+end # DebugTarget
+
+# Saves the entries that it decides to process.
+# Handles everything except the String 'wind'.
+class DebugWatcher < Array
+def entry_added(entry)
+  handled = entry!='wind'
+  self << entry if handled
+	handled
+end
+end # DebugWatcher

data/genie-0.1/tests/test_commands.rb

@@ -0,0 +1,338 @@
+
+require 'nist/common/log'
+# Don't bother to output test warnings.
+Object.outputters.clear
+
+require 'nist/genie/genie'
+require 'test/unit'
+require 'helpers'
+
+
+CommandMetainfo.new(:Rubbish)
+CommandMetainfo.new(:Fatal)
+CommandMetainfo.new(:Err)
+
+# ====================================================
+
+class FakeTarget
+
+attr_accessor :internal_state
+
+def self.fatal_message; "It's the end of the world as we know it"; end
+def self.err_message; 'That does not compute'; end
+
+def initialize
+  self.internal_state=Array.new
+end
+
+def do_Rubbish(args, undo_data)
+	undo_data[:superHero]=:FlamingCarrot
+	internal_state << [:do_Rubbish, args]
+	sleep(2)
+	warn('Sufferen Succotash!')
+	:Squid
+end
+
+def undo_Rubbish(args)
+  internal_state << [:undo_Rubbish, args]
+	sleep(1)
+	warn('Yumpin Yimminy')
+  42
+end
+
+def do_Fatal(args, undo_data)
+  fatal FakeTarget.fatal_message
+end
+
+def undo_Fatal(args)
+  fatal FakeTarget.fatal_message
+end
+
+def do_Err(args, undo_data)
+  raise FakeTarget.err_message
+end
+
+def undo_Err(args)
+  raise FakeTarget.err_message
+end
+
+end
+
+
+# ====================================================
+
+class Test_Commands < Test::Unit::TestCase
+
+def test_Command
+  c1 = make(:Spoon)
+	assert_kind_of(Command, c1)
+	c2 = c1.inverse
+	assert_kind_of(UndoRedoCommand, c2)
+	c3 = c2.inverse
+	assert_kind_of(UndoRedoCommand, c2)
+	e1 = c1.to_entry
+	e2 = c2.to_entry
+	e3 = c3.to_entry
+	assert_equal('Spoon', c1.description)
+	assert_equal('Spoon', c2.description)
+	assert_equal('Spoon', c3.description)
+	CommandMetainfo[:Spoon].description = 'Eating untensil'
+	assert_equal('Eating untensil', c1.description)
+	assert_equal('Eating untensil', c2.description)
+	assert_equal('Eating untensil', c3.description)
+	assert_equal(:do, c1.type)
+	assert_equal(:undo, c2.type)
+	assert_equal(:redo, c3.type)
+	assert_equal(:undo, c3.inverse.type)
+	assert_equal([c1], c1.command_chain)
+	assert_equal([c1, c2], c2.command_chain)
+	assert_equal([c1, c2, c3], c3.command_chain)
+	assert(c1.is_undoable)
+	assert(c2.is_undoable)
+	assert(c3.is_undoable)
+	assert( e1.can_undo)
+	assert(!e1.can_redo)
+	assert(!e2.can_undo)
+	assert( e2.can_redo)
+	assert( e3.can_undo)
+	assert(!e3.can_redo)
+	CommandMetainfo[:Spoon].undo_proc=nil
+	assert(!c1.is_undoable)
+	assert(!e1.can_undo)
+	assert(!e1.can_redo)
+end
+
+def test_metainfo
+  cm = CommandMetainfo[:Rubbish]
+  assert_nil(CommandMetainfo[:Gargoyle], 'CommandMetainfo registry somehow found nonexistant instance.')
+  assert_not_nil(cm, 'CommandMetainfo registry failed to find expected instance.')
+	assert_equal(:Rubbish, cm.semantics)
+  assert_equal(1, cm.max_attempts)
+	assert_equal(true, cm.may_have_side_effects)
+	assert_equal('Rubbish', cm.description)
+end
+
+def test_metainfo_resolution
+  c = Command.new(:Rubbish)
+	assert_not_nil(c.metainfo, "Command failed to lookup metainfo")
+  assert_equal(1, c.max_attempts)
+	assert_equal(true, c.may_have_side_effects)
+end
+
+def test_Command_do
+  c = common_command
+	result = c.do
+	verify_do(c, result, true)
+end
+
+def test_Command_undo
+  c = common_command
+	c.undo_data[:wascally]=:wabbit
+	result = c.undo
+	verify_undo(c, result)
+end
+
+def test_UndoRedo_undo
+  c = common_command
+	c2 = UndoRedoCommand.new(c)
+	result = c2.undo
+	verify_do(c, result, false)
+end
+
+def test_UndoRedo_do
+  c = common_command
+	c.undo_data[:wascally]=:wabbit
+	c2 = UndoRedoCommand.new(c)
+	result = c2.do
+	verify_undo(c, result)
+end
+
+def test_UnitOfWork_do
+  c1 = common_command
+	c2 = UndoRedoCommand.new(c1)
+	c3 = UndoRedoCommand.new(c2)
+	c = UnitOfWork.new(:Muddle, c1, c2, c3)
+	assert_equal(3, c.size)
+	r = c.do
+	verify_UnitOfWork(true, r, c, c1, c2, c3)
+end
+
+
+def test_UnitOfWork_redo
+  c1 = common_command
+	c2 = c1.inverse
+	c3 = c2.inverse
+	c = UnitOfWork.new(:Muddle, c1, c2, c3)
+	assert_equal(3, c.size)
+	r = c.redo
+	verify_UnitOfWork(false, r, c, c1, c2, c3)
+end
+
+
+def test_UnitOfWork_undo
+  c1 = common_command
+	c2 = c1.inverse
+	c3 = c1.inverse
+	# The order is fudged so that we can use the
+	# same tests we used for redo.
+	c = UnitOfWork.new(:Muddle, c2, c1, c3)
+	assert_equal(3, c.size)
+	r = c.undo
+	verify_UnitOfWork(false, r, c, c1, c2, c3)
+end
+
+def test_Fatal_do
+  c = common_command(:Fatal)
+	result = c.do
+	assert(result.error?)
+	assert_equal(1, result.notices.size)
+	assert_equal(FakeTarget.fatal_message, result.notices[0].message)
+end
+
+def test_Fatal_redo
+  c = common_command(:Fatal)
+	result = c.redo
+	assert(result.error?)
+	assert_equal(1, result.notices.size)
+	assert_equal(FakeTarget.fatal_message, result.notices[0].message)
+end
+
+def test_Fatal_undo
+  c = common_command(:Fatal)
+	result = c.undo
+	assert(result.error?)
+	assert_equal(1, result.notices.size)
+	assert_equal(FakeTarget.fatal_message, result.notices[0].message)
+end
+
+def test_Err_do
+  c = common_command(:Err)
+	result = c.do
+	assert(result.error?)
+	assert_equal(1, result.notices.size)
+	assert(result.notices[0].message.index(FakeTarget.err_message))
+end
+
+def test_Err_redo
+  c = common_command(:Err)
+	result = c.redo
+	assert(result.error?)
+	assert_equal(1, result.notices.size)
+	assert(result.notices[0].message.index(FakeTarget.err_message))
+end
+
+def test_Err_undo
+  c = common_command(:Err)
+	result = c.undo
+	assert(result.error?)
+	assert_equal(1, result.notices.size)
+	assert(result.notices[0].message.index(FakeTarget.err_message) )
+end
+
+# ==== support code =====
+
+def common_command(semantics=:Rubbish)
+  c = Command.new(semantics)
+	c.target = FakeTarget.new
+	c.args[:wombat]= :gizzard
+	c
+end
+
+def verify_do(c, result, has_undo_data)
+  if result.error?
+	  require 'nist/common/treeDump'
+		result.treeDump
+	end
+  assert(!result.error?)
+	assert_equal([[:do_Rubbish, {:wombat => :gizzard}]], c.target.internal_state )
+	assert_equal(:Squid, result.result)
+	assert_equal({:superHero => :FlamingCarrot}, result.undo_data)
+	expected = has_undo_data ? {:superHero => :FlamingCarrot} : {}
+	assert_equal(expected, c.undo_data)
+	assert_in_delta(2.0, result.execution_seconds, 0.1)
+	assert_equal(1, result.notices.size)
+	n = result.notices[0]
+	assert_equal('WARN', n.level_name)
+	assert_equal('FakeTarget', n.name)
+	assert_equal('Sufferen Succotash!', n.message)
+	assert(n.backtrace.size > 20)
+end
+
+def verify_undo(c, result)  
+  if result.error?
+	  require 'nist/common/treeDump'
+		result.treeDump
+	end
+  assert(!result.error?)
+	assert_equal([[:undo_Rubbish, {:wombat => :gizzard, :wascally => :wabbit}]], c.target.internal_state )
+	assert_equal(42, result.result)
+	assert_equal({}, result.undo_data)
+	assert_equal({:wascally => :wabbit}, c.undo_data)
+	assert_in_delta(1.0, result.execution_seconds, 0.1)
+	assert_equal(1, result.notices.size)
+	n = result.notices[0]
+	assert_equal('WARN', n.level_name)
+	assert_equal('FakeTarget', n.name)
+	assert_equal('Yumpin Yimminy', n.message)
+	assert(n.backtrace.size > 20)
+end
+
+# is_do is a Boolean,
+#   true for 'do'
+#   false for 'undo'
+# The difference is not very large: it results from the different ways the two methods cache undo data.
+def verify_UnitOfWork(is_do, r, c, c1, c2, c3)
+	assert_instance_of(Array, r.result)
+	assert_equal(3, r.size)
+	r1 = r[0]
+	r2 = r[1]
+	r3 = r[2]
+	# == Test shared data ==
+	undo_data = is_do ? {:wombat => :gizzard, :superHero => :FlamingCarrot} : {:wombat => :gizzard} 
+	assert_equal([[:do_Rubbish, {:wombat => :gizzard}], [:undo_Rubbish, undo_data], [:do_Rubbish, {:wombat => :gizzard}]], c1.target.internal_state )
+	# == Test first command & result ==
+	assert_equal(:Squid, r1.result)
+	assert_equal({:superHero => :FlamingCarrot}, r1.undo_data)
+	undo_data = is_do ? {:superHero => :FlamingCarrot} : {}
+	assert_equal(undo_data, c1.undo_data)
+	assert_in_delta(2.0, r1.execution_seconds, 0.1)
+	assert_equal(1, r1.notices.size)
+	n = r1.notices[0]
+	assert_equal('WARN', n.level_name)
+	assert_equal('FakeTarget', n.name)
+	assert_equal('Sufferen Succotash!', n.message)
+	assert(n.backtrace.size > 20)
+	# == Test second command & result ==
+	assert_equal(42, r2.result)
+	assert_equal({}, r2.undo_data)
+	assert_in_delta(1.0, r2.execution_seconds, 0.1)
+	assert_equal(1, r2.notices.size)
+	n = r2.notices[0]
+	assert_equal('WARN', n.level_name)
+	assert_equal('FakeTarget', n.name)
+	assert_equal('Yumpin Yimminy', n.message)
+	assert(n.backtrace.size > 20)
+	# == Test third command & result ==
+	# Identical to test for first command, except:
+	#     r1=>r3 and c1=>c3
+	#     c3 undo_data does not exist, so is not tested
+	assert_equal(:Squid, r3.result)
+	assert_equal({:superHero => :FlamingCarrot}, r3.undo_data)
+	assert_in_delta(2.0, r3.execution_seconds, 0.1)
+	assert_equal(1, r3.notices.size)
+	n = r1.notices[0]
+	assert_equal('WARN', n.level_name)
+	assert_equal('FakeTarget', n.name)
+	assert_equal('Sufferen Succotash!', n.message)
+	assert(n.backtrace.size > 20)
+end
+
+	
+end # Test_Commands
+
+# ====================================================
+
+if __FILE__ == $0 #directlyInvoked?
+    require 'test/unit/ui/console/testrunner'
+    Test::Unit::UI::Console::TestRunner.run(Test_Commands)
+end

data/genie-0.1/tests/test_processors.rb

@@ -0,0 +1,17 @@
+require 'nist/genie/genie'
+require 'test/unit'
+
+# ====================================================
+
+class Test_Processors < Test::Unit::TestCase
+
+def test_nothing; end
+	
+end # Test_Processors
+
+# ====================================================
+
+if __FILE__ == $0 #directlyInvoked?
+    require 'test/unit/ui/console/testrunner'
+    Test::Unit::UI::Console::TestRunner.run(Test_Processors)
+end

data/genie-0.1/tests/test_queues.rb

@@ -0,0 +1,288 @@
+require 'nist/genie/genie'
+require 'test/unit'
+require 'helpers'
+
+# Not yet tested: 
+#    Queue#processed      (but called methods are tested)
+#    Queue#claim_seconds  (but called methods are tested)
+
+# For testing purposes, it is convenient to regard all errors are retryable.
+class Log4r::LogEvent
+alias retryable_error? error?
+end
+
+# ====================================================
+
+class Test_Queues < Test::Unit::TestCase
+
+def test_TransactionBundle
+  semantics = [:electron, :proton, :neutron]
+	entries = semantics.collect {|sem| make(sem).to_entry }
+  entry = TransactionBundle.new(entries)
+	entry.do()
+	assert(!entry.retry?)
+	assert(!entry.retry_individually(true))
+	assert(entry.retry_individually(false))
+	notDone, done = entry.partition(false) 
+	assert_equal([], notDone)
+	assert_equal(entries, done)
+	notDone, done = entry.partition(true) 
+	assert_equal([], notDone)
+	assert_equal(entries, done)
+	# Fake an error
+	bad = entries[1]
+	good = [entries[0], entries[2]]
+	bad.result.add_error('Self destruct activated')
+	assert(entry.retry?)
+	assert(!entry.retry_individually(true))
+	assert(!entry.retry_individually(false)) # Because of may_have_side_effects
+	notDone, done = entry.partition(false)
+	assert_equal(entries, notDone)
+	assert_equal([], done)
+	notDone, done = entry.partition(true)
+	assert_equal(entries, notDone)
+	assert_equal([], done)
+	# Set may_have_side_effects to false
+	CommandMetainfo[:proton].may_have_side_effects=false
+	assert(!entry.retry_individually(true))
+	assert(entry.retry_individually(false))
+	notDone, done = entry.partition(false)
+	assert_equal([bad], notDone)
+	assert_equal(good, done)
+	notDone, done = entry.partition(true)
+	assert_equal(entries, notDone)
+	assert_equal([], done)
+end
+
+def verify_do_undo_redo(entry)
+  log = entries[0].command.target.log
+	methods = log.collect {|e| e[0] }
+  assert_equal(['do_electron', 'do_proton', 'do_neutron'], methods)
+end
+
+def test_QueueEntry
+  cmnd = make(:Wretched)
+	entry = cmnd.to_entry
+	sleep(1)
+	assert_in_delta(1.0, entry.age, 0.1)
+	assert_equal(0, entry.num_attempts)
+	assert_equal(2, entry.remaining_attempts)
+	assert(entry.has_remaining_attempts)
+	assert(entry.remaining_attempts?)
+	assert_nil(entry.result)
+	assert(!entry.error?)
+	assert(!entry.retry?)
+	assert_nil(entry.when_finished)
+	assert_nil(entry.thread)
+	# Finally, run the command
+	entry.do()
+	assert_equal(1, entry.num_attempts)
+	assert_equal(1, entry.remaining_attempts)
+	assert(entry.has_remaining_attempts)
+	assert(entry.remaining_attempts?)
+	result = entry.result
+	assert_instance_of(Result, result)
+	assert_equal('Result_do_Wretched', result.result)
+	assert_equal(0, result.notices.size)
+	assert(!entry.error?)
+	assert(!entry.retry?)
+	assert_nil(entry.when_finished)
+	notDone, done = entry.partition(:ignoredNonsnse) # Argument is not ignored by TransactionBundle.
+	assert_equal([], notDone)
+	assert_equal([entry], done)
+	# Fake an error
+	result.notices << Log4r::LogEvent.new(5, Object.logger, [], 'Self destruct activated')
+	assert(entry.error?)
+	assert(entry.retry?)
+	notDone, done = entry.partition(:ignoredNonsnse)
+	assert_equal([entry], notDone)
+	assert_equal([], done)
+	# Test finishing timestamp (does not make sense when retry? is true, but not prevented)
+	assert_nil(entry.when_finished)
+	entry.finish
+	assert_instance_of(Time, entry.when_finished)
+end
+
+# Tests the distribution of que entries among the various watchers.
+def test_Queue_roundrobbin
+	q = Queue.new
+	q.add_watcher(w1 = DebugWatcher.new)
+	q.add_watcher(w2 = DebugWatcher.new)
+	q.add_watcher(w3 = DebugWatcher.new)
+	'Find what wind serves to advance an honest mind'.split.each {|word| 
+	    # Argument really should be a QueueEntry, but a String is
+			# good enough to test the distribution.
+	    q.notify_watchers(word)
+			}
+	require 'nist/common/treeDump'
+	assert_equal(['Find', 'to', 'honest'], w1.to_a)
+	assert_equal(['what', 'advance', 'mind'], w2.to_a)
+	assert_equal(['serves', 'an'], w3.to_a)
+end
+
+def test_Queue
+  q = Queue.new
+	q.add_watcher(watcher = DebugWatcher.new)
+	t = Time.now
+	# Make a bunch of entries and add them to the queue
+	q.enqueue make(:Camembert)
+	q.enqueue make(:Brie)
+	q.enqueue make(:Gorgozola)
+	q.enqueue make(:Wensleydale)
+	q.enqueue make(:Limburger)
+	CommandMetainfo[:Camembert].estimated_seconds=3.0
+	CommandMetainfo[:Brie].estimated_seconds=5.0
+	CommandMetainfo[:Gorgozola].estimated_seconds=7.0
+	CommandMetainfo[:Wensleydale].estimated_seconds=9.0
+	CommandMetainfo[:Limburger].estimated_seconds=13.0
+	sleep(1)
+	expected_age = Time.now-t
+	assert_in_delta(expected_age, q.age_oldest_available, expected_age / 10)
+	assert_equal(37, q.estimated_seconds)
+	assert_equal(5, q.num_available)
+	# Test computation of number of entries to claim
+	# Test unlimited num_for_estimated_seconds
+	assert_equal(0, q.num_for_estimated_seconds(2))
+	assert_equal(1, q.num_for_estimated_seconds(4))
+	assert_equal(2, q.num_for_estimated_seconds(9))
+	assert_equal(3, q.num_for_estimated_seconds(16))
+	assert_equal(4, q.num_for_estimated_seconds(25))
+	assert_equal(5, q.num_for_estimated_seconds(38))
+	# Test limited num_for_estimated_seconds
+	assert_equal(1, q.num_for_estimated_seconds(9, 1))
+	assert_equal(2, q.num_for_estimated_seconds(16, 2))
+	assert_equal(2, q.num_for_estimated_seconds(25, 2))
+	assert_equal(2, q.num_for_estimated_seconds(38, 2))
+	# Now try claiming some entries
+	# Claim 1
+	entry = e1 = q.claim_one
+	assert_instance_of(QueueEntry, entry)
+	assert_same(RC[:Camembert], entry.command)
+	entry = e2 = q.claim_num(1)
+	assert_instance_of(QueueEntry, entry)
+	assert_same(RC[:Brie], entry.command)
+	assert_equal(2, q.claimed.size)
+	assert_same(entry, q.claimed[1])
+	# Claim 2
+	entry = e3 = q.claim_num(2)
+	assert_instance_of(TransactionBundle, entry)
+	kids = entry.children
+	assert_equal(2, kids.size)
+	assert_same(RC[:Gorgozola], kids[0].command)
+	assert_same(RC[:Wensleydale], kids[1].command)
+	assert_equal(3, q.claimed.size)
+	assert_same(entry, q.claimed[2])
+	# Claim 3
+	q.enqueue make(:Sapsago)
+	q.enqueue make(:Asiago)
+	entry = e4 = q.claim_num(3)
+	assert_instance_of(TransactionBundle, entry)
+	kids = entry.children
+	assert_equal(3, kids.size)
+	assert_same(RC[:Limburger], kids[0].command)
+	assert_same(RC[:Sapsago], kids[1].command)
+	assert_same(RC[:Asiago], kids[2].command)
+	assert_equal(4, q.claimed.size)
+	assert_same(entry, q.claimed[3])
+	# Test some private, internally used messages
+	# _relinquish
+	q.enqueue make(:Chocolate)
+	e5 = q.claim_one
+	assert_equal(5, q.claimed.size)
+	assert_same(e5, q.claimed[4])
+	q._relinquish(e5)
+	# _finish
+	assert_equal(0, q.num_available)
+	assert_equal(4, q.claimed.size)
+	assert_equal(0, q.history.size)
+	q._finish(e2)
+	assert_equal(0, q.num_available)
+	assert_equal(3, q.claimed.size)
+	assert_equal(1, q.history.size)
+	assert_same(e2, q.history[0])
+	assert_same(e1, q.claimed[0])
+	assert_same(e3, q.claimed[1])
+	# _reschedule
+	q.enqueue make(:Waffle)
+	q._reschedule(e1)
+	assert_equal(2, q.num_available)
+	assert_equal(2, q.claimed.size)
+	assert_equal(1, q.history.size)
+	assert_same(e1, q.available[0])
+	assert_same(e3, q.claimed[0])
+	assert_same(e4, q.claimed[1])
+end
+
+def test_do
+  q = Queue.new
+	q.add_watcher(watcher = DebugWatcher.new)
+	log = Array.new
+	semantics = [:mercury, :venus, :mars, :saturn, :jupiter]
+	commands = semantics.collect {|sem| make(sem, log) }
+	threads = commands.collect {|cmnd|
+	    Thread.new(q, cmnd, log) {|queue, c, lg| 
+		      sem = c.semantics.to_s
+		      lg << 'Enqueue_'+sem
+			    queue.do(c)
+			    lg << 'Fini_'+ sem
+			    }
+			sleep(0.1) # Let the new thread get as far as it can before spawning a new one
+			}
+	semantics.each {|sem|
+	  s = sem.to_s
+	  log << 'Claim_'+s
+		entry = q.claim_one
+		log << 'Execute_'+s
+		entry.do
+		log << 'Done_'+s
+		q.processed(entry)
+		sleep(0.1) # Let revived thread get as far as it can
+		log << 'Finished_'+s
+		}
+	expected = [
+	'Enqueue_mercury',
+  'Enqueue_venus',
+  'Enqueue_mars',
+  'Enqueue_saturn',
+  'Enqueue_jupiter',
+  'Claim_mercury',
+  'Execute_mercury',
+  [:do_mercury, {}, {}],
+  'Done_mercury',
+  'Fini_mercury',
+  'Finished_mercury',
+  'Claim_venus',
+  'Execute_venus',
+  [:do_venus, {}, {}],
+  'Done_venus',
+  'Fini_venus',
+  'Finished_venus',
+  'Claim_mars',
+  'Execute_mars',
+  [:do_mars, {}, {}],
+  'Done_mars',
+  'Fini_mars',
+  'Finished_mars',
+  'Claim_saturn',
+  'Execute_saturn',
+  [:do_saturn, {}, {}],
+  'Done_saturn',
+  'Fini_saturn',
+  'Finished_saturn',
+  'Claim_jupiter',
+  'Execute_jupiter',
+  [:do_jupiter, {}, {}],
+  'Done_jupiter',
+  'Fini_jupiter',
+  'Finished_jupiter' ]
+	assert_equal(expected, log)
+end
+	
+end # Test_Queues
+
+# ====================================================
+
+if __FILE__ == $0 #directlyInvoked?
+    require 'test/unit/ui/console/testrunner'
+    Test::Unit::UI::Console::TestRunner.run(Test_Queues)
+end