SF.net SVN: fclient: [118] trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py

[<ju...@us...>]

Revision: 118
          http://fclient.svn.sourceforge.net/fclient/?rev=118&view=rev
Author:   jurner
Date:     2008-02-02 10:27:42 -0800 (Sat, 02 Feb 2008)

Log Message:
-----------
refactore unittests

Modified Paths:
--------------
    trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py

Modified: trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py
===================================================================
--- trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-02 18:27:21 UTC (rev 117)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-02 18:27:42 UTC (rev 118)
@@ -18,6 +18,7 @@
 
 import fcp2_0_client
 from fcp2_0_client import FcpClient
+import fcp2_0_consts as consts
 
 
 sys.path.pop(0)
@@ -32,7 +33,8 @@
 #***********************************************************************************
 #
 #***********************************************************************************
-class TestFcpClient(unittest.TestCase):
+class BaseTestClient(unittest.TestCase):
+	"""Base class that does not connect to FcpClient prior to each test"""
 	
 	
 	def __init__(self, *args, **kwargs):
@@ -52,8 +54,8 @@
 		self.events = []					# events received from the client
 		self.messages = []				# messages the client sent
 		self.tmpfiles = []				# temp files used for testing (will be removed on tearDown)
-		
-	def _captureBytesFromClient(self, bytes):
+	
+	def _captureMessagesFromClient(self, bytes):
 		s = DummySocket()
 		s.setResponse(bytes)
 		self.messages.append(self.fcpClient.Message.fromSocket(s))
@@ -62,17 +64,21 @@
 		self.events.append( (event, msg) )
 		
 	def connectClient(self):
+		"""Connects to the client"""
+		
 		enum = self.fcpClient.connect(duration=0.2, timeout=0.1)
 		msg = enum.next()
 		self.failIf(msg is not None)
-		self.socket.setResponseMessage(
+		#NOTE: have to send directly via socket here (our sendResponseMessage
+		# calls client.next() autkmatically)
+		self.socket.sendResponseMessage(
 				'NodeHello',
 				FCPVersion='2.0',
 				Node='Fred',
-				Version='???',
-				Revision='???',
-				Build='???',
-				ExRevision='???',
+				Version=str(self.fcpClient.ExpectedFcpVersion),
+				Revision='99999999',
+				Build='999999',
+				ExRevision='999999',
 				Testnet='false',
 				CompressionCodecs='1',
 				ConnectionIdentifier='any',
@@ -81,32 +87,115 @@
 		msg = enum.next()
 		self.messages.pop(0)
 		self.events.pop(0)
+	
+
+	def assertHasNextEvent(self, 
+			expectedEvent=None, 
+			messageName=None,
+			param1=None, 
+			param2=None, 
+			param3=None, 
+			param4=None, 
+			param5=None,
+			data=None
+			):
+		"""Tests if we received a certain event from the client
+		@param expectedEvent: the event expected or None if no event is expected
+		@param messageName: expected mesageName or None if no message is expected
+		@param param1: tuple(paramName, value) of a message parameter expected
+		@param data: data expected along with the message or None
 		
+		@return: message if a message was received or None
+		"""
+		if expectedEvent is None:
+			self.failIf(self.events)
+		else:
+			self.failUnless(self.events)
+			event, msg = self.events.pop(0)
+			self.assertEqual(event, expectedEvent)
+			
+			if messageName is not None:
+				self.assertEqual(msg.name, messageName)
+				if param1 is not None:
+					param1, value1 = param1
+					self.failUnless(param1 in msg.params)
+					self.assertEqual(value1, msg[param1])
+				if param2 is not None:
+					param2, value2 = param2
+					self.failUnless(param2 in msg.params)
+					self.assertEqual(value2, msg[param2])
+				if param3 is not None:
+					param3, value3 = param3
+					self.failUnless(param3 in msg.params)
+					self.assertEqual(value3, msg[param3])
+				if param4 is not None:
+					param4, value4 = param4
+					self.failUnless(param4 in msg.params)
+					self.assertEqual(value4, msg[param4])
+				if param5 is not None:
+					param5, value5 = param5
+					self.failUnless(param5 in msg.params)
+					self.assertEqual(value5, msg[param5])
+			
+				if data is not None:
+					self.assertEqual(data, msg.data)
+				
+				return msg
+			
 		
+	def assertHasNextMessage(self, 
+			messageName, 
+			param1=None, 
+			param2=None, 
+			param3=None, 
+			param4=None, 
+			param5=None,
+			data=None
+			):
+		"""Tests if we received a certain message from the client
+			@param messageName: expected mesageName or None if no message is expected
+			@param param1: tuple(paramName, value) of a message parameter expected
+			@param data: data expected along with the message or None
+			
+			@return: message if a message was received or None
+			"""
+		if messageName is None:
+			self.failIf(self.messages)
+		else:
+			msg = self.messages.pop(0)
+			self.assertEqual(msg.name, messageName)
+			if param1 is not None:
+				param1, value1 = param1
+				self.failUnless(param1 in msg.params)
+				self.assertEqual(value1, msg[param1])
+			if param2 is not None:
+				param2, value2 = param2
+				self.failUnless(param2 in msg.params)
+				self.assertEqual(value2, msg[param2])
+			if param3 is not None:
+				param3, value3 = param3
+				self.failUnless(param3 in msg.params)
+				self.assertEqual(value3, msg[param3])
+			if param4 is not None:
+				param4, value4 = param4
+				self.failUnless(param4 in msg.params)
+				self.assertEqual(value4, msg[param4])
+			if param5 is not None:
+				param5, value5 = param5
+				self.failUnless(param5 in msg.params)
+				self.assertEqual(value5, msg[param5])
+				
+			if data is not None:
+				self.assertEqual(data, msg.data)
+			return msg
+			
 	
-	def nextMessage(self):
-		"""Returns the next message the client send or None"""
-		if self.messages:
-			return self.messages.pop(0)
-		return None
+	def sendResponseMessage(self, messageName, data=None, **params):
+		"""Posts a message to the client"""
+		self.socket.sendResponseMessage(messageName, data=data, **params)
+		self.fcpClient.next()
 		
-	def nextEvent(self):
-		"""Returns the next tuple(event, message) the client triggered or (None, None)"""
-		if self.events:
-			return self.events.pop(0)
-		return (None, None)
-		
-	def hasNextEvent(self):
-		return bool(self.events)
-		
-	def hasNextMessage(self):
-		return bool(self.messages)
-		
-		
-	
-	#####################################################
-	##
-	#####################################################
+
 	def setUp(self):
 		self.oldSocketModule = fcp2_0_client.socket
 		fcp2_0_client.socket = 	self.socketModule
@@ -121,7 +210,7 @@
 	
 		# capture all messages the client sent
 		self.messages = []		# messages the client send
-		self.socket.setBytesReceiver(self._captureBytesFromClient)
+		self.socket.setBytesReceiver(self._captureMessagesFromClient)
 		
 		
 		
@@ -135,22 +224,37 @@
 		
 		# clean up tmpfiles
 		for fpath in self.tmpfiles: os.remove(fpath)
+
+#***********************************************************************************
+#
+#***********************************************************************************
+class BaseTestConnectedClient(BaseTestClient):
+	"""Base class that automatically connects to FcpClient prior to each test"""
 	
+	def setUp(self):
+		BaseTestClient.setUp(self)
+		self.connectClient()
 		
-	#######################################################
-	##
-	## connect() test cases
-	##
-	#######################################################
+	
+#***********************************************************************************
+#
+#***********************************************************************************
+#TODO: class Test.... set/getDebugVerbosity / connectionName and friends...  (BaseTestConnectedClient):
+
+#***********************************************************************************
+#
+#***********************************************************************************
+class TestConnect(BaseTestClient):
+	
+	
 	def testClose(self):
-		
 		self.failIf(self.socket.closed)
 		self.connectClient()
 		self.fcpClient.close()
 		self.failUnless(self.socket.closed)
 	
 	
-	def testConnectingFailed(self):
+	def testConnectFailed(self):
 		
 		# simulate a failed connection attempt
 		enum = self.fcpClient.connect(duration=0.2, timeout=0.1)
@@ -162,160 +266,271 @@
 		else:
 			raise RuntimeError('Fell trough')
 		
+				
 		# check messages the client send
-		self.failUnless(len(self.messages) == 1)
-		msg = self.messages.pop(0)
-		self.failUnless(msg.name == self.fcpClient.Message.MessageClientHello)
-		
+		self.assertHasNextMessage(consts.Message.ClientHello)
+						
 		# check events the client triggered
-		self.failUnless(len(self.events) == 1)
-		event, msg = self.events.pop(0)
-		self.failUnless(event.name == self.fcpClient.events.ClientDisconnected.name)
-		self.failUnless(msg.get('DisconnectReason', None) == FcpClient.DisconnectReason.ConnectingFailed)
+		self.assertHasNextEvent(
+				self.fcpClient.events.ClientDisconnected,
+				consts.Message.ClientDisconnected,
+				('DisconnectReason', consts.DisconnectReason.ConnectingFailed),
+				)
 		
+		self.assertHasNextEvent(None)
+		
 		# did the client clean up our socket?
 		self.failUnless(self.socket.closed)
 		
 		
 	
-	def testConnectingSucceeded(self):
+	def testConnecSucceeded(self):
 		
 		# simulate a successful connection attempt
 		enum = self.fcpClient.connect(duration=0.2, timeout=0.1)
 		msg = enum.next()
 		self.failIf(msg is not None)
 		
-		self.socket.setResponseMessage(
+		# check messages the client send message
+		self.assertHasNextMessage(
+			consts.Message.ClientHello
+			)
+		
+		#NOTE: have to send directly via socket here (our sendResponseMessage
+		# calls client.next() autkmatically)
+		self.socket.sendResponseMessage(
 				'NodeHello',
 				FCPVersion='2.0',
 				Node='Fred',
-				Version='???',
-				Revision='???',
-				Build='???',
-				ExRevision='???',
+				Version=str(self.fcpClient.ExpectedFcpVersion),
+				Revision='99999999',
+				Build='999999',
+				ExRevision='999999',
 				Testnet='false',
 				CompressionCodecs='1',
 				ConnectionIdentifier='any',
 				NodeLanguage='en',
 				)
 		msg = enum.next()
+						
+		# check events the client triggered
+		self.assertHasNextEvent(
+				self.fcpClient.events.ClientConnected,
+				consts.Message.NodeHello,
+				)
 		
-		# check messages the client received our response
-		self.failIf(msg is None)
-		self.failUnless(msg.name == self.fcpClient.Message.MessageNodeHello)
+		self.assertHasNextEvent(None)
+	
+
+#***********************************************************************************
+#
+#***********************************************************************************
+#TODO: testCloseOnVersionMismatch
+#TODO: testCloseOnDuplicateConnectionName
+#TODO: testShutdown
+
+class TestConnection(BaseTestConnectedClient):
+	
+	def testBrokenSocket(self):
 		
-		# check events the client triggered
-		self.failUnless(len(self.events) == 1)
-		event, msg = self.events.pop(0)
-		self.failUnless(event.name == self.fcpClient.events.ClientConnected.name)
-		self.failUnless(msg.name == self.fcpClient.Message.MessageNodeHello)
+		self.socket.close()
 		
+		# send a test message
+		self.assertRaises(socket.error, self.fcpClient.sendMessage, 'test' )
+		
+		# check if ClientDisconnected events has been triggered
+		self.assertHasNextEvent(
+				self.fcpClient.events.ClientDisconnected,
+				consts.Message.ClientSocketDied,
+				)
+		self.assertHasNextEvent(None)
+
 	
 	
-	####################################################
-	##
-	## PersistentGet test cases
-	##
-	####################################################		
-	def testEventRequestStarted(self):
-		
-		self.connectClient()
+#***********************************************************************************
+#
+#***********************************************************************************
+class TestClientGet(BaseTestConnectedClient):
+	
+	def testClientGetRegistered(self):
 				
 		# request a arbitrary file
-		myIdentifier = self.fcpClient.getFile(
+		myIdentifier = self.fcpClient.getData(
 			'arbitrary-uri',
-			'arbitryry.txt'
 			)
-		
-		msg = self.nextMessage()
-		self.failIf(msg is None)
-		self.assertEqual(msg.name, self.fcpClient.Message.MessageClientGet)
-		self.failIf(self.hasNextEvent() )		# no events should be triggered up to now
+		self.assertHasNextMessage(
+				consts.Message.ClientGet,
+				)
+		self.assertHasNextEvent(None)
+				
 		self.failUnless(self.fcpClient.getRequests() )
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		self.assertEqual(myIdentifier, myRequest['Identifier'])
-		self.assertEqual(myRequest['FcStatus'], self.fcpClient.Message.StatusPending)
+		self.assertEqual(myRequest['FcStatus'], consts.MessageStatus.Pending)
 		
+	
+	def testGetData(self):
+						
+		# request a arbitrary file
+		myIdentifier = self.fcpClient.getData(
+			'arbitrary-uri',
+			)
+		myRequest = self.fcpClient.getRequest(myIdentifier)		
+		
 		# respond to the file request
-		self.socket.setResponseMessage(
+		self.sendResponseMessage(
 				'PersistentGet',
 				Started='false',
 				**myRequest.params
 				)
-		self.fcpClient.next()
-		
-		event, msg = self.nextEvent()
-		self.failIf(event is None)
-		self.assertEqual(event, self.fcpClient.events.RequestStarted)
-		self.assertEqual(msg, myRequest)		# ??? looks like an implemenation detail
-		self.assertEqual(myRequest['FcStatus'], self.fcpClient.Message.StatusStarted)
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestStarted,
+				consts.Message.ClientGet,
+				('FcStatus', consts.MessageStatus.Started)
+				)
+		self.assertHasNextEvent(None)
+			
+		# simulate a progress
+		self.sendResponseMessage(
+				'SimpleProgress',
+				Identifier=myIdentifier,
+				Total=10,
+				Required=8,
+				Failed=0,
+				FatallyFailed=0,
+				FinalizedTotal='true',
+				Succeeded=1,
+				)
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestProgress,
+				)
 				
-		self.failIf(self.hasNextEvent() )
-		
-		
+		# finalize request
+		data = 'foo'
+		params = {
+				'Identifier': myIdentifier,
+				'Global': 'false',
+				'DataLength': len(data),
+				'Metadata.ContentType': 'any',
+				}
+		self.sendResponseMessage(
+				'DataFound',
+				**params
+				)
+		# we don't expect an event here....
+		self.assertHasNextEvent(None)
+				
+		self.sendResponseMessage(
+				'AllData',
+				data=data,
+				Identifier=myIdentifier,
+				Global='false',
+				DataLength=len(data),
+				)
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestCompleted,
+				data=data
+				)
+		self.assertHasNextEvent(None)
+			
 	
-	def testEventRequestModified(self):
-		
-		self.connectClient()
-		
+	def testgetFile(self):
+						
 		# request a arbitrary file
 		myIdentifier = self.fcpClient.getFile(
 			'arbitrary-uri',
+			'arbitryry.txt'
+			)
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		self.assertHasNextMessage(consts.Message.ClientGet)
+				
+		# respond to the file request
+		self.sendResponseMessage(
+				'PersistentGet',
+				Started='false',
+				**myRequest.params
+				)
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestStarted,
+				consts.Message.ClientGet,
+				('FcStatus', consts.MessageStatus.Started)
+				)
+		self.assertHasNextEvent(None)
+				
+		# finalize request
+		data = 'foo'
+		params = {
+				'Identifier': myIdentifier,
+				'Global': 'false',
+				'DataLength': 123456,
+				'Metadata.ContentType': 'any',
+				}
+		self.sendResponseMessage(
+				'DataFound',
+				**params
+				)
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestCompleted,
+				consts.Message.ClientGet,
+				('FcStatus', consts.MessageStatus.Complete)
+				)
+		self.assertHasNextEvent(None)
+
+#***********************************************************************************
+#
+#***********************************************************************************
+#TODO: class TestClientPut(BaseTestConnectedClient):
+
+#***********************************************************************************
+#
+#***********************************************************************************
+#TODO: testGetRequest()
+#TODO: testGetRequest()
+#TODO: testResendRequest()
+
+class TestRequests(BaseTestConnectedClient):
+
+	def testModifyRequest(self):
+				
+		# request a arbitrary file
+		myIdentifier = self.fcpClient.getFile(
+			'arbitrary-uri',
 			'arbitryry.txt',
 			persistentUserData='foo',
-			priorityClass=self.fcpClient.Priority.Medium,
+			priorityClass=consts.Priority.Medium,
 			)
