arrow 1.0.7

data/rake/testing.rb

@@ -0,0 +1,187 @@
+# 
+# Rake tasklib for testing tasks
+
+# 
+# Authors:
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+
+unless defined?( COVERAGE_MINIMUM )
+	if ENV['COVVERAGE_MINIMUM']
+		COVERAGE_MINIMUM = Float( ENV['COVERAGE_MINIMUM'] )
+	else
+		COVERAGE_MINIMUM = 85.0 
+	end
+end
+SPEC_FILES       = [] unless defined?( SPEC_FILES )
+TEST_FILES       = [] unless defined?( TEST_FILES )
+
+COMMON_SPEC_OPTS = ['-Du'] unless defined?( COMMON_SPEC_OPTS )
+
+COVERAGE_TARGETDIR = BASEDIR + 'coverage' unless defined?( COVERAGE_TARGETDIR )
+RCOV_EXCLUDES      = 'spec,tests,/Library/Ruby,/var/lib,/usr/local/lib' unless
+	defined?( RCOV_EXCLUDES )
+
+
+desc "Run all defined tests"
+task :test do
+	unless SPEC_FILES.empty?
+		log "Running specs"
+		Rake::Task['spec:quiet'].invoke
+	end
+
+	unless TEST_FILES.empty?
+		log "Running unit tests"
+		Rake::Task[:unittests].invoke 
+	end
+end
+
+
+### RSpec specifications
+begin
+	gem 'rspec', '>= 1.1.3'
+
+	require 'spec'
+	require 'spec/rake/spectask'
+
+	### Task: spec
+	desc "Run specs"
+	task :spec => 'spec:doc'
+
+	namespace :spec do
+		desc "Run rspec every time there's a change to one of the files"
+		task :autotest do
+			require 'autotest/rspec'
+
+			autotester = Autotest::Rspec.new
+			autotester.run
+		end
+
+		desc "Generate regular color 'doc' spec output"
+		Spec::Rake::SpecTask.new( :doc ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = COMMON_SPEC_OPTS + ['-f', 's', '-c']
+		end
+
+		desc "Generate spec output with profiling"
+		Spec::Rake::SpecTask.new( :profile ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = COMMON_SPEC_OPTS + ['-f', 'o']
+		end
+
+		desc "Generate quiet non-colored plain-text output"
+		Spec::Rake::SpecTask.new( :quiet ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = COMMON_SPEC_OPTS + ['-f', 'p']
+		end
+
+		desc "Generate HTML output"
+		Spec::Rake::SpecTask.new( :html ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = COMMON_SPEC_OPTS + ['-f', 'h']
+		end
+
+	end
+rescue LoadError => err
+	task :no_rspec do
+		$stderr.puts "Specification tasks not defined: %s" % [ err.message ]
+	end
+
+	task :spec => :no_rspec
+	namespace :spec do
+		task :autotest => :no_rspec
+		task :doc => :no_rspec
+		task :profile => :no_rspec
+		task :quiet => :no_rspec
+		task :html => :no_rspec
+	end
+end
+
+
+### Test::Unit tests
+begin
+	require 'rake/testtask'
+
+	Rake::TestTask.new( :unittests ) do |task|
+		task.libs += [LIBDIR]
+		task.test_files = TEST_FILES
+		task.verbose = true
+	end
+
+rescue LoadError => err
+	task :no_test do
+		$stderr.puts "Test tasks not defined: %s" % [ err.message ]
+	end
+
+	task :unittests => :no_rspec
+end
+
+
+### RCov (via RSpec) tasks
+begin
+	gem 'rcov'
+	gem 'rspec', '>= 1.1.3'
+
+	require 'spec'
+	require 'rcov'
+
+	### Task: coverage (via RCov)
+	desc "Build test coverage reports"
+	unless SPEC_FILES.empty?
+		Spec::Rake::SpecTask.new( :coverage ) do |task|
+			task.spec_files = SPEC_FILES
+			task.libs += [LIBDIR]
+			task.spec_opts = ['-f', 'p', '-b']
+			task.rcov_opts = RCOV_OPTS
+			task.rcov = true
+		end
+	end
+
+
+	### Task: rcov
+	task :rcov => :coverage
+
+	### Other coverage tasks
+	namespace :coverage do
+		desc "Generate a detailed text coverage report"
+		Spec::Rake::SpecTask.new( :text ) do |task|
+			task.spec_files = SPEC_FILES
+			task.rcov_opts = RCOV_OPTS + ['--text-report']
+			task.rcov = true
+		end
+
+		desc "Show differences in coverage from last run"
+		Spec::Rake::SpecTask.new( :diff ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = ['-f', 'p', '-b']
+			task.rcov_opts = RCOV_OPTS - ['--save'] + ['--text-coverage-diff']
+			task.rcov = true
+		end
+
+		desc "Run RCov in 'spec-only' mode to check coverage from specs"
+		Spec::Rake::SpecTask.new( :speconly ) do |task|
+			task.spec_files = SPEC_FILES
+			task.rcov_opts = ['--exclude', RCOV_EXCLUDES, '--text-report', '--save']
+			task.rcov = true
+		end
+	end
+
+	CLOBBER.include( COVERAGE_TARGETDIR )
+
+rescue LoadError => err
+	task :no_rcov do
+		$stderr.puts "Coverage tasks not defined: RSpec+RCov tasklib not available: %s" %
+		[ err.message ]
+	end
+
+	task :coverage => :no_rcov
+	task :clobber_coverage
+	task :rcov => :no_rcov
+	namespace :coverage do
+		task :text => :no_rcov
+		task :diff => :no_rcov
+	end
+	task :verify => :no_rcov
+end
+
+

data/rake/verifytask.rb

@@ -0,0 +1,64 @@
+#####################################################################
+###	S U B V E R S I O N   T A S K S   A N D   H E L P E R S
+#####################################################################
+
+require 'rake/tasklib'
+
+#
+# Work around the inexplicable behaviour of the original RDoc::VerifyTask, which 
+# errors if your coverage isn't *exactly* the threshold.
+# 
+
+# A task that can verify that the RCov coverage doesn't
+# drop below a certain threshold. It should be run after
+# running Spec::Rake::SpecTask.
+class VerifyTask < Rake::TaskLib
+	
+	COVERAGE_PERCENTAGE_PATTERN = 
+		%r{<tt class='coverage_code'>(\d+\.\d+)%</tt>}
+	
+	# Name of the task. Defaults to :verify_rcov
+	attr_accessor :name
+
+	# Path to the index.html file generated by RCov, which
+	# is the file containing the total coverage.
+	# Defaults to 'coverage/index.html'
+	attr_accessor :index_html
+
+	# Whether or not to output details. Defaults to true.
+	attr_accessor :verbose
+
+	# The threshold value (in percent) for coverage. If the 
+	# actual coverage is not equal to this value, the task will raise an 
+	# exception. 
+	attr_accessor :threshold
+
+	def initialize( name=:verify )
+		@name = name
+		@index_html = 'coverage/index.html'
+		@verbose = true
+		yield self if block_given?
+		raise "Threshold must be set" if @threshold.nil?
+		define
+	end
+
+	def define
+		desc "Verify that rcov coverage is at least #{threshold}%"
+
+		task @name do
+			total_coverage = nil
+			if match = File.read( index_html ).match( COVERAGE_PERCENTAGE_PATTERN )
+				total_coverage = Float( match[1] )
+			else
+				raise "Couldn't find the coverage percentage in #{index_html}"
+			end
+
+			puts "Coverage: #{total_coverage}% (threshold: #{threshold}%)" if verbose
+			if total_coverage < threshold
+				raise "Coverage must be at least #{threshold}% but was #{total_coverage}%"
+			end
+		end
+	end
+end
+
+# vim: set nosta noet ts=4 sw=4:

data/spec/arrow/acceptparam_spec.rb

@@ -0,0 +1,157 @@
+#!/usr/bin/env ruby
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
+
+	libdir = basedir + "lib"
+
+	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
+}
+
+
+require 'spec'
+require 'spec/lib/constants'
+require 'spec/lib/helpers'
+require 'arrow'
+require 'arrow/constants'
+require 'arrow/acceptparam'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Arrow::AcceptParam do
+	include Arrow::SpecHelpers
+
+	before( :all ) do
+		setup_logging( :crit )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	ValidHeaders = {
+		'*/*' =>
+			{:type => nil, :subtype => nil, :qval => 1.0},
+		'*/*; q=0.1' =>
+			{:type => nil, :subtype => nil, :qval => 0.1},
+		'*/*;q=0.1' =>
+			{:type => nil, :subtype => nil, :qval => 0.1},
+		'image/*' =>
+			{:type => 'image', :subtype => nil, :qval => 1.0},
+		'image/*; q=0.18' =>
+			{:type => 'image', :subtype => nil, :qval => 0.18},
+		'image/*;q=0.4' =>
+			{:type => 'image', :subtype => nil, :qval => 0.4},
+		'image/*;q=0.9; porn=0; anseladams=1' =>
+			{:type => 'image', :subtype => nil, :qval => 0.9,
+				:extensions => %w[anseladams=1 porn=0]},
+		'image/png' =>
+			{:type => 'image', :subtype => 'png', :qval => 1.0},
+		'IMAGE/pNg' =>
+			{:type => 'image', :subtype => 'png', :qval => 1.0},
+		'application/x-porno' =>
+			{:type => 'application', :subtype => 'x-porno', :qval => 1.0},
+		'image/png; q=0.2' =>
+			{:type => 'image', :subtype => 'png', :qval => 0.2},
+		'image/x-giraffes;q=0.2' =>
+			{:type => 'image', :subtype => 'x-giraffes', :qval => 0.2},
+		'example/pork;    headcheese=0;withfennel=1' =>
+			{:type => 'example', :subtype => 'pork', :qval => 1.0,
+				:extensions => %w[headcheese=0 withfennel=1]},
+		'model/vnd.moml+xml' =>
+			{:type => 'model', :subtype => 'vnd.moml+xml', :qval => 1.0},
+		'model/parasolid.transmit.binary; q=0.2' =>
+			{:type => 'model', :subtype => 'parasolid.transmit.binary',
+				:qval => 0.2},
+		'image/png; q=0.2; compression=1' =>
+			{:type => 'image', :subtype => 'png', :qval => 0.2,
+				:extensions => %w[compression=1]},
+	}
+
+
+	it "parses valid Accept header values" do
+		ValidHeaders.each do |hdr, expectations|
+			rval = Arrow::AcceptParam.parse( hdr )
+
+			rval.should be_an_instance_of( Arrow::AcceptParam )
+			rval.type.should == expectations[:type]
+			rval.subtype.should == expectations[:subtype]
+			rval.qvalue.should == expectations[:qval]
+			if expectations[:extensions]
+				expectations[:extensions].each do |ext|
+					rval.extensions.should include(ext)
+				end
+			end
+		end
+	end
+
+	it "is lenient (but warns) about invalid qvalues" do
+		rval = nil
+		lambda {
+			rval = Arrow::AcceptParam.parse( '*/*; q=18' )
+		}.should_not raise_error()
+
+		rval.should be_an_instance_of( Arrow::AcceptParam )
+		rval.qvalue.should == 1.0
+	end
+
+
+	it "rejects invalid Accept header values" do
+		lambda {
+			Arrow::AcceptParam.parse( 'porksausage' )
+		}.should raise_error()
+	end
+
+
+	it "can represent itself in a human-readable object format" do
+		header = "text/html; q=0.9; level=2"
+		acceptparam = Arrow::AcceptParam.parse( header )
+		acceptparam.inspect.should =~ %r{AcceptParam.*text/html.*q=0.9}
+	end
+
+
+	it "can represent itself as an Accept header" do
+		header = "text/html;q=0.9;level=2"
+		acceptparam = Arrow::AcceptParam.parse( header )
+		acceptparam.to_s.should == header
+	end
+
+
+	it "can compare and sort on specificity" do
+		header = "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9," +
+			     "text/html;q=0.9;level=1,text/plain;q=0.8,image/png,*/*;q=0.5"
+		params = header.split(/\s*,\s*/).collect {|par|
+			Arrow::AcceptParam.parse( par )
+		}.sort
+
+		params[0].to_s.should == 'application/xhtml+xml;q=1.0'
+		params[1].to_s.should == 'application/xml;q=1.0'
+		params[2].to_s.should == 'image/png;q=1.0'
+		params[3].to_s.should == 'text/xml;q=1.0'
+		params[4].to_s.should == 'text/html;q=0.9;level=1'
+		params[5].to_s.should == 'text/html;q=0.9'
+		params[6].to_s.should == 'text/plain;q=0.8'
+		params[7].to_s.should == '*/*;q=0.5'
+	end
+
+
+	it "can be compared against strings" do
+		specific_param = Arrow::AcceptParam.parse( 'text/html' )
+		type_wildcard_param = Arrow::AcceptParam.parse( '*/*' )
+		subtype_wildcard_param = Arrow::AcceptParam.parse( 'image/*' )
+
+		( specific_param =~ 'text/html' ).should be_true()
+		( specific_param =~ 'image/png' ).should be_false()
+
+		( subtype_wildcard_param =~ 'image/png' ).should be_true()
+		( subtype_wildcard_param =~ 'image/jpeg' ).should be_true()
+		( subtype_wildcard_param =~ 'text/plain' ).should be_false()
+	end
+end
+
+# vim: set nosta noet ts=4 sw=4:

data/spec/arrow/applet_spec.rb

@@ -0,0 +1,575 @@
+#!/usr/bin/env ruby
+# 
+# Specification for the Arrow::Applet class
+# $Id$
+#
+# Copyright (c) 2004-2008 The FaerieMUD Consortium. Most rights reserved.
+# 
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
+
+	libdir = basedir + "lib"
+
+	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
+}
+
+require 'spec'
+
+require 'apache/fakerequest'
+require 'arrow'
+require 'arrow/applet'
+
+require 'spec/lib/helpers'
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Arrow::Applet do
+	include Arrow::SpecHelpers
+
+	before( :all ) do
+		setup_logging( :crit )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	it "has a signature even if it doesn't declare one" do
+		plainclass = Class.new( Arrow::Applet )
+		plainclass.signature.should be_an_instance_of( Arrow::Applet::SignatureStruct )
+		plainclass.signature.members.should include( 'name' )
+	end
+
+	it "subclasses know if further subclasses of itself have been loaded" do
+		plainclass = Class.new( Arrow::Applet )
+		plainclass.should_not be_inherited_from()
+		subclass = Class.new( plainclass )
+		plainclass.should be_inherited_from()
+	end
+
+	it "raises an exception if an action method that doesn't accept arguments is declared" do
+		lambda {
+			Class.new( Arrow::Applet ) do
+				def no_arg_action
+					raise "shouldn't be callable"
+				end
+			end
+		}.should raise_error( ::ScriptError, 'Inappropriate arity for no_arg_action' )
+	end
+
+
+	describe "concrete child and grandchild classes" do
+		before(:each) do
+			@appletclass = Class.new( Arrow::Applet ) do
+				default_action :test
+
+				applet_name "SuperApplet"
+				applet_description "A superclass applet"
+				applet_version 177
+				applet_maintainer "ged@FaerieMUD.org"
+			end
+			@appletsubclass = Class.new( @appletclass )
+
+			@applet = @appletclass.new( nil, nil, nil )
+		end
+
+
+		it "don't return superclass applets from ::load by default" do
+			Kernel.stub!( :load ).and_return do
+				Arrow::Applet.newly_loaded << @appletclass << @appletsubclass
+			end
+
+			applets = Arrow::Applet.load( 'stubbedapplet' )
+
+			applets.should have(1).member
+			applets.should_not include( @appletclass )
+			applets.should include( @appletsubclass )
+		end
+
+
+		it "return superclass applets from ::load if asked to do so" do
+			Kernel.stub!( :load ).and_return do
+				Arrow::Applet.newly_loaded << @appletclass << @appletsubclass
+			end
+
+			applets = Arrow::Applet.load( 'stubbedapplet', true )
+
+			applets.should have(2).members
+			applets.should include( @appletclass )
+			applets.should include( @appletsubclass )
+		end
+
+
+		it "inherit some values from their parent's signature" do
+			@appletsubclass.signature.maintainer.should == @appletclass.signature.maintainer
+			@appletsubclass.signature.maintainer.should_not be_equal(@appletclass.signature.maintainer)
+		end
+
+		it "don't inherit the :version, :name, and :description from their parent's signature" do
+			@appletsubclass.signature.version.should_not == @appletclass.signature.version
+			@appletsubclass.signature.name.should == @appletsubclass.name
+			@appletsubclass.signature.description.should == '(none)'
+		end
+	end
+
+
+	describe "instance" do
+		before( :all ) do
+			setup_logging( :crit )
+		end
+
+		before( :each ) do
+			@appletclass = Class.new( Arrow::Applet ) do
+				def test_action( txn, *args )
+					return [txn, args]
+				end
+
+				def one_arg_action( txn, one )
+					return one
+				end
+
+				def two_args_action( txn, one, two )
+					return [ one, two ]
+				end
+
+				def action_missing_action( txn, missing, *args )
+					return [ :missing, missing, *args ]
+				end
+
+				def load_template_action( txn, template_name )
+					return self.load_template( template_name )
+				end
+				template :devdas, "dola/re/dola.tmpl"
+			end
+
+			@uri = '/test'
+			@factory = mock( "template factory" )
+
+			@applet = @appletclass.new( nil, @factory, @uri )
+
+			@txn = stub( "transaction", :vargs => nil, :form_request? => false, :vargs= => nil )
+		end
+
+
+		it "delegates template-loading to its template factory" do
+			@factory.should_receive( :get_template ).with( 'dola/re/dola.tmpl' ).
+				and_return( :the_template )
+			@applet.load_template_action( @txn, :devdas ).should == :the_template
+		end
+
+		it "eliminates URI arguments to match the arity of actions with only one argument" do
+			@applet.run( @txn, 'one_arg', :first, :second, :third ).should == :first
+		end
+
+		it "eliminates URI arguments to match the arity of actions with two arguments" do
+			@applet.run( @txn, 'two_args', :first, :second, :third ).should == [:first, :second]
+		end
+
+		it "appends nil URI arguments to match the arity of actions with two arguments" do
+			@applet.run( @txn, 'two_args', :first ).should == [:first, nil]
+		end
+
+
+		it "maps invocations of nonexistent actions to the action_missing action" do
+			@applet.run( @txn, "nonexistent", :first ).should == [ :missing, "nonexistent", :first ]
+		end
+
+		it "doesn't use libapreq's param parser for a POST with content-type " +
+		        "other than 'application/www-form-url-encoded" do
+			request = mock( "request", :null_object => true )
+			request.should_not_receive( :paramtable )
+
+			txn = mock( "transaction", :null_object => true )
+			txn.should_receive( :form_request? ).at_least(1).and_return( false )
+			txn.stub!( :request ).and_return( request )
+
+			@applet.run( txn, 'test' )
+		end
+
+	end # describe "instance"
+
+
+	describe "instance with an action that accepts form parameters" do
+		before( :all ) do
+			setup_logging( :crit )
+		end
+
+		it "allows a validator to be declared using 'action, hash' syntax" do
+			appletclass = Class.new( Arrow::Applet ) do
+				def comma_action( txn, *args )
+					return 'yay'
+				end
+
+				validator :comma, :optional => :formy
+			end
+			appletclass.signature.validator_profiles[ :comma ].should == {
+				:optional => :formy
+			}
+		end
+
+		it "allows a validator to be declared using 'action => { hash }' syntax" do
+			appletclass = Class.new( Arrow::Applet ) do
+				def hash_action( txn, *args )
+					return 'yay'
+				end
+
+				validator :hash => { :optional => :formy }
+			end
+			appletclass.signature.validator_profiles[ :hash ].should == {
+				:optional => :formy
+			}
+		end
+	end
+
+
+	describe "instance without an #action_missing_action method" do
+		before( :all ) do
+			setup_logging( :crit )
+		end
+
+		before( :each ) do
+			@appletclass = Class.new( Arrow::Applet ) do
+				template :test => 'test.tmpl'
+			end
+
+			@uri = '/test'
+			@factory = mock( "template factory" )
+
+			@applet = @appletclass.new( nil, @factory, @uri )
+
+			@txn = stub( "transaction", :vargs => nil, :form_request? => false, :vargs= => nil )
+		end
+
+		it "maps missing actions to like-named templates" do
+			template = stub( "test template" )
+			@factory.should_receive( :get_template ).with( 'test.tmpl' ).and_return( template )
+
+			template.should_receive( :txn= ).with( @txn )
+			template.should_receive( :applet= ).with( @applet )
+
+			@applet.run( @txn, 'test' ).should == template
+		end
+
+		it "untaints the action before using it to look up the missing action template" do
+			template = stub( "test template" )
+			@factory.should_receive( :get_template ).with( 'test.tmpl' ).and_return( template )
+
+			template.should_receive( :txn= ).with( @txn )
+			template.should_receive( :applet= ).with( @applet )
+
+			action = 'test'
+			action.taint
+
+			Thread.new do
+				Thread.current.abort_on_exception = true
+				$SAFE = 1
+				lambda {
+					@applet.run( @txn, action )
+				}.should_not raise_error()
+			end.join
+		end
+
+
+
+		### TODO: Convert these to specs
+
+		def test_load_template_should_raise_an_error_for_templates_not_in_the_signature
+			assert_raises( Arrow::AppletError ) do
+				applet = @appletclass.new( nil, nil, nil )
+				applet.__send__( :load_template, :foo )
+			end
+		end
+
+
+		def test_template_directive_should_add_a_template_to_the_signature
+			assert !@appletclass.signature.templates.key?( :foo )
+
+			assert_nothing_raised do
+				@appletclass.class_eval do
+					template :foo, "foo.tmpl"
+				end
+			end
+
+			assert_equal "foo.tmpl", @appletclass.signature.templates[:foo]
+		end
+
+		def test_template_directive_should_accept_single_hash_pair
+			assert !@appletclass.signature.templates.key?( :foo )
+
+			assert_nothing_raised do
+				@appletclass.class_eval do
+					template :foo => "foo.tmpl"
+				end
+			end
+
+			assert_equal "foo.tmpl", @appletclass.signature.templates[:foo]
+		end
+
+		def test_template_directive_should_accept_multiple_hash_pairs
+			assert !@appletclass.signature.templates.key?( :foo )
+			assert !@appletclass.signature.templates.key?( :bar )
+
+			assert_nothing_raised do
+				@appletclass.class_eval do
+					template :foo => "foo.tmpl",
+						:bar => "bar.tmpl"
+				end
+			end
+
+			assert_equal "foo.tmpl", @appletclass.signature.templates[:foo]
+			assert_equal "bar.tmpl", @appletclass.signature.templates[:bar]
+		end
+
+		def test_applet_name_directive_should_set_signature_name
+			assert_not_equal "foo", @appletclass.signature.name
+
+			assert_nothing_raised do
+				@appletclass.class_eval do
+					applet_name "foo"
+				end
+			end
+
+			assert_equal "foo", @appletclass.signature.name
+		end
+
+		def test_applet_description_directive_should_set_signature_description
+			assert_not_equal "foo", @appletclass.signature.description
+
+			assert_nothing_raised do
+				@appletclass.class_eval do
+					applet_description "foo"
+				end
+			end
+
+			assert_equal "foo", @appletclass.signature.description
+		end
+
+		def test_applet_maintainer_directive_should_set_signature_maintainer
+			assert_not_equal "foo", @appletclass.signature.maintainer
+
+			assert_nothing_raised do
+				@appletclass.class_eval do
+					applet_maintainer "foo"
+				end
+			end
+
+			assert_equal "foo", @appletclass.signature.maintainer
+		end
+
+		def test_applet_appicon_directive_should_set_signature_appicon
+			assert_not_equal "foo.png", @appletclass.signature.appicon
+
+			assert_nothing_raised do
+				@appletclass.class_eval do
+					applet_maintainer "foo.png"
+				end
+			end
+
+			assert_equal "foo.png", @appletclass.signature.maintainer
+		end
+
+		def test_applet_version_directive_should_set_signature_version
+			assert_not_equal "200.1", @appletclass.signature.version
+
+			assert_nothing_raised do
+				@appletclass.class_eval do
+					applet_version "200.1"
+				end
+			end
+
+			assert_equal "200.1", @appletclass.signature.version
+		end
+
+		def test_default_action_directive_should_set_signature_default_action
+			assert_not_equal :edit, @appletclass.signature.default_action
+
+			assert_nothing_raised do
+				@appletclass.class_eval do
+					default_action :edit
+				end
+			end
+
+			assert_equal "edit", @appletclass.signature.default_action
+		end
+
+
+		def test_run_should_track_run_times
+			assert_equal 0.0, @applet.total_utime
+			assert_equal 0.0, @applet.total_stime
+
+			@applet.def_action_body do |txn|
+				# This will hopefully take more than 0.0 seconds on any machine.
+				10_000.times do
+					# This causes a system access, which makes for stime
+					# the previous code was only usertime on my linux machine -JJ
+					d = Dir.open('.')
+					d.close
+				end
+			end
+
+			with_run_fixtured_transaction do |txn|
+				@applet.run( txn, "test" )
+			end
+
+			assert (@applet.total_utime > 0.0), 
+				"Applet utime after run: %0.5f" % [@applet.total_utime]
+			assert (@applet.total_stime > 0.0), 
+				"Applet stime after run: %0.5f" % [@applet.total_stime]
+		end
+
+
+		def test_defining_an_action_method_with_inappropriate_arity_should_raise_scripterror
+			assert_raises( ScriptError ) do
+				@appletclass.class_eval { def malformed_action; end }
+			end
+		end
+
+
+		def test_running_against_action_method_with_inappropriate_arity_should_raise_appleterror
+			# We have to sneak a method past the ::method_added check...
+			@appletclass.class_eval do
+				def self::method_added(sym); end
+				def malformed_action; end
+			end
+
+			assert_raises( Arrow::AppletError ) do
+				with_run_fixtured_transaction do |txn|
+					@applet.run( txn, "malformed" )
+				end
+			end
+		end	
+
+
+		def test_run_with_two_arg_action_sends_the_appropriate_number_of_args
+			@appletclass.class_eval do
+				def two_arg_action( txn, arg )
+					[ txn, arg ]
+				end
+			end
+			@applet = @appletclass.new( nil, nil, nil )
+
+			with_run_fixtured_transaction do |txn|
+				rval = @applet.run( txn, "two_arg", "arg1", "arg2", "arg3" )
+
+				assert_instance_of Array, rval
+				assert_equal 2, rval.length
+				assert_same txn, rval.first
+				assert_equal "arg1", rval[1]
+			end
+
+		end
+
+
+		def test_run_with_block_yields_action_method_and_transaction_instead_of_invoking
+			rval, meth, rtxn, rargs = nil
+
+			with_run_fixtured_transaction do |txn|
+				rval = @applet.run( txn, "test", "arg1", "arg2" ) do |metharg, txn2, *args|
+					meth = metharg
+					rtxn = txn2
+					rargs = args
+
+					:passed
+				end
+
+				assert_instance_of Method, meth
+				assert_match( /#test_action/, meth.to_s )
+				assert_same txn, rtxn
+				assert_equal ["arg1", "arg2"], rargs
+
+				assert_equal :passed, rval
+			end
+		end
+
+
+		def test_run_with_parameterless_action_method_raises_an_appleterror
+			@applet.def_action_body do
+				flunk "Expected exception before action body was run"
+			end
+
+			with_run_fixtured_transaction do |txn|
+				assert_raises( Arrow::AppletError ) do
+					@applet.run( txn, "malformed" )
+				end
+			end
+		end
+
+
+		def test_run_without_an_action_invokes_the_default_action
+			invoked = false
+
+			@applet.def_action_body do
+				invoked = true
+			end
+
+			with_run_fixtured_transaction do |txn|
+				rval = @applet.run( txn )
+			end
+
+			assert_equal true, invoked, "Default action was not invoked"
+		end
+
+
+		def test_looking_up_a_valid_action_method_should_return_method_object_for_it
+			rval = nil
+			args = []
+
+			assert_nothing_raised do
+				rval, *args = @applet.send( :lookup_action_method, nil, "test" )
+			end
+
+			assert_instance_of Method, rval
+			assert_match( /#test_action/, rval.to_s )
+		end
+
+
+
+
+		def test_default_delegation_method_just_yields
+			rval = nil
+
+			assert_nothing_raised do
+				rval = @applet.delegate( nil, [:chain] ) {|arg| rval = arg }
+			end
+
+			assert_equal [:chain], rval
+		end
+
+
+		def test_subrun_from_delegation_populates_txn_vargs
+
+			# Define the delegator and an action to subrun
+			@appletclass.class_eval do
+				def delegate( txn, chain, *args )
+					self.subrun( 'test_vargs', txn, *args )
+				end
+				def test_vargs_action( txn, *args )
+				end
+			end
+
+			applet = @appletclass.new( nil, nil, nil )
+
+			# Even though it's not a real #run, the transaction should be
+			# set up the same way passing through #subrun
+			with_run_fixtured_transaction do |txn, req|
+				txn.should_receive( :vargs ).and_return(nil).at_least.once
+
+				assert_nothing_raised do
+					applet.delegate( txn, nil )
+				end
+			end
+
+		end
+
+	end # describe "concrete subclass"
+
+end
+
+
+# vim: set nosta noet ts=4 sw=4: