arrow 1.0.7

data/spec/arrow/broker_spec.rb

@@ -0,0 +1,153 @@
+#!/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 )
+}
+
+begin
+	require 'spec'
+	require 'apache/fakerequest'
+	require 'arrow'
+	require 'spec/lib/helpers'
+	require 'arrow/broker'
+rescue LoadError
+	unless Object.const_defined?( :Gem )
+		require 'rubygems'
+		retry
+	end
+	raise
+end
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Arrow::Broker do
+	include Arrow::SpecHelpers
+	
+	before( :all ) do
+		setup_logging( :crit )
+	end
+	
+	after( :all ) do
+		reset_logging()
+	end
+
+	
+	before( :each ) do
+		conf = Arrow::Config.new( TEST_CONFIG )
+		@broker = Arrow::Broker.new( conf )
+	end
+
+
+	#################################################################
+	###	H E L P E R   F U N C T I O N S
+	#################################################################
+	
+	def make_applet_chain( uri, *applets )
+		chain = []
+		uriparts = uri.split( %r{/} )
+
+		applets.each_with_index do |applet, i|
+			chain << Arrow::AppletRegistry::ChainLink.new(
+				applet,
+				uriparts[0..i+1].join('/'),
+				uriparts[i+2 .. -1] || []
+			  )
+		end
+		
+		return chain
+	end
+
+
+	#################################################################
+	###	E X A M P L E S
+	#################################################################
+
+	it "runs an applet when dispatching a uri that maps to it" do
+		applet = mock( "applet", :null_object => true )
+		appletchain = make_applet_chain( '/admin/create/job/1', applet )
+		@broker.registry = stub( "applet registry",
+			:check_for_updates => true,
+			:find_applet_chain => appletchain
+		  )
+
+		txn = mock( "transaction", :null_object => true )
+		txn.should_receive( :path ).and_return( '/admin/create/job/1' )
+
+		applet.should_receive( :run ).
+			with( txn, "create", "job", "1" ).
+			and_return( :passed )
+
+		@broker.delegate( txn ).should == :passed
+	end
+
+	
+	it "chains calls through multiple applets when a uri maps to more than one" do
+		applet1 = mock( "delegating applet 1" )
+		applet2 = mock( "delegating applet 2" )
+		applet3 = mock( "target applet" )
+
+		appletchain = make_applet_chain( '/admin/create/job/1', applet1, applet2, applet3 )
+		@broker.registry = stub( "applet registry",
+			:check_for_updates => true,
+			:find_applet_chain => appletchain
+		  )
+
+		txn = mock( "transaction", :null_object => true )
+		txn.should_receive( :path ).and_return( '/admin/create/job/1' )
+		signature = stub( "applet signature", :name => 'mock applet' )
+
+		applet1.should_receive( :signature ).
+			at_least(:once).
+			and_return( signature )
+		applet1.should_receive( :delegate ).
+			with( txn, appletchain[1,2], "create", "job", "1" ).
+			and_yield( nil )
+		applet2.should_receive( :signature ).
+			at_least(:once).
+			and_return( signature )
+		applet2.should_receive( :delegate ).
+			with( txn, appletchain[2..2], "job", "1" ).
+			and_yield( nil )
+		applet3.should_receive( :signature ).
+			at_least(:once).
+			and_return( signature )
+		applet3.should_receive( :run ).
+			with( txn, "1" ).
+			and_return( :passed )
+
+		@broker.delegate( txn ) #.should == :passed # RSpec 1.0 broke this
+	end
+
+	describe " for a root-mounted dispatcher" do
+
+		it "runs the root applet for a request to an empty path" do
+			conf = Arrow::Config.new( TEST_CONFIG )
+			broker = Arrow::Broker.new( conf )
+
+			applet = mock( "applet", :null_object => true )
+			appletchain = make_applet_chain( '/', applet )
+			broker.registry = stub( "applet registry",
+				:check_for_updates => true,
+				:find_applet_chain => appletchain
+			  )
+
+			txn = mock( "transaction", :null_object => true )
+			txn.should_receive( :path ).and_return( '' )
+
+			applet.should_receive( :run ).
+				with( txn ).
+				and_return( :passed )
+
+			broker.delegate( txn ).should == :passed
+		end
+	end
+
+end