-		msg = self.nextMessage()
-		self.failIf(msg is None)
-		self.assertEqual(msg.name, self.fcpClient.Message.MessageClientGet)
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		self.assertHasNextMessage(consts.Message.ClientGet)
 		
 		# respond to the file request
-		self.socket.setResponseMessage(
+		self.sendResponseMessage(
 				'PersistentGet',
 				Started='false',
-				**msg.params
+				**myRequest.params
 				)
-		self.fcpClient.next()
-		event, msg = self.nextEvent()
-		self.failIf(event is None)
-		self.assertEqual(event, self.fcpClient.events.RequestStarted)
-		
-		
-		myRequest = self.fcpClient.getRequest(myIdentifier)
-		
-		
+		self.assertHasNextEvent(self.fcpClient.events.RequestStarted	)
+				
 		# test modify persistent user data
-		self.fcpClient.modifyRequest(myIdentifier, persistentUserData='bar', priorityClass=self.fcpClient.Priority.High)
-		msg = self.nextMessage()
-		self.failIf(msg is None)
-		self.assertEqual(msg.name, self.fcpClient.Message.MessageModifyPersistentRequest)
+		self.fcpClient.modifyRequest(myIdentifier, persistentUserData='bar', priorityClass=consts.Priority.High)
+		msg = self.assertHasNextMessage(consts.Message.ModifyPersistentRequest)
 		
 		# respond to the file request
-		self.socket.setResponseMessage(
+		self.sendResponseMessage(
 				'PersistentRequestModified',
 				**msg.params
 				)
-		self.fcpClient.next()
+		self.assertHasNextEvent(self.fcpClient.events.RequestModified)
 		
-		event, eventMsg = self.nextEvent()
-		self.failIf(event is None)
-		self.assertEqual(event, self.fcpClient.events.RequestModified)
-		self.failUnless(self.fcpClient.Message.ModifiedRequestPersistentUserData in eventMsg['FcModified'])
-		self.failUnless(self.fcpClient.Message.ModifiedRequestPriorityClass in eventMsg['FcModified'])
+		self.failUnless(consts.RequestModified.PersistentUserData in myRequest['FcModified'])
+		self.failUnless(consts.RequestModified.PriorityClass in myRequest['FcModified'])
 		self.assertEqual('bar', myRequest['FcPersistentUserData'])
-		self.assertEqual(self.fcpClient.Priority.High, myRequest['PriorityClass'])	
-		self.failIf(self.events)
+		self.assertEqual(consts.Priority.High, myRequest['PriorityClass'])	
 		
-				
-		
-		
-		
+		self.assertHasNextEvent(None)
 	
 	
 	def testRemoveRequest(self):
-			
-		self.connectClient()
-		
+				
 		# request a file
 		myIdentifier = self.fcpClient.getFile(
 			'arbitrary-uri',
@@ -324,75 +539,50 @@
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 				
 		# respond to the file request
-		self.socket.setResponseMessage(
+		self.sendResponseMessage(
 				'PersistentGet',
 				Started='false',
 				**myRequest.params
 				)
-		self.fcpClient.next()		
-		
-				
+							
 		# ignore events and messages so far
 		self.events = []
 		self.messages = []
 				
-		
 		# now cancel request
 		self.fcpClient.removeRequest(myIdentifier)
 		
 		# status of our request should be set to removed emidiately, but it should
 		# not be removed from the client
-		self.assertEqual(myRequest['FcStatus'], self.fcpClient.Message.StatusRemoved)
+		self.assertEqual(myRequest['FcStatus'], consts.MessageStatus.Removed)
 		self.failUnless(myIdentifier in self.fcpClient.getRequests())
 		
 		# client schould send a RemovePersistentRequest
-		msg = self.nextMessage()
-		self.failIf(msg is None)
-		self.assertEqual(msg.name, self.fcpClient.Message.MessageRemovePersistentRequest)
-		
+		self.assertHasNextMessage(consts.Message.RemovePersistentRequest)
+				
 		# respond with a PersistentRequestRemoved
-		self.socket.setResponseMessage(
+		self.sendResponseMessage(
 				'PersistentRequestRemoved',
-				Identifier=msg['Identifier']
+				Identifier=myIdentifier,
 				)
-		self.fcpClient.next()	
-		
+			
 		# now the request should have been removed
 		self.failIf(self.fcpClient.getRequests())
 		
-		self.failIf(self.hasNextEvent() )
+		# client never sends an event here
+		self.assertHasNextEvent(None)
+
+#***********************************************************************************
+#
+#***********************************************************************************
+#TODO: testRestoreClientPut and friends
+class TestRestoreRequests(BaseTestConnectedClient):
 	
-	
-	####################################################
-	##
-	## modifyRequest test cases
-	##
-	####################################################	
-	
-	
-	####################################################
-	##
-	## removeRequest test cases
-	##
-	####################################################	
-	
+	def testRestorePersistentGet_InvalidIdentifier(self):
 		
-		
-		
-	####################################################
-	##
-	## restore persistent request test cases
-	##
-	## should be run after removeRequest test cases
-	###
-	####################################################
-	def testRestorePersistentRequest_InvalidIdentifier(self):
-		
-		self.connectClient()
-		
 		# throw an invalid PersistentRequest at the client
 		myIdentifier = 'true-invalid-request-identifier'
-		self.socket.setResponseMessage(
+		self.sendResponseMessage(
 				'PersistentGet',
 				Identifier=myIdentifier,
 				ReturnType='disk',
@@ -401,27 +591,23 @@
 				Started='false',
 				Global='false',
 				)
-		self.fcpClient.next()
-	
+		
 		# the client should now to cancel the request
-		msg = self.nextMessage()
-		self.failIf(msg is None)
-		self.assertEqual(msg.name, self.fcpClient.Message.MessageRemovePersistentRequest)
-		self.failUnless(msg['Identifier'] == myIdentifier)
+		self.assertHasNextMessage(
+				consts.Message.RemovePersistentRequest,
+				('Identifier', myIdentifier)
+				)
 		
 		requests = self.fcpClient.getRequests()
 		self.failIf(requests)
 				
 		# the client should not trigger any events
-		self.failIf(self.hasNextEvent() )
-	
-	
-	def testRestorePersistentRequest_ValidIdentifier(self):	
-		
-		self.connectClient()
-		
+		self.assertHasNextEvent(None)
+
+
+	def testRestorePersistentGet_ValidIdentifier(self):	
+			
 		# we need a valid identifier to restore a request, so hack a bit
-		
 		myIdentifier = self.fcpClient.getFile(
 			'arbitrary-uri',
 			'arbitryry.txt'
@@ -430,17 +616,16 @@
 		identifier = myRequest['Identifier']
 				
 		self.fcpClient.removeRequest(myIdentifier)
-		self.socket.setResponseMessage(
+		self.sendResponseMessage(
 				'PersistentRequestRemoved',
 				Identifier=identifier,
 				)
-		self.fcpClient.next()
 		self.messages = []
 		self.events = []
 		
 		
 		# throw a PersistentGet at the client with the identifier we hacked
-		self.socket.setResponseMessage(
+		self.sendResponseMessage(
 				'PersistentGet',
 				Identifier=identifier,
 				ReturnType='disk',
@@ -449,47 +634,127 @@
 				Started='false',
 				ClientToken=myRequest['ClientToken']
 				)
-		self.fcpClient.next()
-		
+				
 		# check if the client restored the request
-		event, msg = self.nextEvent()
-		self.failIf(event is None)
-		self.assertEqual(event, self.fcpClient.events.RequestRestored)
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestRestored,
+				consts.Message.ClientGet,
+				('Identifier', myIdentifier)
+				)
 		
-		requests = self.fcpClient.getRequests()
-		self.failUnless(requests)
-		self.assertEqual(identifier, requests[msg['Identifier']]['Identifier'])
+		self.assertHasNextEvent(None)
+				
+#***********************************************************************************
+#
+#***********************************************************************************
+#TODO: testDDAReadDenied_ReadDissallowed
+#TODO: testDDAWriteDenied
+#TODO: testDDAWriteDenied_WriteDisallowed
+
+class TestDDA(BaseTestConnectedClient):
+	
+	def testDDAWriteDenied(self):
+				
+		# request a file
+		myIdentifier = self.fcpClient.getFile(
+			'arbitrary-uri',
+			os.path.join(DIR, 'DDATest.txt')
+			)
 		
-		self.failIf(self.hasNextEvent() )
+		# client schould send a ClientGet
+		self.assertHasNextMessage(consts.Message.ClientGet)
 				
+		# respond with a ProtocolError
+		self.sendResponseMessage(
+				'ProtocolError',
+				Code=25,		# DDADenied
+				Identifier=myIdentifier,
+				ExtraDescription='An error occured',
+				Fatal='false',
+				Global='false',
+				)
+				
+		# client should respond with a TestDDARequest
+		self.assertHasNextMessage(
+				 consts.Message.TestDDARequest,
+				 ('Directory', DIR),
+				 ('WantWriteDirectory', True)
+				)
 		
-	####################################################
-	##
-	## error test cases
-	##
-	####################################################
-	def testBrokenSocket(self):
+		#msg = self.nextMessage()
+		#self.failIf(msg is None)
+		#self.assertEqual(msg.name, consts.Message.TestDDARequest)
+		##self.assertEqual(msg['Directory'], DIR)
+		#self.failIf(not msg['WantWriteDirectory'])
 		
-		self.connectClient()
-		self.socket.close()
 		
-		# send a test message
-		self.assertRaises(socket.error, self.fcpClient.sendMessage, 'test' )
+		# respond with a TestDDAReply message
+		writeContent = 'blah'
+		fd, fpath = tempfile.mkstemp(dir=DIR)
+		os.close(fd)
+		self.sendResponseMessage(
+				'TestDDAReply',
+				Directory=DIR,
+				WriteFilename=fpath,
+				ContentToWrite=writeContent,
+				)
+				
+		# client should respond with a TestDDAResponse
+		self.assertHasNextMessage(
+				consts.Message.TestDDAResponse,
+				('Directory', DIR)
+				)
+				
+		# check if content was written
+		with open(fpath) as fp:
+			self.failUnless(fp.read() == writeContent)
+					
+		# respond with a TestDDAComplete message
+		self.sendResponseMessage(
+				'TestDDAComplete',
+				Directory=DIR,
+				WriteDirectoryAllowed='true',
+				)
+				
+		# check if our tempfile was removed
+		self.failIf(os.path.isfile(fpath))
+				
+		# client sahould send a new ClientGet
+		msg = self.assertHasNextMessage(consts.Message.ClientGet)
+						
+		# no events should have been triggered upo to now
+		self.assertHasNextEvent(None)
 		
-		# check if ClientDisconnected events has been triggered
-		event, msg = self.nextEvent()
-		self.failIf(event is None)
-		self.assertEqual(event, self.fcpClient.events.ClientDisconnected)
-		self.assertEqual(msg.name, self.fcpClient.Message.MessageClientSocketDied)
+		# respond with a PersistentGet
+		self.sendResponseMessage(
+				'PersistentGet',
+				Started='false',
+				**msg.params
+				)
+				
+		# check if client send expected events
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestStarted,
+				consts.Message.ClientGet,
+				('Identifier', myIdentifier)
+				)
+		self.assertHasNextEvent(None)
 		
-		self.failIf(self.hasNextEvent() )
+		requests = self.fcpClient.getRequests()
+		self.assertEqual(len(requests), 1)
+
+
+	#def testDDAReadDenied(self):
 		
-		
+	#	pass
+
+#***********************************************************************************
+#
+#***********************************************************************************
+class TestCollisions(BaseTestConnectedClient):
 	
 	def testIdentifierCollision(self):	
-		
-		self.connectClient()
-		
+				
 		# request a file
 		myIdentifier = self.fcpClient.getFile(
 			'arbitrary-uri',
@@ -497,50 +762,37 @@
 			)
 		
 		# client schould send a ClientGet
-		msg = self.nextMessage()
-		self.failIf(msg is None)
-		self.assertEqual(msg.name, self.fcpClient.Message.MessageClientGet)
+		self.assertHasNextMessage(consts.Message.ClientGet)
 		
-		# check if our request was registered
-		requests = self.fcpClient.getRequests()
-		self.failUnless(len(requests) == 1)
 				
 		# respond with an IdentifierCollision
-		self.socket.setResponseMessage(
+		self.sendResponseMessage(
 				'IdentifierCollision',
-				Identifier=msg['Identifier']
+				Identifier=myIdentifier,
 				)
-		self.fcpClient.next()
-				
+						
 		# client schould send a new ClientGet
-		msg2 = self.nextMessage()
-		self.failIf(msg2 is None)
-		self.assertEqual(msg2.name, self.fcpClient.Message.MessageClientGet)
-				
+		self.assertHasNextMessage(consts.Message.ClientGet)
+		
 		# check client state
 		requests = self.fcpClient.getRequests()
 		self.assertEqual(len(requests), 1)
 		
 		# check if RequestModified event has been triggered
-		event, eventMsg = self.nextEvent()
-		self.failIf(event is None)
-		self.assertEqual(event, self.fcpClient.events.RequestModified)
-		self.failUnless(self.fcpClient.Message.ModifiedRequestIdentifier in eventMsg['FcModified'])
-		self.assertEqual(eventMsg['FcModified'][self.fcpClient.Message.ModifiedRequestIdentifier], myIdentifier)
-		self.assertNotEqual(eventMsg['Identifier'], myIdentifier)
+		msg = self.assertHasNextEvent(
+				self.fcpClient.events.RequestModified,
+				consts.Message.ClientGet,
+				)
 				
-		self.failIf(self.events)
+		self.failUnless(consts.RequestModified.Identifier in msg['FcModified'])
+		self.assertEqual(msg['FcModified'][consts.RequestModified.Identifier], myIdentifier)
+		self.assertNotEqual(msg['Identifier'], myIdentifier)
+				
+		self.assertHasNextEvent(None)
 		
 	
-	####################################################
-	##
-	## test filename collisions
-	##
-	####################################################
 	def testFilenameCollision_HandleRename(self):
-		
-		self.connectClient()
-		
+				
 		# request a file
 		fpath = os.path.join(DIR, 'test.txt')
 		open(fpath, 'wb').close()
@@ -549,62 +801,49 @@
 		myIdentifier = self.fcpClient.getFile(
 			'arbitrary-uri',
 			fpath,
-			filenameCollision=self.fcpClient.FilenameCollision.HandleRename,
+			filenameCollision=consts.FilenameCollision.HandleRename,
 			)
 		
 		# client schould send a ClientGet
-		msg = self.nextMessage()
-		self.failIf(msg is None)    
-		self.assertEqual(msg.name, self.fcpClient.Message.MessageClientGet)
+		self.assertHasNextMessage(consts.Message.ClientGet)
 		
 		# check if our request was registered
 		requests = self.fcpClient.getRequests()
 		self.failUnless(len(requests) == 1)
 				
 		# now respond with a ProtocolError
-		self.socket.setResponseMessage(
+		self.sendResponseMessage(
 				'ProtocolError',
-				Identifier=msg['Identifier'],
+				Identifier=myIdentifier,
 				Code='10', 		# disk target exists
 				ExtraDescription='An error occured',
 				Fatal='false',
 				Global='false',
 				)
-		self.fcpClient.next()
-		
+				
 		# client schould send a new ClientGet with a differing filename
-		msg2 = self.nextMessage()
-		self.failIf(msg2 is None)    
-		self.assertEqual(msg2.name, self.fcpClient.Message.MessageClientGet)
+		msg = self.assertHasNextEvent(
+				self.fcpClient.events.RequestModified, 
+				consts.Message.ClientGet
+				)
+				
+		self.failUnless(consts.RequestModified.Filename in msg['FcModified'])
+		self.assertEqual(msg['FcModified'][consts.RequestModified.Filename], fpath)
+		self.assertNotEqual(msg['Filename'], fpath)
 		
-		# check if filename was replaced
-		self.failIf(msg['Filename'] == msg2['Filename'])
-		
-		event, eventMsg = self.nextEvent()
-		self.failIf(event is None)
-		self.assertEqual(event, self.fcpClient.events.RequestModified)
-		self.failUnless(self.fcpClient.Message.ModifiedRequestFilename in eventMsg['FcModified'])
-		self.assertEqual(eventMsg['FcModified'][self.fcpClient.Message.ModifiedRequestFilename], fpath)
-		self.assertNotEqual(eventMsg['Filename'], fpath)
-		
 		# check flags
-		filenameCollision = eventMsg['FcFilenameCollision']
+		filenameCollision = msg['FcFilenameCollision']
 		self.assertEqual(
-				filenameCollision & self.fcpClient.FilenameCollision.MaskHandle, 
-				self.fcpClient.FilenameCollision.HandleRename
+				filenameCollision & consts.FilenameCollision.MaskHandle, 
+				consts.FilenameCollision.HandleRename
 				)
-		self.failUnless(filenameCollision & self.fcpClient.FilenameCollision.CollisionHandled)
+		self.failUnless(filenameCollision & consts.FilenameCollision.CollisionHandled)
 		
+		self.assertHasNextEvent(None)
 		
-		self.failIf(self.events)
-				
-		
 	
-	
 	def testFilenameCollision_HandleNever(self):
-		
-		self.connectClient()
-		
+				
 		# request a file
 		fpath = os.path.join(DIR, 'test.txt')
 		open(fpath, 'wb').close()
@@ -613,169 +852,92 @@
 		myIdentifier = self.fcpClient.getFile(
 			'arbitrary-uri',
 			fpath,
-			filenameCollision=self.fcpClient.FilenameCollision.HandleNever,
+			filenameCollision=consts.FilenameCollision.HandleNever,
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		
 		# client schould send a ClientGet
-		msg = self.nextMessage()
-		self.failIf(msg is None)    
-		self.assertEqual(msg.name, self.fcpClient.Message.MessageClientGet)
+		self.assertHasNextMessage(consts.Message.ClientGet)
 		
 		# check if our request was registered
 		requests = self.fcpClient.getRequests()
 		self.failUnless(len(requests) == 1)
 				
 		# now respond with a ProtocolError
-		self.socket.setResponseMessage(
+		self.sendResponseMessage(
 				'ProtocolError',
-				Identifier=msg['Identifier'],
+				Identifier=myIdentifier,
 				Code='10', 		# disk target exists
 				ExtraDescription='An error occured',
 				Fatal='false',
 				Global='false',
 				)
-		self.fcpClient.next()
-		
+				
 		# client schould send no messages and trigger a RequestFailed event
-		msg2 = self.nextMessage()
-		self.failUnless(msg2 is None)    
-				
-		event, eventMsg = self.nextEvent()
-		self.failIf(event is None)
-		self.assertEqual(event, self.fcpClient.events.RequestFailed)
-		#TODO: more checks here
+		self.assertHasNextEvent(self.fcpClient.events.RequestFailed)
 		
 		# request should have been removed
 		self.failIf(self.fcpClient.getRequests())
 		
-		self.failIf(self.events)
+		self.assertHasNextEvent(None)
 		
-	####################################################
-	##
-	## DDA test cases
-	##
-	####################################################
-	def testDDAWriteDenied(self):
-		
-		self.connectClient()
-		
-		# request a file
-		myIdentifier = self.fcpClient.getFile(
-			'arbitrary-uri',
-			os.path.join(DIR, 'DDATest.txt')
-			)
-		
-				
-		# client schould send a ClientGet
-		msg = self.nextMessage()
-		self.failIf(msg is None)
-		self.assertEqual(msg.name, self.fcpClient.Message.MessageClientGet)
-		
-		# check client state
-		requests = self.fcpClient.getRequests()
-		self.failUnless(len(requests) == 1)
-		
-		# respond with a ProtocolError
-		self.socket.setResponseMessage(
-				'ProtocolError',
-				Code=25,		# DDADenied
-				Identifier=msg['Identifier'],
-				ExtraDescription='An error occured',
-				Fatal='false',
-				Global='false',
-				)
-		self.fcpClient.next()
-		
-		# client should respond with a TestDDARequest
-		msg = self.nextMessage()
-		self.failIf(msg is None)
-		self.assertEqual(msg.name, self.fcpClient.Message.MessageTestDDARequest)
-		self.assertEqual(msg['Directory'], DIR)
-		self.failIf(not msg['WantWriteDirectory'])
-		
-		
-		# respond with a TestDDAReply message
-		writeContent = 'blah'
-		fd, fpath = tempfile.mkstemp(dir=DIR)
-		os.close(fd)
-		self.socket.setResponseMessage(
-				'TestDDAReply',
-				Directory=msg['Directory'],
-				WriteFilename=fpath,
-				ContentToWrite=writeContent,
-				)
-		self.fcpClient.next()
-		
-		# client should respond with a TestDDAResponse
-		msg = self.nextMessage()
-		self.failIf(msg is None)
-		self.assertEqual(msg.name, self.fcpClient.Message.MessageTestDDAResponse)
-		self.assertEqual(msg['Directory'], DIR)
-		
-		# check if content was written
-		with open(fpath) as fp:
-			self.failUnless(fp.read() == writeContent)
-					
-		# respond with a TestDDAComplete message
-		self.socket.setResponseMessage(
-				'TestDDAComplete',
-				Directory=msg['Directory'],
-				WriteDirectoryAllowed='true',
-				)
-		self.fcpClient.next()
-		
-		# check if our tempfile was removed
-		self.failIf(os.path.isfile(fpath))
-				
-		# client sahould send a new ClientGet
-		msg = self.nextMessage()
-		self.failIf(msg is None)
-		self.assertEqual(msg.name, self.fcpClient.Message.MessageClientGet)
-				
-		# no events should have been triggered upo to now
-		self.failIf(self.events)
-		
-		# respond with a PersistentGet
-		self.socket.setResponseMessage(
-				'PersistentGet',
-				Started='false',
-				**msg.params
-				)
-		self.fcpClient.next()		
-		
-		# check if client send expected events
-		event, eventMsg = self.nextEvent()
-		self.failIf(event is None)
-		self.assertEqual(event, self.fcpClient.events.RequestStarted)
-				
-		# check client state
-		self.failUnless(msg['Identifier'] == myIdentifier)
-		requests = self.fcpClient.getRequests()
-		self.assertEqual(len(requests), 1)
-		
-	####################################################
-	##
-	## 
-	##
-	####################################################
-				
+#***********************************************************************************
+#
+#***********************************************************************************
+#TODO: class TestNodeAndPeers(BaseTestConnectedClient):		
 
+#***********************************************************************************
+#
+#***********************************************************************************
+#TODO: class TestPlugins(BaseTestConnectedClient):	
+
+#***********************************************************************************
+#TODO: class TestConfig(BaseTestConnectedClient):	
+
+#***********************************************************************************
+#
+#***********************************************************************************
+#TODO: class TestSSKKeypair(BaseTestConnectedClient):	
+
+#***********************************************************************************
+#
+#***********************************************************************************
+#TODO: class TestSubscribeUSK(BaseTestConnectedClient):
+
+
+	
 #*********************************************************************************
 #
 #*********************************************************************************
 def suite():
-	return unittest.TestLoader().loadTestsFromTestCase(TestFcpClient)
 	
+	tests = (
+			TestConnect,
+			TestConnection,
+			TestClientGet,
+			TestRequests,
+			TestRestoreRequests,
+			TestDDA,
+			TestCollisions,
+			)
+	
+	suite = unittest.TestSuite()
+	for test in tests:
+		suite.addTest(unittest.makeSuite(test))
+	return suite
+	
 def test():
-	unittest.main()
+	unittest.TextTestRunner(verbosity=1).run(suite())
 
-if __name__ == '__main__':
-	test()
 
+if __name__ == "__main__":
+    test()
 
+	
 
 
 
 
 
+
+


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.