arrow 1.0.7

data/tests/path.tests.rb

@@ -0,0 +1,157 @@
+#!/usr/bin/env ruby -w
+#
+# Unit test for the Arrow::Config::Path class
+# $Id$
+#
+# Copyright (c) 2003 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? Arrow::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/lib" unless
+		$LOAD_PATH.include?( "#{basedir}/tests/lib" )
+
+	require 'arrow/testcase'
+end
+
+require 'arrow/path'
+
+### This test suite tests the stage1 (static) parser and the metagrammar it
+### parses in which the actual parser-generator's behaviour is defined.
+class Arrow::PathTestCase < Arrow::TestCase
+
+	TestArrayPath = %w{/etc /bin /shouldnt/exist} +
+		[ Dir.pwd, File.dirname(Dir.pwd) ]
+	TestStringPath = TestArrayPath.join( File::PATH_SEPARATOR )
+	ExtantDirs = TestArrayPath.find_all {|dir|
+		File.directory?(dir) && File.readable?(dir)
+	}.uniq
+	warn "No extant directories in the array of test paths." if ExtantDirs.empty?
+
+
+	#################################################################
+	###	T E S T S
+	#################################################################
+
+	### Instance test
+	def test_00_Instance
+		printTestHeader "Arrow::Path: Instantiation"
+		path = nil
+
+		assert_instance_of Class, Arrow::Path
+		assert_nothing_raised { path = Arrow::Path.new }
+		assert_instance_of Arrow::Path, path
+		assert_equal 0, path.dirs.length
+	end
+
+	### Test instantiation with a String
+	def test_01_InstanceWithString
+		printTestHeader "Arrow::Path: Instantiation with String"
+		path, rval = nil, nil
+
+		assert_nothing_raised {
+			path = Arrow::Path.new( TestStringPath )
+		}
+
+		assert_instance_of Arrow::Path, path
+		assert_instance_of Array, path.dirs
+		assert_equal TestArrayPath.length, path.dirs.length
+
+		TestArrayPath.each_with_index {|dir, i|
+			assert_equal dir, path.dirs[i]
+		}
+	end
+
+	### Test instantiation with a Array
+	def test_02_InstanceWithArray
+		printTestHeader "Arrow::Path: Instantiation with Array"
+		path, rval = nil, nil
+
+		assert_nothing_raised {
+			path = Arrow::Path.new( TestArrayPath )
+		}
+
+		assert_instance_of Arrow::Path, path
+		assert_instance_of Array, path.dirs
+		assert_equal TestArrayPath.length, path.dirs.length
+
+		TestArrayPath.each_with_index {|dir, i|
+			assert_equal dir, path.dirs[i]
+		}
+
+		self.class.addSetupBlock {
+			@path = Arrow::Path.new( TestArrayPath )
+		}
+		self.class.addTeardownBlock {
+			@path = nil
+		}
+	end
+
+	### Test the valid_dirs method
+	def test_05_ValidDirs
+		printTestHeader "Arrow::Path: Valid Dirs"
+		rval = nil
+
+		assert_nothing_raised {
+			rval = @path.valid_dirs
+		}
+
+		assert_equal ExtantDirs, rval
+	end
+
+	### Test Enumerable interface 'each'
+	def test_10_Enumerable
+		printTestHeader "Arrow::Path: Each Iterator"
+		rval = []
+		assert_nothing_raised {
+			@path.each {|dir| rval << dir}
+		}
+		assert_equal ExtantDirs, rval
+	end
+
+	### Test Enumerable mixin method #collect
+	def test_11_EnumerableCollect
+		printTestHeader "Arrow::Path: Collect Iterator"
+		rval = nil
+		assert_nothing_raised {
+			rval = @path.collect {|dir| dir.reverse }
+		}
+		assert_equal ExtantDirs.collect {|dir| dir.reverse}, rval
+	end
+
+	### Test Array method delegation for #push
+	def test_14_PushArrayDelegate
+		printTestHeader "Arrow::Path: Array Delegate: Push"
+
+		assert_nothing_raised do
+			@path.push Dir.pwd
+		end
+		
+		newpath = ExtantDirs | [Dir.pwd]
+		assert_equal newpath.sort, @path.valid_dirs.sort
+	end
+
+	### Test Array method delegation for #unshift
+	def test_15_UnshiftArrayDelegate
+		printTestHeader "Arrow::Path: Array Delegate: Unshift"
+
+		assert_nothing_raised {
+			@path.unshift( Dir.pwd, File.dirname(Dir.pwd) )
+		}
+		
+		newpath = [Dir.pwd, File.dirname(Dir.pwd)] | ExtantDirs 
+		assert_equal newpath.sort, @path.valid_dirs.sort
+	end
+
+	
+
+end
+