data/spec/arrow/config_spec.rb

@@ -0,0 +1,224 @@
+#!/usr/bin/env ruby
+# 
+# Specification for the Arrow::Config 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 )
+}
+
+begin
+	require 'spec'
+	require 'apache/fakerequest'
+	require 'arrow'
+	require 'arrow/config'
+
+	require 'spec/lib/helpers'
+	require 'spec/lib/constants'
+rescue LoadError
+	unless Object.const_defined?( :Gem )
+		require 'rubygems'
+		retry
+	end
+	raise
+end
+
+
+include Arrow::TestConstants
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Arrow::Config do
+	include Arrow::SpecHelpers
+	
+	before( :all ) do
+		setup_logging( :crit )
+	end
+	
+	after( :all ) do
+		reset_logging()
+	end
+
+
+
+	#################################################################
+	###	E X A M P L E S
+	#################################################################
+
+	describe Arrow::Config::ConfigStruct do
+		
+		it "can be constructed from a Hash" do
+			struct = Arrow::Config::ConfigStruct.new( TEST_CONFIG_HASH )
+			struct.should have(5).members
+		end
+		
+		describe "instance" do
+			before( :each ) do
+				@struct = Arrow::Config::ConfigStruct.new( TEST_CONFIG_HASH )
+			end
+
+			it "knows what its keys are" do
+				@struct.keys.should have( TEST_CONFIG_HASH.length ).members
+				@struct.keys.should include( *TEST_CONFIG_HASH.keys )
+			end
+
+			it "knows if it has a particular key" do
+				@struct.should have_key( :templates )
+			end
+		
+			it "can look up its values via the Hash index interface" do
+				@struct[:applets][:path].should == TEST_CONFIG_HASH[:applets][:path]
+			end
+			
+			it "can turn itself back into a Hash" do
+				@struct.to_hash.should == TEST_CONFIG_HASH
+			end
+			
+		end
+		
+	end
+	
+
+	it "has reasonable defaults when instantiated without arguments" do
+		config = Arrow::Config.new
+		config.to_hash.should == Arrow::Config::DEFAULTS
+	end
+
+
+	it "can be initialized with a Hash" do
+		config = Arrow::Config.new( TEST_CONFIG_HASH.dup )
+		config.to_hash.should == TEST_CONFIG_HASH
+	end
+	
+
+	### Test instantiation of the Config class with configuration values.
+	def test_11_InstantiationWithArgs
+		printTestHeader "Arrow::Config: Instantiation with arguments"
+		rval = config = nil
+
+		assert_nothing_raised {
+			config = Arrow::Config.new( TestConfig )
+		}
+		assert_instance_of Arrow::Config, config
+
+		# The configuration values should be the test config merged with the
+		# defaults for the config class.
+		(TestConfig.keys|Arrow::Config::DEFAULTS.keys).each {|key|
+			val = TestConfig[key] || Arrow::Config::DEFAULTS[key]
+			assert_nothing_raised { rval = config.send(key) }
+			assert_config_equal val, rval, key
+		}
+	end
+
+
+	### Test the abstract Config::Loader class.
+	def test_30_Loader
+		printTestHeader "Arrow::Config: Loader base class"
+		rval = loader = nil
+		createTime = Time.now
+
+		assert_nothing_raised { loader = Arrow::Config::Loader.create('test') }
+		assert_kind_of Arrow::Config::Loader, loader
+
+		# The #load method
+		assert_respond_to loader, :load
+		assert_nothing_raised { rval = loader.load("foo") }
+		assert_instance_of Hash, rval
+		assert rval.key?( :applets ), "Loaded hash has an :applets key"
+		assert rval.key?( :templates ), "Loaded hash has a :templates key"
+
+		# The #save method
+		assert_respond_to loader, :save
+		assert_nothing_raised { loader.save(rval, "foo") }
+	end
+
+
+	### Test the .create method of Loader with the YAML Loader class.
+	def test_31_CreateYamlLoader
+		printTestHeader "Arrow::Config: YAML loader"
+		loader = rval = nil
+
+		assert_nothing_raised {
+			loader = Arrow::Config::Loader.create( 'yaml' )
+		}
+		assert_kind_of Arrow::Config::Loader, loader
+
+		assert_nothing_raised {
+			loader = Arrow::Config::Loader.create( 'YAML' )
+		}
+		assert_kind_of Arrow::Config::Loader, loader
+
+		assert_nothing_raised {
+			loader = Arrow::Config::Loader.create( 'Yaml' )
+		}
+		assert_kind_of Arrow::Config::Loader, loader
+	end
+
+
+	### Write config
+	def test_40_ConfigWriteRead
+		printTestHeader "Arrow::Config: #write and #read"
+		
+		config = Arrow::Config.new( TestConfig )
+		assert_nothing_raised {
+			config.write( TestConfigFilename )
+		}
+
+		otherConfig = Arrow::Config.load( TestConfigFilename )
+
+		assert_config_equal config.struct, otherConfig.struct
+	end
+
+
+	### Changed predicate knows something has changed after regular set
+	def test_50_changed_after_set
+		printTestHeader "Arrow::Config: #changed? after .member="
+		rval = nil
+		config = Arrow::Config.new( TestConfig )
+
+		# Make sure the brand-new config struct knows it's unchanged
+		assert_nothing_raised do
+			rval = config.changed?
+		end
+		assert_equal false, rval
+
+		# Change something via the regular accessors
+		config.templates.cache = false
+
+		# Make sure it knows something changed
+		assert_nothing_raised do
+			rval = config.changed?
+		end
+		assert_equal true, rval
+	end
+
+
+	### "Changed" predicate knows something has changed after merge-in-place
+	def test_55_changed_after_merge
+		printTestHeader "Arrow::Config: #changed? after #merge!"
+		rval = nil
+		config = Arrow::Config.new( TestConfig )
+		config2 = Arrow::Config.new()
+
+		# Now merge the defaults back into the test config
+		config.merge!( config2 )
+
+		# Make sure it knows something changed
+		assert_nothing_raised do
+			rval = config.changed?
+		end
+		assert_equal true, rval
+	end
+
+end

data/spec/arrow/cookieset_spec.rb

@@ -0,0 +1,164 @@
+#!/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 )
+}
+
+begin
+	require 'digest/md5'
+	require 'spec'
+	require 'apache/fakerequest'
+	require 'arrow'
+	require 'arrow/cookieset'
+rescue LoadError
+	unless Object.const_defined?( :Gem )
+		require 'rubygems'
+		retry
+	end
+	raise
+end
+
+
+#####################################################################
+###	C O N T E X T S
+#####################################################################
+
+describe Arrow::CookieSet do
+	before(:each) do
+		@cookieset = Arrow::CookieSet.new
+	end
+
+
+	it "is able to enummerate over each cookie in the set" do
+		pants_cookie = Arrow::Cookie.new( 'pants', 'baggy' )
+		shirt_cookie = Arrow::Cookie.new( 'shirt', 'pirate' )
+		@cookieset << shirt_cookie << pants_cookie
+
+		cookies = []
+		@cookieset.each do |cookie|
+			cookies << cookie
+		end
+
+		cookies.length.should == 2
+		cookies.should include( pants_cookie )
+		cookies.should include( shirt_cookie )
+	end
+
+	it "is able to add a cookie referenced symbolically" do
+		pants_cookie = Arrow::Cookie.new( 'pants', 'denim' )
+		@cookieset[:pants] = pants_cookie
+		@cookieset['pants'].should == pants_cookie
+	end
+
+
+	it "autos-create a cookie for a non-cookie passed to the index setter" do
+		lambda { @cookieset['bar'] = 'badgerbadgerbadgerbadger' }.should_not raise_error()
+
+		@cookieset['bar'].should be_an_instance_of( Arrow::Cookie )
+		@cookieset['bar'].value.should == 'badgerbadgerbadgerbadger'
+	end
+
+	it "raises an exception if the name of a cookie being set doesn't agree with the key it being set with" do
+		pants_cookie = Arrow::Cookie.new( 'pants', 'corduroy' )
+		lambda { @cookieset['shirt'] = pants_cookie }.should raise_error( ArgumentError )
+	end
+
+	it "implements Enumerable" do
+		Enumerable.instance_methods( false ).each do |meth|
+			@cookieset.should respond_to( meth )
+		end
+	end
+
+	it "is able to set a cookie's value symbolically to something other than a String" do
+		@cookieset[:wof] = Digest::MD5.hexdigest( Time.now.to_s )
+	end
+
+	it "is able to set a cookie with a Symbol key" do
+		@cookieset[:wof] = Arrow::Cookie.new( :wof, "something" )
+	end
+
+end
+
+describe Arrow::CookieSet, " created with an Array of cookies" do
+	it "should flatten the array" do
+		cookie_array = []
+		cookie_array << Arrow::Cookie.new( 'foo', 'bar' )
+		cookie_array << [Arrow::Cookie.new( 'shmoop', 'torgo!' )]
+
+		cookieset = nil
+		lambda {cookieset = Arrow::CookieSet.new(cookie_array)}.should_not raise_error()
+		cookieset.length.should == 2
+	end
+end
+
+describe Arrow::CookieSet, " with a 'foo' cookie" do
+	before(:each) do
+		@cookie = Arrow::Cookie.new( 'foo', 'bar' )
+		@cookieset = Arrow::CookieSet.new( @cookie )
+	end
+
+	it "contains only one cookie" do
+		@cookieset.length.should == 1
+	end
+
+	it "is able to return the 'foo' Arrow::Cookie via its index operator" do
+		@cookieset[ 'foo' ].should == @cookie
+	end
+
+
+	it "is able to return the 'foo' Arrow::Cookie via its symbolic name" do
+		@cookieset[ :foo ].should == @cookie
+	end
+
+	it "knows if it includes a cookie named 'foo'" do
+		@cookieset.should include( 'foo' )
+	end
+
+	it "knows if it includes a cookie referenced by :foo" do
+		@cookieset.should include( :foo )
+	end
+
+	it "knows that it doesn't contain a cookie named 'lollypop'" do
+		@cookieset.should_not include( 'lollypop' )
+	end
+
+	it "knows that it includes the 'foo' cookie object" do
+		@cookieset.should include( @cookie )
+	end
+
+
+	it "adds a cookie to the set if it has a different name" do
+		new_cookie = Arrow::Cookie.new( 'bar', 'foo' )
+		@cookieset << new_cookie
+
+		@cookieset.length.should == 2
+		@cookieset.should include( new_cookie )
+	end
+
+
+	it "replaces any existing same-named cookie added via appending" do
+		new_cookie = Arrow::Cookie.new( 'foo', 'giant scallops of doom' )
+		@cookieset << new_cookie
+
+		@cookieset.length.should == 1
+		@cookieset.should include( new_cookie )
+		@cookieset['foo'].should equal( new_cookie )
+	end
+
+	it "replaces any existing same-named cookie set via the index operator" do
+		new_cookie = Arrow::Cookie.new( 'foo', 'giant scallops of doom' )
+		@cookieset[:foo] = new_cookie
+
+		@cookieset.length.should == 1
+		@cookieset.should include( new_cookie )
+		@cookieset['foo'].should equal( new_cookie )
+	end
+
+end
+
+# vim: set nosta noet ts=4 sw=4: