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

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

Revision: 204
          http://fclient.svn.sourceforge.net/fclient/?rev=204&view=rev
Author:   jurner
Date:     2008-02-11 02:55:27 -0800 (Mon, 11 Feb 2008)

Log Message:
-----------
reworked tests. In theory it is now possible to test against the running node

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-11 10:54:36 UTC (rev 203)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-11 10:55:27 UTC (rev 204)
@@ -26,40 +26,114 @@
 del parentdir
 #<-- rel import hack
 
-
 from dummy_socket import DummySocket
+#***********************************************************************************
+#
+#***********************************************************************************	
+DIR = os.path.dirname(os.path.abspath(__file__))
+TestAgainstNode = 0		# don't know how to test against node. Do not touch this!
 
+#***********************************************************************************
+#
+#***********************************************************************************	
+class MyFcpClient(FcpClient):
+	"""Customized client recording all messages it sends
+	"""
+	def __init__(self, *args, **kwargs):
+		FcpClient.__init__(self, *args, **kwargs)
+		self.test_messagesSend = []
+	
+	def sendMessageEx(self, msg):
+		FcpClient.sendMessageEx(self, msg)
+		# deepcopy here, we need exact state
+		msg = copy.deepcopy(msg)
+		self.test_messagesSend.append(msg)
+			
+#***********************************************************************************
+#
+#***********************************************************************************	
+class DummySocketModule(object): 
+	"""Dummy socket module we inject into the client module for testing
+	
+	"""
+	AF_INET = socket.AF_INET
+	SOCK_STREAM = socket.SOCK_STREAM
+	error = socket.error
+	socket = DummySocket()
+	
+	def __init__(self):
+		self.lastSocket = None
+		
+	def __getattribute__(self, name):
+		obj = object.__getattribute__(self, name)
+		if name == 'socket':
+			self.lastSocket = obj
+		return obj
+		
+#***********************************************************************************
+#
+#***********************************************************************************	
+class MySocketFactory(object):
+	"""Real and alive socket. Can be used to test against the running node. Not used currently
+	
+	Usage:
 
-DIR = os.path.dirname(os.path.abspath(__file__))
+		DummySocketModule.socket = MySocketFactory()
+	
+	"""
+	def __init__(self, *args, **kwargs):
+		self.socket = None
+		self.closed = False
+		
+	def __call__(self, *args, **kwargs):
+		self.socket = socket.socket(*args, **kwargs)
+		return self
+		
+	def sendResponseMessage(self, *args, **kwargs):
+		pass
+		
+	def connect(self, *args, **kwargs):
+		return self.socket.connect(*args, **kwargs)
+	
+	def sendall(self, bytes):
+		return self.socket.sendall(bytes)
+		
+	def settimeout(self, n):
+		return self.socket.settimeout(n)
+	
+	def recv(self, n):
+		return self.socket.recv(n)
+		
+	def close(self):
+		self.closed = True
+		result = self.socket.close()
+		self.socket = None
+		return result
+
 #***********************************************************************************
 #
 #***********************************************************************************
 class BaseTestClient(unittest.TestCase):
-	"""Base class that does not connect to FcpClient prior to each test"""
+	"""Base class for all tests"""
 		
+	if TestAgainstNode:
+		DummySocketModule.socket = MySocketFactory()
+	fcpClient = MyFcpClient(
+						#debugVerbosity=FcpClient.consts.DebugVerbosity.Debug
+						)
+	
+	# inject our customized socket module 
+	socketModule = DummySocketModule()
+	fcp2_0_client.socket = 	socketModule
+	
+	
 	def __init__(self, *args, **kwargs):
 		unittest.TestCase.__init__(self, *args, **kwargs)
 		
-		# replace socket module with our dummy socket module
-		self.oldSocketModule = None
-		self.socket = DummySocket()
-		class DummySocketModule(object): 
-			AF_INET = socket.AF_INET
-			SOCK_STREAM = socket.SOCK_STREAM
-			error = socket.error
-			socket = self.socket
-		self.socketModule = DummySocketModule
-		
-		self.fcpClient = None			# client to test
 		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 _captureMessagesFromClient(self, bytes):
-		s = DummySocket()
-		s.setResponse(bytes)
-		self.messages.append(self.fcpClient.Message.fromSocket(s))
-	
+		
 	def _captureEventsFromClient(self, event, msg):
 		# have to copy message here, to get exact state
 		msg = copy.deepcopy(msg)
@@ -67,27 +141,34 @@
 		
 	def connectClient(self):
 		"""Connects to the client"""