data/tests/session.tests.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby -w
+#
+# Unit test for the Arrow::Session class
+# $Id$
+#
+# Copyright (c) 2003 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? Arrow::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/lib" unless
+		$LOAD_PATH.include?( "#{basedir}/tests/lib" )
+
+	require 'arrow/testcase'
+end
+
+require 'arrow/session'
+require 'arrow/config'
+require 'arrow/transaction'
+
+
+### Collection of tests for the Arrow::Session class.
+class Arrow::SessionTestCase < Arrow::TestCase
+
+	### Configuration
+	SessionDir			= File.dirname( File.expand_path(__FILE__) ) + "/sessions"
+
+	DefaultIdUri		= "md5:."
+	DefaultIdType		= 'Arrow::Session::MD5Id'
+	DefaultLockUri		= "file:#{SessionDir}"
+	DefaultLockType		= 'Arrow::Session::FileLock'
+	DefaultStoreUri		= "file:#{SessionDir}"
+	DefaultStoreType	= 'Arrow::Session::YamlStore'
+
+    TestSessionId       = "6bfb3f041cf9204c3a2ea4611bd5c9d1"
+
+	DefaultConfigHash = {
+		:idType		=> DefaultIdUri,
+		:idName     => "test_id",
+		:lockType	=> DefaultLockUri,
+		:storeType	=> DefaultStoreUri,
+	}
+
+
+
+	#################################################################
+	###	T E S T S
+	#################################################################
+
+    def test_create_id_should_use_id_from_cookie_if_present
+        rval = nil
+        
+        FlexMock.use( "config", "txn", "request", "cookie" ) do |config, txn, request, cookie|
+            txn.should_receive( :request_cookies ).
+				and_return({ "test_id" => cookie }).at_least.twice
+            txn.should_receive( :request ).and_return( request )
+
+            config.should_receive( :idName ).and_return( "test_id" ).at_least.once
+            cookie.should_receive( :value ).and_return( TestSessionId ).once
+            config.should_receive( :idType ).and_return( DefaultIdUri )
+            
+            rval = Arrow::Session.create_id( config, txn )
+        end
+        
+        assert_kind_of Arrow::Session::Id, rval
+        assert_equal TestSessionId, rval.to_s
+    end        
+
+	def test_the_session_class_should_know_what_the_session_cookie_name_is
+		rval = nil
+		
+		FlexMock.use( "config" ) do |config|
+			config.should_receive( :idName ).and_return( 'cookie-name' )
+			Arrow::Session.configure( config )
+			rval = Arrow::Session.session_cookie_name
+		end
+		
+		assert_equal 'cookie-name', rval
+	end
+
+	def test_saving_should_add_the_session_cookie_to_the_request_via_the_transaction
+		cookieset = Arrow::CookieSet.new
+		config = Arrow::Config.new
+		config.session.idName = 'cookie-name'
+		Arrow::Session.configure( config.session )
+		
+		FlexMock.use( "config", "store", "txn", "lock" ) do |config, store, txn, lock|
+			store.should_receive( :[]= ).with( :_session_id, 'id' )
+			store.should_receive( :save )
+			
+			lock.should_receive( :release_all_locks )
+			txn.should_receive( :cookies ).and_return( cookieset )
+			
+			session = Arrow::Session.new( :id, lock, store, txn )
+			session.save
+		end
+
+		assert cookieset.include?( 'cookie-name' )
+	end
+
+end
+

data/tests/session_id.tests.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby -w
+#
+# Unit test for the Arrow::Session::Id class
+# $Id$
+#
+# Copyright (c) 2003 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? Arrow::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/lib" unless
+		$LOAD_PATH.include?( "#{basedir}/tests/lib" )
+
+	require 'arrow/testcase'
+end
+
+
+### Collection of tests for the Arrow::Session::Id class.
+class Arrow::SessionIdTestCase < Arrow::TestCase
+
+	DefaultIdUri		= "md5:."
+	DefaultIdType		= 'Arrow::Session::MD5Id'
+
+
+	def setup
+		@id = Arrow::Session::Id.create( DefaultIdUri, @req )
+	end
+
+	def teardown
+		@id = nil
+	end
+
+
+	#################################################################
+	###	T E S T S
+	#################################################################
+
+	### Test to make sure the Id class is defined
+	def test_session_id_class_should_exist_and_be_a_class
+		assert_block( "Arrow::Session::Id defined?" ) { defined? Arrow::Session::Id }
+		assert_instance_of Class, Arrow::Session::Id
+	end
+
+
+	### Test the id component.
+	def test_creating_an_id_should_determine_the_id_class_from_the_uri
+		assert_equal DefaultIdType, @id.class.name
+	end
+
+
+	### Test to be sure the id object passes its own validation
+	def test_11_IdValidate
+		printTestHeader "Session::Id: Validation"
+		rval = nil
+
+		assert_nothing_raised {
+			rval = @id.class.validate( DefaultIdUri, @id.to_s )
+		}
+		assert_equal @id.to_s, rval,
+			"return value from .validate should be the same as its string value"
+
+		assert_nothing_raised {
+			str = @id.to_s
+			str.taint
+			rval = @id.class.validate( DefaultIdUri, str )
+		}
+		assert_not_tainted rval,
+			"return value from .validate should be untainted"
+	end
+
+
+end
+