-		enum = self.fcpClient.iterConnect(duration=0.2, timeout=0.1)
-		msg = enum.next()
-		self.failIf(msg is not None)
-		#NOTE: have to send directly via socket here (our sendResponseMessage
-		# calls client.next() autkmatically)
-		self.socket.sendResponseMessage(
-				'NodeHello',
-				FCPVersion='2.0',
-				Node='Fred',
-				Version=str(self.fcpClient.ExpectedFcpVersion),
-				Revision='999999999999',
-				Build='999999',
-				ExRevision='9999999999',
-				Testnet='false',
-				CompressionCodecs='1',
-				ConnectionIdentifier='any',
-				NodeLanguage='en',
+		for n, nodeHello in enumerate(self.fcpClient.iterConnect(duration=20, timeout=0.1)):
+			if n == 0:
+				self.assertHasNextMessage(
+					consts.Message.ClientHello
+					)
+				self.sendResponseMessage(
+						'NodeHello',
+						FCPVersion='2.0',
+						Node='Fred',
+						Version=str(self.fcpClient.ExpectedFcpVersion),
+						Revision='999999999999',
+						Build='9999999999',
+						ExRevision='9999999999',
+						Testnet='false',
+						CompressionCodecs='1',
+						ConnectionIdentifier='any',
+						NodeLanguage='en',
+						
+						callNext=False,
+						)
+					
+		# check events the client triggered
+		self.assertHasNextEvent(
+				self.fcpClient.events.ClientConnected,
+				consts.Message.NodeHello,
 				)
-		msg = enum.next()
-		self.messages.pop(0)
-		self.events.pop(0)
+		
+		self.assertHasNextEvent(None)
 	
 	def assertHasNextEvent(self, 
 			expectedEvent=None, 
@@ -159,10 +240,10 @@
 		@return: message if a message was received or None
 		"""
 		if messageName is None:
-			self.failIf(self.messages)
+			self.failIf(self.fcpClient.test_messagesSend)
 		else:
-			self.failUnless(self.messages)
-			msg = self.messages.pop(0)
+			self.failUnless(self.fcpClient.test_messagesSend)
+			msg = self.fcpClient.test_messagesSend.pop(0)
 			self.assertEqual(msg.name, messageName)
 			if param1 is not None:
 				param1, value1 = param1
@@ -189,29 +270,20 @@
 				self.assertEqual(data, msg.data)
 			return msg
 		
-	def sendResponseMessage(self, messageName, data=None, **params):
+	def sendResponseMessage(self, messageName, data=None, callNext=True, **params):
 		"""Posts a message to the client"""
-		self.socket.sendResponseMessage(messageName, data=data, **params)
-		self.fcpClient.next()
+		self.socketModule.lastSocket.sendResponseMessage(messageName, data=data, **params)
+		if not TestAgainstNode:
+			if callNext:
+				self.fcpClient.next()
 		
 	def setUp(self):
-		self.oldSocketModule = fcp2_0_client.socket
-		fcp2_0_client.socket = 	self.socketModule
-		
-		self.fcpClient = FcpClient()
-		
 		# conect all events
 		self.events = []		# events received from the client
 		for event in self.fcpClient.events:
 			event += self._captureEventsFromClient
-	
-		# capture all messages the client sent
-		self.messages = []		# messages the client send
-		self.socket.setBytesReceiver(self._captureMessagesFromClient)
 			
 	def tearDown(self):
-		fcp2_0_client.socket = self.oldSocketModule
-		
 		# disconnect all events
 		for event in self.fcpClient.events:
 			event -= self._captureEventsFromClient
@@ -221,17 +293,6 @@
 #***********************************************************************************
 #
 #***********************************************************************************
-class BaseTestConnectedClient(BaseTestClient):
-	"""Base class that automatically connects to FcpClient prior to each test"""
-	
-	def setUp(self):
-		BaseTestClient.setUp(self)
-		self.connectClient()
-		
-	
-#***********************************************************************************
-#
-#***********************************************************************************
 #TODO: class Test.... set/getDebugVerbosity / connectionName and friends...  (BaseTestConnectedClient):
 
 #***********************************************************************************
@@ -240,7 +301,7 @@
 class TestConnect(BaseTestClient):
 	
 	
-	def testClose(self):
+	def XXXtestClose(self):
 		self.failIf(self.socket.closed)
 		self.connectClient()
 		self.fcpClient.close()
@@ -248,11 +309,16 @@
 	
 	
 	
-	def testConnect(self):
-		nodeHello = self.fcpClient.connect(duration=0.2, timeout=0.1)
+	def XXXtestConnect(self):
+		nodeHello = self.fcpClient.connect(duration=10, timeout=0.1)
+		self.failIf(nodeHello is None)
+		return
+		
+		
+		nodeHello = self.fcpClient.connect(duration=0, timeout=0)
 		self.failIf(nodeHello is not None)
 		
-		self.socket.sendResponseMessage(
+		self.socketModule.lastSocket.sendResponseMessage(
 				'NodeHello',
 				FCPVersion='2.0',
 				Node='Fred',
@@ -265,68 +331,57 @@
 				ConnectionIdentifier='any',
 				NodeLanguage='en',
 				)
-		nodeHello = self.fcpClient.connect(duration=0.2, timeout=0.1)
+		nodeHello = self.fcpClient.connect(duration=10, timeout=0.1)
 		self.failIf(nodeHello is None)
 				
 	
-	def testIterConnect_Failure(self):
+	def test_0_IterIterConnect_RFailure(self):
 		
-		# simulate a failed connection attempt
-		enum = self.fcpClient.connect(duration=0.2, timeout=0.1)
-		t0 = time.time()
-		while time.time() - t0 < 1:
-			try:
-				nodeHello = enum.next()
-			except: break
-		else:
-			raise RuntimeError('Fell trough')
+		# we cannot test against node here
+		if not TestAgainstNode:
 		
-				
-		# check messages the client send
-		self.assertHasNextMessage(consts.Message.ClientHello)
-						
-		# check events the client triggered
-		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)
+			for n, nodeHello in enumerate(self.fcpClient.iterConnect(duration=1, timeout=0.1)):
+				if n == 0:
+					self.assertHasNextMessage(
+						consts.Message.ClientHello
+						)
 			
-	
-	def testIterConnect_Success(self):
+			# check events the client triggered
+			self.assertHasNextEvent(
+					self.fcpClient.events.ClientDisconnected,
+					consts.Message.ClientDisconnected,
+					('DisconnectReason', consts.DisconnectReason.ConnectingFailed),
+					)
+			
+			self.assertHasNextEvent(None)
+			self.assertHasNextMessage(None)
+			self.failUnless(self.socketModule.lastSocket.closed)
+			
+			#self.fcpClient.connect(duration=20, timeout=0.1)
+			
 		
-		# simulate a successful connection attempt
-		enum = self.fcpClient.iterConnect(duration=0.2, timeout=0.1)
-		msg = enum.next()
-		self.failIf(msg is not None)
-		
-		# 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=str(self.fcpClient.ExpectedFcpVersion),
-				Revision='999999999999',
-				Build='9999999999',
-				ExRevision='9999999999',
-				Testnet='false',
-				CompressionCodecs='1',
-				ConnectionIdentifier='any',
-				NodeLanguage='en',
-				)
-		msg = enum.next()
+	def test_1_IterConnect_Success(self):
+		for n, nodeHello in enumerate(self.fcpClient.iterConnect(duration=20, timeout=0.1)):
+			if n == 0:
+				self.assertHasNextMessage(
+					consts.Message.ClientHello
+					)
+				self.sendResponseMessage(
+						'NodeHello',
+						FCPVersion='2.0',
+						Node='Fred',
+						Version=str(self.fcpClient.ExpectedFcpVersion),
+						Revision='999999999999',
+						Build='9999999999',
+						ExRevision='9999999999',
+						Testnet='false',
+						CompressionCodecs='1',
+						ConnectionIdentifier='any',
+						NodeLanguage='en',
 						
+						callNext=False,
+						)
+					
 		# check events the client triggered
 		self.assertHasNextEvent(
 				self.fcpClient.events.ClientConnected,
@@ -334,13 +389,14 @@
 				)
 		
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
 	
 #***********************************************************************************
 #
 #***********************************************************************************
-class TestDisconnectReason(BaseTestConnectedClient):
+class TestDisconnectReason(BaseTestClient):
 	
-	def testDuplicateClientName(self):
+	def test_1000_DuplicateClientName(self):
 		
 		self.sendResponseMessage('CloseConnectionDuplicateClientName')
 		msg = self.assertHasNextEvent(
@@ -351,12 +407,16 @@
 		self.failUnless('Param' in msg.params)
 		self.assertEqual(msg['Param'], None)
 		
+		self.failUnless(self.socketModule.lastSocket.closed)
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		
+		self.connectClient()
 	
 	
-	def testSocketDied_Receive(self):
+	def test_1001_SocketDied_Receive(self):
 		
-		self.socket.close()
+		self.socketModule.lastSocket.close()
 		self.fcpClient.next()
 		
 		# check if ClientDisconnected events has been triggered
@@ -369,12 +429,16 @@
 		self.failUnless('Param' in msg.params)
 		self.assertEqual(msg['Param'].name, consts.Message.ClientSocketDied)
 		
+		self.failUnless(self.socketModule.lastSocket.closed)
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		
+		self.connectClient()
 	
 	
-	def testSocketDied_Send(self):
+	def test_1002_SocketDied_Send(self):
 		
-		self.socket.close()
+		self.socketModule.lastSocket.close()
 		
 		# send a test message
 		self.assertRaises(socket.error, self.fcpClient.sendMessage, 'test' )
@@ -389,10 +453,13 @@
 		self.failUnless('Param' in msg.params)
 		self.assertEqual(msg['Param'].name, consts.Message.ClientSocketDied)
 		
+		self.failUnless(self.socketModule.lastSocket.closed)
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		self.connectClient()
 		
 			
-	def testShutdown(self):
+	def test_1003_Shutdown(self):
 		
 		self.fcpClient.closeFreenet()
 		
@@ -412,10 +479,14 @@
 		self.failUnless('Param' in msg.params)
 		self.assertEqual(msg['Param'], None)
 		
+		self.failUnless(self.socketModule.lastSocket.closed)
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		self.connectClient()
 	
+		
 	
-	def testVersionMismatch(self):
+	def test_1004_VersionMismatch(self):
 		
 		# cheat a bit and reconnect client
 		enum = self.fcpClient.iterConnect(duration=0.2, timeout=0.1)
@@ -427,7 +498,7 @@
 		
 		#NOTE: have to send directly via socket here (our sendResponseMessage
 		# calls client.next() autkmatically)
-		self.socket.sendResponseMessage(
+		self.socketModule.lastSocket.sendResponseMessage(
 				'NodeHello',
 				FCPVersion='0.0',
 				Node='Fred',
@@ -439,6 +510,8 @@
 				CompressionCodecs='1',
 				ConnectionIdentifier='any',
 				NodeLanguage='en',
+				
+				callNext=False
 				)
 		msg = enum.next()
 						
@@ -452,31 +525,42 @@
 		self.failUnless('Param' in msg.params)
 		self.assertEqual(msg['Param'].name, consts.Message.NodeHello)
 		
+		self.failUnless(self.socketModule.lastSocket.closed)
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		self.connectClient()
 
 #***********************************************************************************
 #
 #***********************************************************************************
-class TestClientGet(BaseTestConnectedClient):
+class TestClientGet(BaseTestClient):
 	
-	def testClientGetRegistered(self):
+	def test_2000_ClientGetRegistered(self):
 				
 		# request a arbitrary file
 		myIdentifier = self.fcpClient.getData(
 			'arbitrary-uri',
 			)
-		self.assertHasNextMessage(
-				consts.Message.ClientGet,
-				)
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
+		
+		self.assertHasNextMessage(consts.Message.ClientGet)
 		self.assertHasNextEvent(None)
 				
-		self.failUnless(self.fcpClient.getRequests() )
+		self.failUnless(myIdentifier in requestsAll)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		self.assertEqual(myIdentifier, myRequest['Identifier'])
 		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Null)
 		
+		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		
+		del requestsAll[myIdentifier]
+		self.failIf(requestsAll)
+		
+		
 	
-	def testGetData_Success(self):
+	def test_2001_GetData_Success(self):
 						
 		# request a arbitrary file
 		myIdentifier = self.fcpClient.getData(
@@ -485,6 +569,8 @@
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		requestsAll = self.fcpClient.getRequests()		
 		
+		self.assertHasNextMessage(consts.Message.ClientGet)
+		
 		# respond to the file request
 		self.sendResponseMessage(
 				'PersistentGet',
@@ -567,18 +653,25 @@
 				)
 		self.failUnless(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
+		
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
 		
+		del requestsAll[myIdentifier]
+		self.failIf(requestsAll)
 		
-	def testGetData_Failure(self):
+		
+	def test_2002_GetData_Failure(self):
 						
 		# request a arbitrary file
 		myIdentifier = self.fcpClient.getData(
 			'arbitrary-uri',
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)		
-		requestsAll = self.fcpClient.getRequests()	
+		requestsAll = self.fcpClient.getRequests()
 		
+		self.assertHasNextMessage(consts.Message.ClientGet)
+		
 		# respond to the file request
 		self.sendResponseMessage(
 				'PersistentGet',
@@ -605,6 +698,7 @@
 				)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
 		
 		#return
 		
@@ -633,9 +727,13 @@
 		self.failUnless(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		
+		del requestsAll[myIdentifier]
+		self.failIf(requestsAll)
 	
 	
-	def testGetFile_Success(self):
+	def test_2003_GetFile_Success(self):
 						
 		# request a arbitrary file
 		myIdentifier = self.fcpClient.getFile(
@@ -676,9 +774,12 @@
 		self.failIf(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		
+		self.failIf(requestsAll)
 
 
-	def testGetFile_Failure(self):
+	def test_2004_GetFile_Failure(self):
 						
 		# request a arbitrary file
 		myIdentifier = self.fcpClient.getFile(
@@ -715,9 +816,12 @@
 		self.failIf(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
 		
+		self.failIf(requestsAll)
+		
 	
-	def testGetKeyInfo_Success(self):
+	def test_2005_GetKeyInfo_Success(self):
 		
 		# request a arbitrary uri
 		myIdentifier = self.fcpClient.getKeyInfo(
@@ -757,9 +861,12 @@
 		self.failIf(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
 		
+		self.failIf(requestsAll)
 		
-	def testGetKeyInfo_TooBig(self):
+		
+	def test_2006_GetKeyInfo_TooBig(self):
 				
 		# test specdial case where ProtocolError.TooBig is handled as success
 		# request a arbitrary uri
@@ -795,16 +902,21 @@
 				)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
 		
+		self.failIf(requestsAll)
+		
 					
 			
-	def testGetKeyInfo_Failure(self):
+	def test_2007_GetKeyInfo_Failure(self):
 						
 		# request a arbitrary file
 		myIdentifier = self.fcpClient.getKeyInfo(
 			'arbitrary-uri',
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
+		
 		self.assertHasNextMessage(consts.Message.ClientGet)
 				
 		# respond to the file request
@@ -831,6 +943,9 @@
 				)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		
+		self.failIf(requestsAll)
 
 #***********************************************************************************
 #
@@ -840,9 +955,9 @@
 #***********************************************************************************
 #
 #***********************************************************************************
-class TestRequests(BaseTestConnectedClient):
+class TestRequests(BaseTestClient):
 
-	def testModifyRequest_Persistent(self):
+	def test_3000_ModifyRequest_Persistent(self):
 				
 		# request a arbitrary file
 		myIdentifier = self.fcpClient.getFile(
@@ -853,6 +968,8 @@
 			persistence=consts.Persistence.Reboot,
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
+		
 		self.assertHasNextMessage(consts.Message.ClientGet)
 		
 		# respond to the file request
@@ -861,7 +978,9 @@
 				Started='false',
 				**myRequest.params
 				)
-						
+		#self.assertNextMessage(consts.Message.ClientGet)				
+		
+		
 		# test modify persistent user data
 		self.fcpClient.modifyRequest(myIdentifier, persistentUserData='bar', priorityClass=consts.Priority.High)
 		msg = self.assertHasNextMessage(consts.Message.ModifyPersistentRequest)
@@ -879,9 +998,13 @@
 		self.assertEqual(consts.Priority.High, myRequest['PriorityClass'])	
 		
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		
+		del requestsAll[myIdentifier]
+		self.failIf(requestsAll)
 	
 	
-	def testModifyRequest_NonPersistent(self):
+	def test_3001_ModifyRequest_NonPersistent(self):
 				
 		# request a arbitrary file
 		myIdentifier = self.fcpClient.getFile(
@@ -891,6 +1014,8 @@
 			priorityClass=consts.Priority.Medium,
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
+		
 		self.assertHasNextMessage(consts.Message.ClientGet)
 		
 		# respond to the file request
@@ -912,6 +1037,7 @@
 		#		'PersistentRequestModified',
 		#		**msg.params
 		#		)
+		
 		self.assertHasNextEvent(self.fcpClient.events.RequestModified)
 		
 		self.failUnless(consts.RequestModified.PersistentUserData in myRequest['FcModified'])
@@ -920,9 +1046,13 @@
 		#self.assertEqual(consts.Priority.High, myRequest['PriorityClass'])	
 		
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		
+		del requestsAll[myIdentifier]
+		self.failIf(requestsAll)
 	
 	
-	def testRemoveRequest_NonPersistent(self):
+	def test_3002_RemoveRequest_NonPersistent(self):
 				
 		# request a file
 		myIdentifier = self.fcpClient.getFile(
@@ -930,7 +1060,9 @@
 			'arbitrary.txt'
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
 				
+		self.assertHasNextMessage(consts.Message.ClientGet)
 		# respond to the file request
 		self.sendResponseMessage(
 				'PersistentGet',
@@ -962,9 +1094,12 @@
 				)
 		self.failIf(self.fcpClient.getRequests())
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		
+		self.failIf(requestsAll)
 
 	
-	def testRemoveRequest_persistent(self):
+	def test_3003_RemoveRequest_persistent(self):
 				
 		# request a file
 		myIdentifier = self.fcpClient.getFile(
@@ -973,7 +1108,10 @@
 			persistence=consts.Persistence.Reboot,
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
 				
+		self.assertHasNextMessage(consts.Message.ClientGet)
+		
 		# respond to the file request
 		self.sendResponseMessage(
 				'PersistentGet',
@@ -1015,10 +1153,13 @@
 		
 		self.failIf(self.fcpClient.getRequests())
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+				
+		self.failIf(requestsAll)
 
 	
 	
-	def testResendRequest_NonPersistent(self):
+	def test_3004_ResendRequest_NonPersistent(self):
 		
 		myIdentifier = self.fcpClient.getData('any-key')
 		myRequest = self.fcpClient.getRequest(myIdentifier)
@@ -1041,8 +1182,14 @@
 				
 		self.assertHasNextMessage(consts.Message.ClientGet)
 		
+		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		
+		del requestsAll[newIdentifier]
+		self.failIf(requestsAll)
+		
 			
-	def testResendRequest_Persistent(self):
+	def test_3005_ResendRequest_Persistent(self):
 		
 		myIdentifier = self.fcpClient.getData('any-key', persistence=consts.Persistence.Reboot)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
@@ -1077,14 +1224,17 @@
 		self.failUnless(newIdentifier in requestsAll)
 		self.failIf(myIdentifier in requestsAll)
 		
+		del requestsAll[newIdentifier]
+		self.failIf(requestsAll)
+		
 
 #***********************************************************************************
 #
 #***********************************************************************************
 #TODO: testRestoreClientPut and friends
-class TestRestoreRequests(BaseTestConnectedClient):
+class TestRestoreRequests(BaseTestClient):
 	
-	def testRestorePersistentGet_InvalidIdentifier(self):
+	def test_4000_RestorePersistentGet_InvalidIdentifier(self):
 		
 		# throw an invalid PersistentRequest at the client
 		myIdentifier = 'true-invalid-request-identifier'
@@ -1110,9 +1260,10 @@
 				
 		# the client should not trigger any events
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
 
 
-	def testRestorePersistentGet_ValidIdentifier(self):	
+	def test_4001_RestorePersistentGet_ValidIdentifier(self):	
 			
 		# we need a valid identifier to restore a request, so hack a bit
 		myIdentifier = self.fcpClient.getFile(
@@ -1122,6 +1273,8 @@
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		requestsAll = self.fcpClient.getRequests()
 					
+		self.assertHasNextMessage(consts.Message.ClientGet)
+		
 		self.fcpClient.removeRequest(myIdentifier)
 		self.sendResponseMessage(
 				'PersistentRequestRemoved',
@@ -1152,6 +1305,10 @@
 		
 		self.failUnless(myIdentifier in requestsAll) 
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		
+		del requestsAll[myIdentifier]
+		self.failIf(requestsAll)
 				
 #***********************************************************************************
 #
@@ -1160,15 +1317,17 @@
 #TODO: testDDAWriteDenied
 #TODO: testDDAWriteDenied_WriteDisallowed
 
-class TestDDA(BaseTestConnectedClient):
+class TestDDA(BaseTestClient):
 	
-	def testDDAWriteDenied(self):
+	def test_5000_DDAWriteDenied(self):
 				
 		# request a file
 		myIdentifier = self.fcpClient.getFile(
 			'arbitrary-uri',
 			os.path.join(DIR, 'DDATest.txt')
 			)
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
 		
 		# client schould send a ClientGet
 		self.assertHasNextMessage(consts.Message.ClientGet)
@@ -1243,6 +1402,12 @@
 				
 		requests = self.fcpClient.getRequests()
 		self.assertEqual(len(requests), 1)
+		
+		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		
+		del requestsAll[myIdentifier]
+		self.failIf(requestsAll)
 
 
 	#def testDDAReadDenied(self):
@@ -1252,15 +1417,17 @@
 #***********************************************************************************
 #
 #***********************************************************************************
-class TestCollisions(BaseTestConnectedClient):
+class TestCollisions(BaseTestClient):
 	
-	def testIdentifierCollision(self):	
+	def test_6000_IdentifierCollision(self):	
 				
 		# request a file
 		myIdentifier = self.fcpClient.getFile(
 			'arbitrary-uri',
 			os.path.join(DIR, 'test.txt')
 			)
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
 		
 		# client schould send a ClientGet
 		self.assertHasNextMessage(consts.Message.ClientGet)
@@ -1275,10 +1442,6 @@
 		# client schould send a new ClientGet
 		self.assertHasNextMessage(consts.Message.ClientGet)
 		
-		# check client state
-		requests = self.fcpClient.getRequests()
-		self.assertEqual(len(requests), 1)
-		
 		# check if RequestModified event has been triggered
 		msg = self.assertHasNextEvent(
 				self.fcpClient.events.RequestModified,
@@ -1286,13 +1449,19 @@
 				)
 				
 		self.failUnless(consts.RequestModified.Identifier in msg['FcModified'])
-		self.assertEqual(msg['FcModified'][consts.RequestModified.Identifier], myIdentifier)
-		self.assertNotEqual(msg['Identifier'], myIdentifier)
+		oldIdentifier = msg['FcModified'][consts.RequestModified.Identifier]
+		newIdentifier = msg['Identifier']
+		self.assertEqual(oldIdentifier, myIdentifier)
+		self.assertNotEqual(newIdentifier, myIdentifier)
 				
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+			
+		del requestsAll[newIdentifier]
+		self.failIf(requestsAll)
 		
 	
-	def testFilenameCollision_HandleRename(self):
+	def test_6001_FilenameCollision_HandleRename(self):
 				
 		# request a file
 		fpath = os.path.join(DIR, 'test.txt')
@@ -1304,14 +1473,12 @@
 			fpath,
 			filenameCollision=consts.FilenameCollision.HandleRename,
 			)
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
 		
 		# client schould send a ClientGet
 		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.sendResponseMessage(
 				'ProtocolError',
@@ -1322,7 +1489,8 @@
 				Global='false',
 				)
 				
-		# client schould send a new ClientGet with a differing filename
+		# client schould send a new ClientGet with a different filename
+		self.assertHasNextMessage(consts.Message.ClientGet)
 		msg = self.assertHasNextEvent(
 				self.fcpClient.events.RequestModified, 
 				consts.Message.ClientGet
@@ -1341,9 +1509,13 @@
 		self.failUnless(filenameCollision & consts.FilenameCollision.CollisionHandled)
 		
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
 		
+		del requestsAll[myIdentifier]
+		self.failIf(requestsAll)
+		
 	
-	def testFilenameCollision_HandleNever(self):
+	def test_6002_FilenameCollision_HandleNever(self):
 				
 		# request a file
 		fpath = os.path.join(DIR, 'test.txt')
@@ -1356,6 +1528,7 @@
 			filenameCollision=consts.FilenameCollision.HandleNever,
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
 		
 		# client schould send a ClientGet
 		self.assertHasNextMessage(consts.Message.ClientGet)
@@ -1381,7 +1554,10 @@
 		self.failIf(self.fcpClient.getRequests())
 		
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
 		
+		self.failIf(requestsAll)
+		
 #***********************************************************************************
 #
 #***********************************************************************************
@@ -1390,10 +1566,10 @@
 #***********************************************************************************
 #
 #***********************************************************************************
-class TestPlugins(BaseTestConnectedClient):
+class TestPlugins(BaseTestClient):
 	
 	
-	def testGetPluginInfo_Success(self):
+	def testGet_8000_PluginInfo_Success(self):
 		
 		myIdentifier = self.fcpClient.getPluginInfo('hi there')
 		myRequest = self.fcpClient.getRequest(myIdentifier)
@@ -1422,12 +1598,17 @@
 													),
 				)
 		
+		self.failIf(myIdentifier in requestsAll)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
+
 		self.assertHasNextEvent(None)
-		self.failIf(myIdentifier in requestsAll)
-		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)	
+		self.assertHasNextMessage(None)
+		
+		self.failIf(requestsAll)
+		
 	
 
-	def testGetPluginInfo_Failure(self):
+	def test_8001_GetPluginInfo_Failure(self):
 		myIdentifier = self.fcpClient.getPluginInfo('hi there')
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		requestsAll = self.fcpClient.getRequests()
@@ -1455,12 +1636,16 @@
 													),
 				)
 				
+		self.failIf(myIdentifier in requestsAll)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
+		
 		self.assertHasNextEvent(None)
-		self.failIf(myIdentifier in requestsAll)
-		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)	
+		self.assertHasNextMessage(None)
+		
+		self.failIf(requestsAll)
 	
 	
-	def testSendPluginMessage_Success(self):
+	def test_8002_SendPluginMessage_Success(self):
 		
 		myIdentifier = self.fcpClient.sendPluginMessage('hi there', {'foo': "bar"})
 		myRequest = self.fcpClient.getRequest(myIdentifier)
@@ -1493,12 +1678,16 @@
 		reply = msg['FcPluginReply']
 		self.failUnless(reply.params.get('baz', None) == '12345')
 				
-		self.assertHasNextEvent(None)
 		self.failIf(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)	
+		
+		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		
+		self.failIf(requestsAll)
 	
 
-	def testGetSendPluginMessage_Failure(self):
+	def test_8003_GetSendPluginMessage_Failure(self):
 		myIdentifier = self.fcpClient.sendPluginMessage('hi there', {'foo': "bar"})
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		requestsAll = self.fcpClient.getRequests()
@@ -1527,9 +1716,12 @@
 													),
 				)
 				
-		self.assertHasNextEvent(None)
 		self.failIf(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)	
+		
+		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		self.failIf(requestsAll)
 	
 
 #***********************************************************************************
@@ -1538,13 +1730,14 @@
 #***********************************************************************************
 #
 #***********************************************************************************
-class TestGenerateKeypair(BaseTestConnectedClient):
+class TestGenerateKeypair(BaseTestClient):
 	
-	def testGeberateSSKKeypair(self):
+	def test_10000_GeberateSSKKeypair(self):
 		myIdentifier = self.fcpClient.generateKeypair(consts.KeyType.SSK)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		requestsAll = self.fcpClient.getRequests()
 		
+		self.assertHasNextMessage(consts.Message.GenerateSSK)
 		self.sendResponseMessage(
 				'SSKKeypair',
 				Identifier=myIdentifier,
@@ -1562,16 +1755,20 @@
 													consts.RequestStatus.RemovedFromQueue
 													),
 				)
-		self.assertHasNextEvent(None)
 		self.failIf(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		
+		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		self.failIf(requestsAll)
 		
-	def testGeberateUSKKeypair(self):
+		
+	def test_10001_GeberateUSKKeypair(self):
 		myIdentifier = self.fcpClient.generateKeypair(consts.KeyType.USK)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		requestsAll = self.fcpClient.getRequests()
 		
+		self.assertHasNextMessage(consts.Message.GenerateSSK)
 		self.sendResponseMessage(
 				'SSKKeypair',
 				Identifier=myIdentifier,
@@ -1589,18 +1786,21 @@
 													consts.RequestStatus.RemovedFromQueue
 													),
 				)
-		self.assertHasNextEvent(None)
 		self.failIf(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)	
+		
+		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		self.failIf(requestsAll)
 	
 
 #***********************************************************************************
 #
 #***********************************************************************************
-class TestSubscribeUSK(BaseTestConnectedClient):
+class TestSubscribeUSK(BaseTestClient):
 
 
-	def testSubscribe(self):
+	def test_11000_Subscribe(self):
 		
 		myIdentifier = self.fcpClient.subscribeUSK('arbitrary')
 		myRequest = self.fcpClient.getRequest(myIdentifier)
@@ -1609,6 +1809,7 @@
 		self.failUnless(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		
+		self.assertHasNextMessage(consts.Message.SubscribeUSK)
 		self.sendResponseMessage(
 				'SubscribedUSKUpdate',
 				Identifier=myIdentifier,
@@ -1624,15 +1825,19 @@
 				('URI', 'arbitryry/99/'),
 				)
 		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
 		
+		del requestsAll[myIdentifier]
+		self.failIf(requestsAll)
 		
+		
 	
 #*********************************************************************************
 #
 #*********************************************************************************
 def suite():
-	
-	tests = (
+		
+	testCases = (
 			TestConnect,
 			TestDisconnectReason,
 			TestClientGet,
@@ -1647,8 +1852,8 @@
 			)
 	
 	suite = unittest.TestSuite()
-	for test in tests:
-		suite.addTest(unittest.makeSuite(test))
+	for testCase in testCases:
+		suite.addTest(unittest.makeSuite(testCase))
 	return suite
 	
 def test():


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