data/tests/session_lock.tests.rb

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby -w
+#
+# Unit test for the Arrow::Session::Lock class
+# $Id$
+#
+# Copyright (c) 2003, 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? Arrow::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/lib" unless
+		$LOAD_PATH.include?( "#{basedir}/tests/lib" )
+
+	require 'arrow/testcase'
+end
+
+require 'digest/md5'
+
+
+### Collection of tests for the Arrow::Session::Lock class.
+class Arrow::SessionLockTestCase < Arrow::TestCase
+
+	SessionDir			= File.dirname( File.expand_path(__FILE__) ) + "/sessions"
+
+	LockTypes = {
+		"file:#{SessionDir}" => 'Arrow::Session::FileLock',
+	}
+
+	# If 'posixlock' is installed, test the posix lock type
+	begin
+		require 'posixlock'
+		LockTypes["posix:#{SessionDir}"] = 'Arrow::Session::PosixLock'
+	rescue ::Exception => err
+	end
+
+
+	def initialize( *args )
+		super
+
+		ctx = Digest::MD5.new
+		ctx << Process.pid.to_s
+		ctx << Time.now.to_s
+
+		@id = ctx.hexdigest
+	end
+
+
+	#################################################################
+	###	T E S T S
+	#################################################################
+
+	### Instance test
+	def test_00_Instantiate
+		assert_block( "Arrow::Session::Lock defined?" ) { defined? Arrow::Session::Lock }
+		assert_instance_of Class, Arrow::Session::Lock
+	end
+
+	
+	### Test the lock component.
+	def test_10_LockCreate
+		printTestHeader "Session::Lock: Create"
+		rval = nil
+
+		LockTypes.each {|uri, type|
+
+			# Should be able to a lock
+			assert_nothing_raised do
+				rval = Arrow::Session::Lock.create( uri, @id )
+			end
+
+			# Lock should support locking/unlocking/predicate methods
+			assert_equal type, rval.class.name
+
+			[
+				:read_lock, :write_lock, 
+				:with_read_lock, :with_write_lock,
+				:locked?, :read_locked?, :write_locked?,
+				:read_unlock, :write_unlock, :finish
+			].each do |meth|
+				assert_respond_to rval, meth
+			end
+		}
+
+		addSetupBlock {
+			@locks = LockTypes.keys.collect {|uri|
+				Arrow::Session::Lock.create( uri, @id )
+			}
+		}
+		addTeardownBlock {
+			unless @locks.nil?
+				@locks.each do |lock|
+					lock.finish
+				end
+				@locks = nil
+			end
+		}
+	end
+
+
+	### Test lock state before any locking
+	def test_11_LockBeforeLocking
+		printTestHeader "Session::Lock: Before locking"
+		rval = nil
+
+		# Locks should start out unlocked
+		@locks.each do |lock|
+			locktype = lock.class.name
+
+			assert_nothing_raised { rval = lock.locked? }
+			assert !rval, "locked? should be false, ie., unlocked (#{locktype})"
+			assert_nothing_raised { rval = lock.read_locked? }
+			assert !rval, "read_locked? should be false, ie., unlocked (#{locktype})"
+			assert_nothing_raised { rval = lock.write_locked? }
+			assert !rval, "write_locked? should be false, ie., unlocked (#{locktype})"
+
+			# Lock should raise errors when unlocked without first being locked.
+			assert_raises( Arrow::LockingError, locktype ) { lock.read_unlock }
+			assert_raises( Arrow::LockingError, locktype ) { lock.write_unlock }
+		end
+	end
+
+
+	### Test read lock functionality
+	def test_12_LockReadLocking
+		printTestHeader "Session::Lock: Read locking"
+		rval = nil
+
+		# Read lock should work
+		@locks.each do |lock|
+			locktype = lock.class.name
+
+			assert_nothing_raised( locktype ) { lock.read_lock }
+			assert_nothing_raised( locktype ) { rval = lock.read_locked? }
+			assert rval, "read_locked? should be true, ie., read locked (#{locktype})"
+			assert_nothing_raised( locktype ) { rval = lock.locked? }
+			assert rval, "locked? should be true, ie., either read or write locked (#{locktype})"
+			assert_nothing_raised( locktype ) { rval = lock.write_locked? }
+			assert !rval, "write_locked? should be false, ie., not write locked (#{locktype})"
+
+			# read_unlock should work and leave it unlocked
+			assert_nothing_raised( locktype ) { lock.read_unlock }
+			assert_nothing_raised( locktype ) { rval = lock.read_locked? }
+			assert !rval, "read_locked? should be false, ie., not locked (#{locktype})"
+			assert_nothing_raised( locktype ) { rval = lock.locked? }
+			assert !rval, "locked? should be false, ie., not read nor write locked (#{locktype})"
+			assert_nothing_raised( locktype ) { rval = lock.write_locked? }
+			assert !rval, "write_locked? should be false, ie., not write locked (#{locktype})"
+		end
+	end
+
+
+	### Test write lock functionality
+	def test_13_LockWriteLocking
+		printTestHeader "Session::Lock: Read locking"
+		rval = nil
+
+		@locks.each do |lock|
+			locktype = lock.class.name
+
+			# Write lock should work
+			assert_nothing_raised( locktype ) { lock.write_lock }
+			assert_nothing_raised( locktype ) { rval = lock.write_locked? }
+			assert rval, "write_locked? should be true, ie., write locked (#{locktype})"
+			assert_nothing_raised( locktype ) { rval = lock.locked? }
+			assert rval, "locked? should be true, ie., either write or read locked (#{locktype})"
+			assert_nothing_raised( locktype ) { rval = lock.read_locked? }
+			assert !rval, "read_locked? should be false, ie., not read locked (#{locktype})"
+
+			# write_unlock should work and leave it unlocked
+			assert_nothing_raised( locktype ) { lock.write_unlock }
+			assert_nothing_raised( locktype ) { rval = lock.write_locked? }
+			assert !rval, "write_locked? should be false, ie., not locked (#{locktype})"
+			assert_nothing_raised( locktype ) { rval = lock.locked? }
+			assert !rval, "locked? should be false, ie., not write nor read locked (#{locktype})"
+			assert_nothing_raised( locktype ) { rval = lock.read_locked? }
+			assert !rval, "read_locked? should be false, ie., not read locked (#{locktype})"
+		end
+
+	end
+
+end
+