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

Status: Pre-Alpha

Brought to you by: jurner

fclient-commit

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

From: <ju...@us...> - 2008-01-30 13:23:25

Revision: 90
          http://fclient.svn.sourceforge.net/fclient/?rev=90&view=rev
Author:   jurner
Date:     2008-01-30 05:23:25 -0800 (Wed, 30 Jan 2008)

Log Message:
-----------
fix

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-01-30 13:22:48 UTC (rev 89)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-01-30 13:23:25 UTC (rev 90)
@@ -679,7 +679,7 @@
 		# respond with a ProtocolError
 		self.socket.setResponseMessage(
 				'ProtocolError',
-				Code='25',		# DDADenied
+				Code=25,		# DDADenied
 				Identifier=msg['Identifier'],
 				ExtraDescription='An error occured',
 				Fatal='false',
@@ -692,7 +692,7 @@
 		self.failIf(msg is None)
 		self.assertEqual(msg.name, self.fcpClient.Message.MessageTestDDARequest)
 		self.assertEqual(msg['Directory'], DIR)
-		self.assertEqual(msg['WantWriteDirectory'], 'true')
+		self.failIf(not msg['WantWriteDirectory'])
 		
 		
 		# respond with a TestDDAReply message


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

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

From: <ju...@us...> - 2008-02-02 18:27:37

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.sendResponseMessag...
 
[truncated message content]

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

From: <ju...@us...> - 2008-02-03 13:16:02

Revision: 127
          http://fclient.svn.sourceforge.net/fclient/?rev=127&view=rev
Author:   jurner
Date:     2008-02-03 05:16:02 -0800 (Sun, 03 Feb 2008)

Log Message:
-----------
a few more tests

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-03 13:14:59 UTC (rev 126)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-03 13:16:02 UTC (rev 127)
@@ -35,8 +35,7 @@
 #***********************************************************************************
 class BaseTestClient(unittest.TestCase):
 	"""Base class that does not connect to FcpClient prior to each test"""
-	
-	
+		
 	def __init__(self, *args, **kwargs):
 		unittest.TestCase.__init__(self, *args, **kwargs)
 		
@@ -65,7 +64,6 @@
 		
 	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)
@@ -76,9 +74,9 @@
 				FCPVersion='2.0',
 				Node='Fred',
 				Version=str(self.fcpClient.ExpectedFcpVersion),
-				Revision='99999999',
+				Revision='999999999999',
 				Build='999999',
-				ExRevision='999999',
+				ExRevision='9999999999',
 				Testnet='false',
 				CompressionCodecs='1',
 				ConnectionIdentifier='any',
@@ -88,7 +86,6 @@
 		self.messages.pop(0)
 		self.events.pop(0)
 	
-
 	def assertHasNextEvent(self, 
 			expectedEvent=None, 
 			messageName=None,
@@ -142,23 +139,22 @@
 				
 				return msg
 			
-		
 	def assertHasNextMessage(self, 
-			messageName, 
-			param1=None, 
-			param2=None, 
-			param3=None, 
-			param4=None, 
-			param5=None,
-			data=None
-			):
+		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
-			"""
+		@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:
@@ -188,14 +184,12 @@
 			if data is not None:
 				self.assertEqual(data, msg.data)
 			return msg
-			
-	
+		
 	def sendResponseMessage(self, messageName, data=None, **params):
 		"""Posts a message to the client"""
 		self.socket.sendResponseMessage(messageName, data=data, **params)
 		self.fcpClient.next()
 		
-
 	def setUp(self):
 		self.oldSocketModule = fcp2_0_client.socket
 		fcp2_0_client.socket = 	self.socketModule
@@ -211,9 +205,7 @@
 		# 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
 		
@@ -221,7 +213,6 @@
 		for eventName in self.fcpClient.Events._events_:
 			event = getattr(self.fcpClient.events, eventName)
 			event -= self._captureEventsFromClient
-		
 		# clean up tmpfiles
 		for fpath in self.tmpfiles: os.remove(fpath)
 
@@ -254,7 +245,7 @@
 		self.failUnless(self.socket.closed)
 	
 	
-	def testConnectFailed(self):
+	def testConnect_Failure(self):
 		
 		# simulate a failed connection attempt
 		enum = self.fcpClient.connect(duration=0.2, timeout=0.1)
@@ -281,10 +272,9 @@
 		
 		# did the client clean up our socket?
 		self.failUnless(self.socket.closed)
-		
-		
+			
 	
-	def testConnecSucceeded(self):
+	def testConnect_Success(self):
 		
 		# simulate a successful connection attempt
 		enum = self.fcpClient.connect(duration=0.2, timeout=0.1)
@@ -303,9 +293,9 @@
 				FCPVersion='2.0',
 				Node='Fred',
 				Version=str(self.fcpClient.ExpectedFcpVersion),
-				Revision='99999999',
-				Build='999999',
-				ExRevision='999999',
+				Revision='999999999999',
+				Build='9999999999',
+				ExRevision='9999999999',
 				Testnet='false',
 				CompressionCodecs='1',
 				ConnectionIdentifier='any',
@@ -321,32 +311,125 @@
 		
 		self.assertHasNextEvent(None)
 	
-
 #***********************************************************************************
 #
 #***********************************************************************************
-#TODO: testCloseOnVersionMismatch
-#TODO: testCloseOnDuplicateConnectionName
-#TODO: testShutdown
-
-class TestConnection(BaseTestConnectedClient):
+class TestDisconnectReason(BaseTestConnectedClient):
 	
-	def testBrokenSocket(self):
+	def testDuplicateClientName(self):
 		
+		self.sendResponseMessage('CloseConnectionDuplicateClientName')
+		msg = self.assertHasNextEvent(
+				self.fcpClient.events.ClientDisconnected,
+				consts.Message.ClientDisconnected,
+				('DisconnectReason', consts.DisconnectReason.DuplicateClientName),
+				)
+		self.failUnless('Param' in msg.params)
+		self.assertEqual(msg['Param'], None)
+		
+		self.assertHasNextEvent(None)
+	
+	
+	def testSocketDied_Receive(self):
+		
 		self.socket.close()
+		self.fcpClient.next()
 		
+		# check if ClientDisconnected events has been triggered
+		msg = self.assertHasNextEvent(
+				self.fcpClient.events.ClientDisconnected,
+				consts.Message.ClientDisconnected,
+				('DisconnectReason', consts.DisconnectReason.SocketDied),
+				#('Param', ClientSocketDiedMessage)		# can not test here
+				)
+		self.failUnless('Param' in msg.params)
+		self.assertEqual(msg['Param'].name, consts.Message.ClientSocketDied)
+		
+		self.assertHasNextEvent(None)
+	
+	
+	def testSocketDied_Send(self):
+		
+		self.socket.close()
+		
 		# send a test message
 		self.assertRaises(socket.error, self.fcpClient.sendMessage, 'test' )
 		
 		# check if ClientDisconnected events has been triggered
-		self.assertHasNextEvent(
+		msg = self.assertHasNextEvent(
 				self.fcpClient.events.ClientDisconnected,
-				consts.Message.ClientSocketDied,
+				consts.Message.ClientDisconnected,
+				('DisconnectReason', consts.DisconnectReason.SocketDied),
+				#('Param', ClientSocketDiedMessage)		# can not test here
 				)
+		self.failUnless('Param' in msg.params)
+		self.assertEqual(msg['Param'].name, consts.Message.ClientSocketDied)
+		
 		self.assertHasNextEvent(None)
-
+		
+			
+	def testShutdown(self):
+		
+		self.fcpClient.closeFreenet()
+		
+		msg = self.assertHasNextMessage(consts.Message.Shutdown)
+		self.sendResponseMessage(
+				'ProtocolError',
+				Code='18', 		# Shutting down
+				)
+				
+		# check events the client triggered
+		msg = self.assertHasNextEvent(
+				self.fcpClient.events.ClientDisconnected,
+				consts.Message.ClientDisconnected,
+				('DisconnectReason', consts.DisconnectReason.Shutdown)
+				#('Param', NodeHelloMessage)		# can not test here
+				)
+		self.failUnless('Param' in msg.params)
+		self.assertEqual(msg['Param'], None)
+		
+		self.assertHasNextEvent(None)
 	
 	
+	def testVersionMismatch(self):
+		
+		# cheat a bit and reconnect client
+		enum = self.fcpClient.connect(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='0.0',
+				Node='Fred',
+				Version=str(self.fcpClient.ExpectedFcpVersion),
+				Revision='0',
+				Build='0',
+				ExRevision='0',
+				Testnet='false',
+				CompressionCodecs='1',
+				ConnectionIdentifier='any',
+				NodeLanguage='en',
+				)
+		msg = enum.next()
+						
+		# check events the client triggered
+		msg = self.assertHasNextEvent(
+				self.fcpClient.events.ClientDisconnected,
+				consts.Message.ClientDisconnected,
+				('DisconnectReason', consts.DisconnectReason.VersionMissmatch)
+				#('Param', NodeHelloMessage)		# can not test here
+				)
+		self.failUnless('Param' in msg.params)
+		self.assertEqual(msg['Param'].name, consts.Message.NodeHello)
+		
+		self.assertHasNextEvent(None)
+
 #***********************************************************************************
 #
 #***********************************************************************************
@@ -369,7 +452,7 @@
 		self.assertEqual(myRequest['FcStatus'], consts.MessageStatus.Pending)
 		
 	
-	def testGetData(self):
+	def testGetData_Success(self):
 						
 		# request a arbitrary file
 		myIdentifier = self.fcpClient.getData(
@@ -429,14 +512,53 @@
 				)
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
+				consts.Message.ClientGet,
+				('FcStatus', consts.MessageStatus.Complete),
 				data=data
 				)
 		self.assertHasNextEvent(None)
 			
 	
-	def testgetFile(self):
+	def testGetData_Failure(self):
 						
 		# request a arbitrary file
+		myIdentifier = self.fcpClient.getData(
+			'arbitrary-uri',
+			)
+		myRequest = self.fcpClient.getRequest(myIdentifier)		
+		
+		# 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
+		self.sendResponseMessage(
+				'GetFailed',
+				Code='28',		# All data not found
+				Identifier=myIdentifier,
+				Global='false',
+				# blah.. more here
+				)
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestFailed,
+				consts.Message.ClientGet,
+				('FcStatus', consts.MessageStatus.Error)
+				)
+		self.assertHasNextEvent(None)
+		
+	
+	def testGetFile_Success(self):
+						
+		# request a arbitrary file
 		myIdentifier = self.fcpClient.getFile(
 			'arbitrary-uri',
 			'arbitryry.txt'
@@ -476,6 +598,142 @@
 				)
 		self.assertHasNextEvent(None)
 
+
+	def testGetFile_Failure(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
+		self.sendResponseMessage(
+				'GetFailed',
+				Code='28',		# All data not found
+				Identifier=myIdentifier,
+				Global='false',
+				# blah.. more here
+				)
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestFailed,
+				consts.Message.ClientGet,
+				('FcStatus', consts.MessageStatus.Error)
+				)
+		self.assertHasNextEvent(None)
+	
+	
+	
+	def testGetKeyInfo_Success(self):
+		
+		# request a arbitrary uri
+		myIdentifier = self.fcpClient.getKeyInfo(
+			'arbitrary-uri',
+			persistence=consts.Persistence.Forever,		# cheat a bit, so we can test multiple cases
+			)
+		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)
+		
+		# test specdial case where ProtocolError.TooBig is handled as success
+		self.sendResponseMessage(
+				'GetFailed',
+				Code='21',		# Too big
+				Identifier=myIdentifier,
+				Global='false',
+				# blah.. more here
+				)
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestCompleted,
+				consts.Message.ClientGet,
+				('FcStatus', consts.MessageStatus.Complete)
+				)
+		self.assertHasNextEvent(None)
+
+
+	def testGetKeyInfo_Failure(self):
+						
+		# request a arbitrary file
+		myIdentifier = self.fcpClient.getKeyInfo(
+			'arbitrary-uri',
+			)
+		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
+		self.sendResponseMessage(
+				'GetFailed',
+				Code='28',		# All data not found
+				Identifier=myIdentifier,
+				Global='false',
+				# blah.. more here
+				)
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestFailed,
+				consts.Message.ClientGet,
+				('FcStatus', consts.MessageStatus.Error)
+				)
+		self.assertHasNextEvent(None)
+
 #***********************************************************************************
 #
 #***********************************************************************************
@@ -585,6 +843,7 @@
 		self.sendResponseMessage(
 				'PersistentGet',
 				Identifier=myIdentifier,
+				Global='false',
 				ReturnType='disk',
 				Verbosity='1',
 				PersistenceType='forever',
@@ -622,12 +881,12 @@
 				)
 		self.messages = []
 		self.events = []
-		
-		
+				
 		# throw a PersistentGet at the client with the identifier we hacked
 		self.sendResponseMessage(
 				'PersistentGet',
 				Identifier=identifier,
+				Global='false',
 				ReturnType='disk',
 				Verbosity='1',
 				PersistenceType='forever',
@@ -913,7 +1172,7 @@
 	
 	tests = (
 			TestConnect,
-			TestConnection,
+			TestDisconnectReason,
 			TestClientGet,
 			TestRequests,
 			TestRestoreRequests,


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

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

From: <ju...@us...> - 2008-02-05 12:27:51

Revision: 148
          http://fclient.svn.sourceforge.net/fclient/?rev=148&view=rev
Author:   jurner
Date:     2008-02-05 04:27:53 -0800 (Tue, 05 Feb 2008)

Log Message:
-----------
adapt

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-05 12:27:18 UTC (rev 147)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-05 12:27:53 UTC (rev 148)
@@ -64,7 +64,7 @@
 		
 	def connectClient(self):
 		"""Connects to the client"""
-		enum = self.fcpClient.connect(duration=0.2, timeout=0.1)
+		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
@@ -198,8 +198,7 @@
 		
 		# conect all events
 		self.events = []		# events received from the client
-		for eventName in self.fcpClient.Events._events_:
-			event = getattr(self.fcpClient.events, eventName)
+		for event in self.fcpClient.events:
 			event += self._captureEventsFromClient
 	
 		# capture all messages the client sent
@@ -210,8 +209,7 @@
 		fcp2_0_client.socket = self.oldSocketModule
 		
 		# disconnect all events
-		for eventName in self.fcpClient.Events._events_:
-			event = getattr(self.fcpClient.events, eventName)
+		for event in self.fcpClient.events:
 			event -= self._captureEventsFromClient
 		# clean up tmpfiles
 		for fpath in self.tmpfiles: os.remove(fpath)
@@ -245,8 +243,30 @@
 		self.failUnless(self.socket.closed)
 	
 	
-	def testConnect_Failure(self):
+	
+	def testConnect(self):
+		nodeHello = self.fcpClient.connect(duration=0.2, timeout=0.1)
+		self.failIf(nodeHello is not None)
 		
+		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',
+				)
+		nodeHello = self.fcpClient.connect(duration=0.2, timeout=0.1)
+		self.failIf(nodeHello is None)
+				
+	
+	def testIterConnect_Failure(self):
+		
 		# simulate a failed connection attempt
 		enum = self.fcpClient.connect(duration=0.2, timeout=0.1)
 		t0 = time.time()
@@ -274,10 +294,10 @@
 		self.failUnless(self.socket.closed)
 			
 	
-	def testConnect_Success(self):
+	def testIterConnect_Success(self):
 		
 		# simulate a successful connection attempt
-		enum = self.fcpClient.connect(duration=0.2, timeout=0.1)
+		enum = self.fcpClient.iterConnect(duration=0.2, timeout=0.1)
 		msg = enum.next()
 		self.failIf(msg is not None)
 		
@@ -394,7 +414,7 @@
 	def testVersionMismatch(self):
 		
 		# cheat a bit and reconnect client
-		enum = self.fcpClient.connect(duration=0.2, timeout=0.1)
+		enum = self.fcpClient.iterConnect(duration=0.2, timeout=0.1)
 		msg = enum.next()
 		self.failIf(msg is not None)
 		
@@ -449,7 +469,7 @@
 		self.failUnless(self.fcpClient.getRequests() )
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		self.assertEqual(myIdentifier, myRequest['Identifier'])
-		self.assertEqual(myRequest['FcStatus'], consts.MessageStatus.Pending)
+		self.assertEqual(myRequest['FcStatus'], consts.RequestStatus.Pending)
 		
 	
 	def testGetData_Success(self):
@@ -469,7 +489,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestStarted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.MessageStatus.Started)
+				('FcStatus', consts.RequestStatus.Started)
 				)
 		self.assertHasNextEvent(None)
 			
@@ -513,7 +533,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.MessageStatus.Complete),
+				('FcStatus', consts.RequestStatus.Complete | consts.RequestStatus.Removed),
 				data=data
 				)
 		self.assertHasNextEvent(None)
@@ -536,7 +556,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestStarted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.MessageStatus.Started)
+				('FcStatus', consts.RequestStatus.Started)
 				)
 		self.assertHasNextEvent(None)
 			
@@ -551,7 +571,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.MessageStatus.Error)
+				('FcStatus', consts.RequestStatus.Complete | consts.RequestStatus.Error | consts.RequestStatus.Removed)
 				)
 		self.assertHasNextEvent(None)
 		
@@ -575,7 +595,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestStarted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.MessageStatus.Started)
+				('FcStatus', consts.RequestStatus.Started)
 				)
 		self.assertHasNextEvent(None)
 				
@@ -594,7 +614,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.MessageStatus.Complete)
+				('FcStatus', consts.RequestStatus.Complete | consts.RequestStatus.Removed)
 				)
 		self.assertHasNextEvent(None)
 
@@ -618,7 +638,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestStarted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.MessageStatus.Started)
+				('FcStatus', consts.RequestStatus.Started)
 				)
 		self.assertHasNextEvent(None)
 				
@@ -633,7 +653,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.MessageStatus.Error)
+				('FcStatus', consts.RequestStatus.Complete | consts.RequestStatus.Error | consts.RequestStatus.Removed)
 				)
 		self.assertHasNextEvent(None)
 	
@@ -658,7 +678,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestStarted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.MessageStatus.Started)
+				('FcStatus', consts.RequestStatus.Started)
 				)
 		self.assertHasNextEvent(None)
 				
@@ -677,7 +697,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.MessageStatus.Complete)
+				('FcStatus', consts.RequestStatus.Complete | consts.RequestStatus.Removed)
 				)
 		self.assertHasNextEvent(None)
 		
@@ -692,7 +712,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.MessageStatus.Complete)
+				('FcStatus', consts.RequestStatus.Complete)
 				)
 		self.assertHasNextEvent(None)
 
@@ -715,7 +735,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestStarted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.MessageStatus.Started)
+				('FcStatus', consts.RequestStatus.Started)
 				)
 		self.assertHasNextEvent(None)
 				
@@ -730,7 +750,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.MessageStatus.Error)
+				('FcStatus', consts.RequestStatus.Complete | consts.RequestStatus.Error | consts.RequestStatus.Removed)
 				)
 		self.assertHasNextEvent(None)
 
@@ -812,7 +832,7 @@
 		
 		# status of our request should be set to removed emidiately, but it should
 		# not be removed from the client
-		self.assertEqual(myRequest['FcStatus'], consts.MessageStatus.Removed)
+		self.assertEqual(myRequest['FcStatus'], consts.RequestStatus.Removed)
 		self.failUnless(myIdentifier in self.fcpClient.getRequests())
 		
 		# client schould send a RemovePersistentRequest
@@ -873,7 +893,7 @@
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		identifier = myRequest['Identifier']
-				
+			
 		self.fcpClient.removeRequest(myIdentifier)
 		self.sendResponseMessage(
 				'PersistentRequestRemoved',
@@ -895,7 +915,7 @@
 				)
 				
 		# check if the client restored the request
-		self.assertHasNextEvent(
+		msg = self.assertHasNextEvent(
 				self.fcpClient.events.RequestRestored,
 				consts.Message.ClientGet,
 				('Identifier', myIdentifier)


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

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

From: <ju...@us...> - 2008-02-05 15:21:55

Revision: 151
          http://fclient.svn.sourceforge.net/fclient/?rev=151&view=rev
Author:   jurner
Date:     2008-02-05 07:21:54 -0800 (Tue, 05 Feb 2008)

Log Message:
-----------
adapt to request status flags changes

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-05 15:21:08 UTC (rev 150)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-05 15:21:54 UTC (rev 151)
@@ -478,7 +478,8 @@
 		myIdentifier = self.fcpClient.getData(
 			'arbitrary-uri',
 			)
-		myRequest = self.fcpClient.getRequest(myIdentifier)		
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		allRequests = self.fcpClient.getRequests()		
 		
 		# respond to the file request
 		self.sendResponseMessage(
@@ -489,7 +490,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestStarted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Started)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started)
 				)
 		self.assertHasNextEvent(None)
 			
@@ -530,15 +531,44 @@
 				Global='false',
 				DataLength=len(data),
 				)
+		
+		# client should complete and remove the request
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Complete | consts.RequestStatus.Removed),
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete | consts.RequestStatus.Removed),
 				data=data
 				)
+		self.failIf(myIdentifier in allRequests)
 		self.assertHasNextEvent(None)
-			
+		
 	
+		# cheat a bit to test peristence == Forever (client should not remove request)
+		allRequests[myIdentifier] =myRequest
+		myRequest['Persistence'] = consts.Persistence.Forever
+		myRequest['FcStatus'] &= ~(consts.RequestStatus.Complete | consts.RequestStatus.Removed) 
+		self.sendResponseMessage(
+				'AllData',
+				data=data,
+				Identifier=myIdentifier,
+				Global='false',
+				DataLength=len(data),
+				)
+		
+		# client should complete but not remove the request
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestCompleted,
+				consts.Message.ClientGet,
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete),
+				data=data
+				)
+		self.failUnless(myIdentifier in allRequests)
+		self.assertHasNextEvent(None)
+		
+		
+		
+	
+	
 	def testGetData_Failure(self):
 						
 		# request a arbitrary file
@@ -546,6 +576,7 @@
 			'arbitrary-uri',
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)		
+		allRequests = self.fcpClient.getRequests()	
 		
 		# respond to the file request
 		self.sendResponseMessage(
@@ -556,7 +587,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestStarted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Started)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started)
 				)
 		self.assertHasNextEvent(None)
 			
@@ -568,14 +599,40 @@
 				Global='false',
 				# blah.. more here
 				)
+		
+		# client should complete request and remove it
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Complete | consts.RequestStatus.Error | consts.RequestStatus.Removed)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete | consts.RequestStatus.Error | consts.RequestStatus.Removed)
 				)
 		self.assertHasNextEvent(None)
 		
+		#return
+		
+		# cheat a bit to test peristence == Forever (client should not remove request)
+		
+		allRequests[myIdentifier] =myRequest
+		myRequest['Persistence'] = consts.Persistence.Forever
+		myRequest['FcStatus'] &= ~(consts.RequestStatus.Error | consts.RequestStatus.Removed)
+		self.sendResponseMessage(
+				'GetFailed',
+				Code='28',		# All data not found
+				Identifier=myIdentifier,
+				Global='false',
+				# blah.. more here
+				)
+		
+		# client should complete but not remove the request
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestFailed,
+				consts.Message.ClientGet,
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete | consts.RequestStatus.Error),
+				)
+		self.failUnless(myIdentifier in allRequests)
+		self.assertHasNextEvent(None)
 	
+	
 	def testGetFile_Success(self):
 						
 		# request a arbitrary file
@@ -584,6 +641,8 @@
 			'arbitryry.txt'
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
+		allRequests = self.fcpClient.getRequests()
+		
 		self.assertHasNextMessage(consts.Message.ClientGet)
 				
 		# respond to the file request
@@ -595,7 +654,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestStarted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Started)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started)
 				)
 		self.assertHasNextEvent(None)
 				
@@ -614,8 +673,9 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Complete | consts.RequestStatus.Removed)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete | consts.RequestStatus.Removed)
 				)
+		self.failIf(myIdentifier in allRequests)
 		self.assertHasNextEvent(None)
 
 
@@ -627,6 +687,8 @@
 			'arbitryry.txt'
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
+		allRequests = self.fcpClient.getRequests()
+		
 		self.assertHasNextMessage(consts.Message.ClientGet)
 				
 		# respond to the file request
@@ -638,7 +700,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestStarted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Started)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started)
 				)
 		self.assertHasNextEvent(None)
 				
@@ -653,8 +715,9 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Complete | consts.RequestStatus.Error | consts.RequestStatus.Removed)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete | consts.RequestStatus.Error | consts.RequestStatus.Removed)
 				)
+		self.failIf(myIdentifier in allRequests)
 		self.assertHasNextEvent(None)
 	
 	
@@ -667,6 +730,8 @@
 			persistence=consts.Persistence.Forever,		# cheat a bit, so we can test multiple cases
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
+		allRequests = self.fcpClient.getRequests()
+		
 		self.assertHasNextMessage(consts.Message.ClientGet)
 				
 		# respond to the file request
@@ -678,7 +743,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestStarted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Started)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started)
 				)
 		self.assertHasNextEvent(None)
 				
@@ -697,11 +762,13 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Complete | consts.RequestStatus.Removed)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete)
 				)
+		self.failIf(myIdentifier not in allRequests)
 		self.assertHasNextEvent(None)
 		
 		# test specdial case where ProtocolError.TooBig is handled as success
+		myRequest['FcStatus'] &= ~(consts.RequestStatus.Complete)
 		self.sendResponseMessage(
 				'GetFailed',
 				Code='21',		# Too big
@@ -712,11 +779,18 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Complete)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete)
 				)
 		self.assertHasNextEvent(None)
+		
+		# cheat a bit to test persistence == Connection
+		myRequest['Persistence'] = consts.Persistence.Connection
+		myRequest['FcStatus'] = consts.RequestStatus.Started
+	
+	###########################################
+	###########################################
 
-
+		
 	def testGetKeyInfo_Failure(self):
 						
 		# request a arbitrary file
@@ -735,7 +809,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestStarted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Started)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started)
 				)
 		self.assertHasNextEvent(None)
 				
@@ -750,7 +824,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Complete | consts.RequestStatus.Error | consts.RequestStatus.Removed)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete | consts.RequestStatus.Error | consts.RequestStatus.Removed)
 				)
 		self.assertHasNextEvent(None)
 
@@ -892,12 +966,12 @@
 			'arbitryry.txt'
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
-		identifier = myRequest['Identifier']
-			
+		allRequests = self.fcpClient.getRequests()
+					
 		self.fcpClient.removeRequest(myIdentifier)
 		self.sendResponseMessage(
 				'PersistentRequestRemoved',
-				Identifier=identifier,
+				Identifier=myIdentifier,
 				)
 		self.messages = []
 		self.events = []
@@ -905,7 +979,7 @@
 		# throw a PersistentGet at the client with the identifier we hacked
 		self.sendResponseMessage(
 				'PersistentGet',
-				Identifier=identifier,
+				Identifier=myIdentifier,
 				Global='false',
 				ReturnType='disk',
 				Verbosity='1',
@@ -918,9 +992,11 @@
 		msg = self.assertHasNextEvent(
 				self.fcpClient.events.RequestRestored,
 				consts.Message.ClientGet,
-				('Identifier', myIdentifier)
+				('Identifier', myIdentifier),
+				('FcStatus', consts.RequestStatus.Started),		# no RequestStatus.Pending flag should be set here
 				)
 		
+		self.failUnless(myIdentifier in allRequests) 
 		self.assertHasNextEvent(None)
 				
 #***********************************************************************************


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

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

From: <ju...@us...> - 2008-02-05 16:00:10

Revision: 154
          http://fclient.svn.sourceforge.net/fclient/?rev=154&view=rev
Author:   jurner
Date:     2008-02-05 08:00:15 -0800 (Tue, 05 Feb 2008)

Log Message:
-----------
adapt to request status flag changes

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-05 15:59:49 UTC (rev 153)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-05 16:00:15 UTC (rev 154)
@@ -604,7 +604,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete | consts.RequestStatus.Error | consts.RequestStatus.Removed)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Error | consts.RequestStatus.Removed)
 				)
 		self.assertHasNextEvent(None)
 		
@@ -627,7 +627,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete | consts.RequestStatus.Error),
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Error),
 				)
 		self.failUnless(myIdentifier in allRequests)
 		self.assertHasNextEvent(None)
@@ -715,7 +715,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete | consts.RequestStatus.Error | consts.RequestStatus.Removed)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Error | consts.RequestStatus.Removed)
 				)
 		self.failIf(myIdentifier in allRequests)
 		self.assertHasNextEvent(None)
@@ -824,7 +824,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete | consts.RequestStatus.Error | consts.RequestStatus.Removed)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Error | consts.RequestStatus.Removed)
 				)
 		self.assertHasNextEvent(None)
 
@@ -906,7 +906,7 @@
 		
 		# status of our request should be set to removed emidiately, but it should
 		# not be removed from the client
-		self.assertEqual(myRequest['FcStatus'], consts.RequestStatus.Removed)
+		self.assertEqual(myRequest['FcStatus'], consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Removed)
 		self.failUnless(myIdentifier in self.fcpClient.getRequests())
 		
 		# client schould send a RemovePersistentRequest


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

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

From: <ju...@us...> - 2008-02-06 10:54:21

Revision: 158
          http://fclient.svn.sourceforge.net/fclient/?rev=158&view=rev
Author:   jurner
Date:     2008-02-06 02:54:27 -0800 (Wed, 06 Feb 2008)

Log Message:
-----------
more fine grained status and type flags for requests

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-06 10:54:05 UTC (rev 157)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-06 10:54:27 UTC (rev 158)
@@ -2,6 +2,7 @@
 from __future__ import with_statement
 
 import os, sys
+import copy
 import socket
 import tempfile
 import time
@@ -60,6 +61,8 @@
 		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)
 		self.events.append( (event, msg) )
 		
 	def connectClient(self):
@@ -536,17 +539,24 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete | consts.RequestStatus.Removed),
+				('FcStatus', consts.RequestStatus.Pending | 
+										consts.RequestStatus.Started | 
+										consts.RequestStatus.Success | 
+										consts.RequestStatus.Removed),
 				data=data
 				)
 		self.failIf(myIdentifier in allRequests)
+		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
 	
 		# cheat a bit to test peristence == Forever (client should not remove request)
 		allRequests[myIdentifier] =myRequest
 		myRequest['Persistence'] = consts.Persistence.Forever
-		myRequest['FcStatus'] &= ~(consts.RequestStatus.Complete | consts.RequestStatus.Removed) 
+		myRequest['FcStatus'] &= ~(consts.RequestStatus.Success | 
+															consts.RequestStatus.Removed | 
+															consts.RequestStatus.Completed 
+															) 
 		self.sendResponseMessage(
 				'AllData',
 				data=data,
@@ -559,16 +569,16 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete),
+				('FcStatus', consts.RequestStatus.Pending | 
+										consts.RequestStatus.Started | 
+										consts.RequestStatus.Success),
 				data=data
 				)
 		self.failUnless(myIdentifier in allRequests)
+		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
 		
-		
-	
-	
 	def testGetData_Failure(self):
 						
 		# request a arbitrary file
@@ -604,8 +614,12 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Error | consts.RequestStatus.Removed)
+				('FcStatus', consts.RequestStatus.Pending | 
+										consts.RequestStatus.Started | 
+										consts.RequestStatus.Error | 
+										consts.RequestStatus.Removed)
 				)
+		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
 		#return
@@ -614,7 +628,9 @@
 		
 		allRequests[myIdentifier] =myRequest
 		myRequest['Persistence'] = consts.Persistence.Forever
-		myRequest['FcStatus'] &= ~(consts.RequestStatus.Error | consts.RequestStatus.Removed)
+		myRequest['FcStatus'] &= ~(consts.RequestStatus.Error | 
+															consts.RequestStatus.Removed | 
+															consts.RequestStatus.Completed)
 		self.sendResponseMessage(
 				'GetFailed',
 				Code='28',		# All data not found
@@ -627,9 +643,13 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Error),
+				('FcStatus', consts.RequestStatus.Pending | 
+										consts.RequestStatus.Started | 
+										consts.RequestStatus.Error
+										),
 				)
 		self.failUnless(myIdentifier in allRequests)
+		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 	
 	
@@ -673,9 +693,10 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete | consts.RequestStatus.Removed)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Success | consts.RequestStatus.Removed)
 				)
 		self.failIf(myIdentifier in allRequests)
+		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 
 
@@ -718,10 +739,10 @@
 				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Error | consts.RequestStatus.Removed)
 				)
 		self.failIf(myIdentifier in allRequests)
+		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
+		
 	
-	
-	
 	def testGetKeyInfo_Success(self):
 		
 		# request a arbitrary uri
@@ -762,13 +783,14 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete)
+				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Success)
 				)
 		self.failIf(myIdentifier not in allRequests)
+		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
 		# test specdial case where ProtocolError.TooBig is handled as success
-		myRequest['FcStatus'] &= ~(consts.RequestStatus.Complete)
+		myRequest['FcStatus'] &= ~(consts.RequestStatus.Success)
 		self.sendResponseMessage(
 				'GetFailed',
 				Code='21',		# Too big
@@ -779,8 +801,13 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Complete)
+				('FcStatus', consts.RequestStatus.Pending | 
+										consts.RequestStatus.Started | 
+										consts.RequestStatus.Success | 
+										consts.RequestStatus.Completed
+										)
 				)
+		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
 		# cheat a bit to test persistence == Connection
@@ -826,6 +853,7 @@
 				consts.Message.ClientGet,
 				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Error | consts.RequestStatus.Removed)
 				)
+		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 
 #***********************************************************************************


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

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

From: <ju...@us...> - 2008-02-06 14:57:29

Revision: 166
          http://fclient.svn.sourceforge.net/fclient/?rev=166&view=rev
Author:   jurner
Date:     2008-02-06 06:57:28 -0800 (Wed, 06 Feb 2008)

Log Message:
-----------
distinguish Removed from RemovedFromQueue

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-06 14:57:08 UTC (rev 165)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-06 14:57:28 UTC (rev 166)
@@ -542,7 +542,8 @@
 				('FcStatus', consts.RequestStatus.Pending | 
 										consts.RequestStatus.Started | 
 										consts.RequestStatus.Success | 
-										consts.RequestStatus.Removed),
+										consts.RequestStatus.RemovedFromQueue
+										),
 				data=data
 				)
 		self.failIf(myIdentifier in allRequests)
@@ -554,8 +555,8 @@
 		allRequests[myIdentifier] =myRequest
 		myRequest['Persistence'] = consts.Persistence.Forever
 		myRequest['FcStatus'] &= ~(consts.RequestStatus.Success | 
-															consts.RequestStatus.Removed | 
-															consts.RequestStatus.Completed 
+															consts.RequestStatus.Completed |
+															consts.RequestStatus.RemovedFromQueue
 															) 
 		self.sendResponseMessage(
 				'AllData',
@@ -617,7 +618,8 @@
 				('FcStatus', consts.RequestStatus.Pending | 
 										consts.RequestStatus.Started | 
 										consts.RequestStatus.Error | 
-										consts.RequestStatus.Removed)
+										consts.RequestStatus.RemovedFromQueue
+										)
 				)
 		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
@@ -629,8 +631,9 @@
 		allRequests[myIdentifier] =myRequest
 		myRequest['Persistence'] = consts.Persistence.Forever
 		myRequest['FcStatus'] &= ~(consts.RequestStatus.Error | 
-															consts.RequestStatus.Removed | 
-															consts.RequestStatus.Completed)
+															consts.RequestStatus.Completed |
+															consts.RequestStatus.RemovedFromQueue
+															)
 		self.sendResponseMessage(
 				'GetFailed',
 				Code='28',		# All data not found
@@ -693,7 +696,11 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Success | consts.RequestStatus.Removed)
+				('FcStatus', consts.RequestStatus.Pending | 
+										consts.RequestStatus.Started | 
+										consts.RequestStatus.Success | 
+										consts.RequestStatus.RemovedFromQueue
+										)
 				)
 		self.failIf(myIdentifier in allRequests)
 		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
@@ -736,7 +743,11 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Error | consts.RequestStatus.Removed)
+				('FcStatus', consts.RequestStatus.Pending | 
+										consts.RequestStatus.Started | 
+										consts.RequestStatus.Error | 
+										consts.RequestStatus.RemovedFromQueue
+										)
 				)
 		self.failIf(myIdentifier in allRequests)
 		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
@@ -748,7 +759,6 @@
 		# request a arbitrary uri
 		myIdentifier = self.fcpClient.getKeyInfo(
 			'arbitrary-uri',
-			persistence=consts.Persistence.Forever,		# cheat a bit, so we can test multiple cases
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		allRequests = self.fcpClient.getRequests()
@@ -783,15 +793,44 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Success)
+				('FcStatus', consts.RequestStatus.Pending | 
+										consts.RequestStatus.Started | 
+										consts.RequestStatus.Success |
+										consts.RequestStatus.RemovedFromQueue
+										)
 				)
-		self.failIf(myIdentifier not in allRequests)
+		self.failIf(myIdentifier in allRequests)
 		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
+		
+	def testGetKeyInfo_TooBig(self):
+				
 		# test specdial case where ProtocolError.TooBig is handled as success
-		myRequest['FcStatus'] &= ~(consts.RequestStatus.Success)
+		# request a arbitrary uri
+		myIdentifier = self.fcpClient.getKeyInfo(
+			'arbitrary-uri',
+			)
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		allRequests = self.fcpClient.getRequests()
+		
+		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.RequestStatus.Pending | consts.RequestStatus.Started)
+				)
+		self.assertHasNextEvent(None)
+		
+		# finalize request
+		self.sendResponseMessage(
 				'GetFailed',
 				Code='21',		# Too big
 				Identifier=myIdentifier,
@@ -803,8 +842,8 @@
 				consts.Message.ClientGet,
 				('FcStatus', consts.RequestStatus.Pending | 
 										consts.RequestStatus.Started | 
-										consts.RequestStatus.Success | 
-										consts.RequestStatus.Completed
+										consts.RequestStatus.Success |
+										consts.RequestStatus.RemovedFromQueue
 										)
 				)
 		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
@@ -814,10 +853,7 @@
 		myRequest['Persistence'] = consts.Persistence.Connection
 		myRequest['FcStatus'] = consts.RequestStatus.Started
 	
-	###########################################
-	###########################################
-
-		
+			
 	def testGetKeyInfo_Failure(self):
 						
 		# request a arbitrary file
@@ -851,7 +887,11 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Error | consts.RequestStatus.Removed)
+				('FcStatus', consts.RequestStatus.Pending | 
+										consts.RequestStatus.Started | 
+										consts.RequestStatus.Error | 
+										consts.RequestStatus.RemovedFromQueue
+										)
 				)
 		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
@@ -934,7 +974,10 @@
 		
 		# status of our request should be set to removed emidiately, but it should
 		# not be removed from the client
-		self.assertEqual(myRequest['FcStatus'], consts.RequestStatus.Pending | consts.RequestStatus.Started | consts.RequestStatus.Removed)
+		self.assertEqual(myRequest['FcStatus'], consts.RequestStatus.Pending | 
+																				consts.RequestStatus.Started | 
+																				consts.RequestStatus.Removed
+																				)
 		self.failUnless(myIdentifier in self.fcpClient.getRequests())
 		
 		# client schould send a RemovePersistentRequest
@@ -947,9 +990,9 @@
 				)
 			
 		# now the request should have been removed
+		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.RemovedFromQueue)
+		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
 		self.failIf(self.fcpClient.getRequests())
-		
-		# client never sends an event here
 		self.assertHasNextEvent(None)
 
 #***********************************************************************************


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

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

From: <ju...@us...> - 2008-02-08 08:38:22

Revision: 175
          http://fclient.svn.sourceforge.net/fclient/?rev=175&view=rev
Author:   jurner
Date:     2008-02-08 00:38:28 -0800 (Fri, 08 Feb 2008)

Log Message:
-----------
adapt

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-08 08:37:46 UTC (rev 174)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-08 08:38:28 UTC (rev 175)
@@ -472,7 +472,7 @@
 		self.failUnless(self.fcpClient.getRequests() )
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		self.assertEqual(myIdentifier, myRequest['Identifier'])
-		self.assertEqual(myRequest['FcStatus'], consts.RequestStatus.Pending)
+		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Pending)
 		
 	
 	def testGetData_Success(self):
@@ -490,13 +490,7 @@
 				Started='false',
 				**myRequest.params
 				)
-		self.assertHasNextEvent(
-				self.fcpClient.events.RequestStarted,
-				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started)
-				)
-		self.assertHasNextEvent(None)
-			
+					
 		# simulate a progress
 		self.sendResponseMessage(
 				'SimpleProgress',
@@ -539,22 +533,21 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | 
-										consts.RequestStatus.Started | 
+				('FcRequestStatus', consts.RequestStatus.Pending | 
 										consts.RequestStatus.Success | 
 										consts.RequestStatus.RemovedFromQueue
 										),
 				data=data
 				)
 		self.failIf(myIdentifier in allRequests)
-		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
 	
 		# cheat a bit to test peristence == Forever (client should not remove request)
 		allRequests[myIdentifier] =myRequest
 		myRequest['Persistence'] = consts.Persistence.Forever
-		myRequest['FcStatus'] &= ~(consts.RequestStatus.Success | 
+		myRequest['FcRequestStatus'] &= ~(consts.RequestStatus.Success | 
 															consts.RequestStatus.Completed |
 															consts.RequestStatus.RemovedFromQueue
 															) 
@@ -570,13 +563,12 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | 
-										consts.RequestStatus.Started | 
+				('FcRequestStatus', consts.RequestStatus.Pending | 
 										consts.RequestStatus.Success),
 				data=data
 				)
 		self.failUnless(myIdentifier in allRequests)
-		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
 		
@@ -595,13 +587,7 @@
 				Started='false',
 				**myRequest.params
 				)
-		self.assertHasNextEvent(
-				self.fcpClient.events.RequestStarted,
-				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started)
-				)
-		self.assertHasNextEvent(None)
-			
+					
 		# finalize request
 		self.sendResponseMessage(
 				'GetFailed',
@@ -615,13 +601,12 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | 
-										consts.RequestStatus.Started | 
+				('FcRequestStatus', consts.RequestStatus.Pending | 
 										consts.RequestStatus.Error | 
 										consts.RequestStatus.RemovedFromQueue
 										)
 				)
-		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
 		#return
@@ -630,7 +615,7 @@
 		
 		allRequests[myIdentifier] =myRequest
 		myRequest['Persistence'] = consts.Persistence.Forever
-		myRequest['FcStatus'] &= ~(consts.RequestStatus.Error | 
+		myRequest['FcRequestStatus'] &= ~(consts.RequestStatus.Error | 
 															consts.RequestStatus.Completed |
 															consts.RequestStatus.RemovedFromQueue
 															)
@@ -646,13 +631,12 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | 
-										consts.RequestStatus.Started | 
+				('FcRequestStatus', consts.RequestStatus.Pending | 
 										consts.RequestStatus.Error
 										),
 				)
 		self.failUnless(myIdentifier in allRequests)
-		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 	
 	
@@ -674,13 +658,7 @@
 				Started='false',
 				**myRequest.params
 				)
-		self.assertHasNextEvent(
-				self.fcpClient.events.RequestStarted,
-				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started)
-				)
-		self.assertHasNextEvent(None)
-				
+						
 		# finalize request
 		data = 'foo'
 		params = {
@@ -696,14 +674,13 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | 
-										consts.RequestStatus.Started | 
+				('FcRequestStatus', consts.RequestStatus.Pending | 
 										consts.RequestStatus.Success | 
 										consts.RequestStatus.RemovedFromQueue
 										)
 				)
 		self.failIf(myIdentifier in allRequests)
-		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 
 
@@ -725,13 +702,7 @@
 				Started='false',
 				**myRequest.params
 				)
-		self.assertHasNextEvent(
-				self.fcpClient.events.RequestStarted,
-				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started)
-				)
-		self.assertHasNextEvent(None)
-				
+						
 		# finalize request
 		self.sendResponseMessage(
 				'GetFailed',
@@ -743,14 +714,13 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | 
-										consts.RequestStatus.Started | 
+				('FcRequestStatus', consts.RequestStatus.Pending | 
 										consts.RequestStatus.Error | 
 										consts.RequestStatus.RemovedFromQueue
 										)
 				)
 		self.failIf(myIdentifier in allRequests)
-		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
 	
@@ -771,13 +741,7 @@
 				Started='false',
 				**myRequest.params
 				)
-		self.assertHasNextEvent(
-				self.fcpClient.events.RequestStarted,
-				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started)
-				)
-		self.assertHasNextEvent(None)
-				
+						
 		# finalize request
 		data = 'foo'
 		params = {
@@ -793,14 +757,13 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | 
-										consts.RequestStatus.Started | 
+				('FcRequestStatus', consts.RequestStatus.Pending | 
 										consts.RequestStatus.Success |
 										consts.RequestStatus.RemovedFromQueue
 										)
 				)
 		self.failIf(myIdentifier in allRequests)
-		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
 		
@@ -822,13 +785,7 @@
 				Started='false',
 				**myRequest.params
 				)
-		self.assertHasNextEvent(
-				self.fcpClient.events.RequestStarted,
-				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started)
-				)
-		self.assertHasNextEvent(None)
-		
+				
 		# finalize request
 		self.sendResponseMessage(
 				'GetFailed',
@@ -840,19 +797,15 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | 
-										consts.RequestStatus.Started | 
+				('FcRequestStatus', consts.RequestStatus.Pending | 
 										consts.RequestStatus.Success |
 										consts.RequestStatus.RemovedFromQueue
 										)
 				)
-		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
-		# cheat a bit to test persistence == Connection
-		myRequest['Persistence'] = consts.Persistence.Connection
-		myRequest['FcStatus'] = consts.RequestStatus.Started
-	
+					
 			
 	def testGetKeyInfo_Failure(self):
 						
@@ -869,13 +822,7 @@
 				Started='false',
 				**myRequest.params
 				)
-		self.assertHasNextEvent(
-				self.fcpClient.events.RequestStarted,
-				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | consts.RequestStatus.Started)
-				)
-		self.assertHasNextEvent(None)
-				
+						
 		# finalize request
 		self.sendResponseMessage(
 				'GetFailed',
@@ -887,13 +834,12 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcStatus', consts.RequestStatus.Pending | 
-										consts.RequestStatus.Started | 
+				('FcRequestStatus', consts.RequestStatus.Pending | 
 										consts.RequestStatus.Error | 
 										consts.RequestStatus.RemovedFromQueue
 										)
 				)
-		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 
 #***********************************************************************************
@@ -928,8 +874,7 @@
 				Started='false',
 				**myRequest.params
 				)
-		self.assertHasNextEvent(self.fcpClient.events.RequestStarted	)
-				
+						
 		# test modify persistent user data
 		self.fcpClient.modifyRequest(myIdentifier, persistentUserData='bar', priorityClass=consts.Priority.High)
 		msg = self.assertHasNextMessage(consts.Message.ModifyPersistentRequest)
@@ -974,8 +919,7 @@
 		
 		# status of our request should be set to removed emidiately, but it should
 		# not be removed from the client
-		self.assertEqual(myRequest['FcStatus'], consts.RequestStatus.Pending | 
-																				consts.RequestStatus.Started | 
+		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Pending | 
 																				consts.RequestStatus.Removed
 																				)
 		self.failUnless(myIdentifier in self.fcpClient.getRequests())
@@ -990,8 +934,8 @@
 				)
 			
 		# now the request should have been removed
-		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.RemovedFromQueue)
-		self.failUnless(myRequest['FcStatus'] & consts.RequestStatus.Completed)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.RemovedFromQueue)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.failIf(self.fcpClient.getRequests())
 		self.assertHasNextEvent(None)
 
@@ -1064,7 +1008,7 @@
 				self.fcpClient.events.RequestRestored,
 				consts.Message.ClientGet,
 				('Identifier', myIdentifier),
-				('FcStatus', consts.RequestStatus.Started),		# no RequestStatus.Pending flag should be set here
+				('FcRequestStatus', consts.RequestStatus.Null),		# no RequestStatus.Pending flag should be set here
 				)
 		
 		self.failUnless(myIdentifier in allRequests) 
@@ -1158,14 +1102,6 @@
 				**msg.params
 				)
 				
-		# check if client send expected events
-		self.assertHasNextEvent(
-				self.fcpClient.events.RequestStarted,
-				consts.Message.ClientGet,
-				('Identifier', myIdentifier)
-				)
-		self.assertHasNextEvent(None)
-		
 		requests = self.fcpClient.getRequests()
 		self.assertEqual(len(requests), 1)
 


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

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

From: <ju...@us...> - 2008-02-08 13:36:56

Revision: 185
          http://fclient.svn.sourceforge.net/fclient/?rev=185&view=rev
Author:   jurner
Date:     2008-02-08 05:37:01 -0800 (Fri, 08 Feb 2008)

Log Message:
-----------
fix

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-08 13:35:24 UTC (rev 184)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-08 13:37:01 UTC (rev 185)
@@ -161,6 +161,7 @@
 		if messageName is None:
 			self.failIf(self.messages)
 		else:
+			self.failUnless(self.messages)
 			msg = self.messages.pop(0)
 			self.assertEqual(msg.name, messageName)
 			if param1 is not None:


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

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

From: <ju...@us...> - 2008-02-08 18:54:32

Revision: 190
          http://fclient.svn.sourceforge.net/fclient/?rev=190&view=rev
Author:   jurner
Date:     2008-02-08 10:54:35 -0800 (Fri, 08 Feb 2008)

Log Message:
-----------
added test for gen keypair and subscribe usk

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-08 18:53:33 UTC (rev 189)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-08 18:54:35 UTC (rev 190)
@@ -473,7 +473,7 @@
 		self.failUnless(self.fcpClient.getRequests() )
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		self.assertEqual(myIdentifier, myRequest['Identifier'])
-		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Pending)
+		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Null)
 		
 	
 	def testGetData_Success(self):
@@ -534,7 +534,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Pending | 
+				('FcRequestStatus', consts.RequestStatus.Null | 
 										consts.RequestStatus.Success | 
 										consts.RequestStatus.RemovedFromQueue
 										),
@@ -542,8 +542,7 @@
 				)
 		self.failIf(myIdentifier in allRequests)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
-		self.assertHasNextEvent(None)
-		
+			
 	
 		# cheat a bit to test peristence == Forever (client should not remove request)
 		allRequests[myIdentifier] =myRequest
@@ -564,7 +563,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Pending | 
+				('FcRequestStatus', consts.RequestStatus.Null | 
 										consts.RequestStatus.Success),
 				data=data
 				)
@@ -602,7 +601,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Pending | 
+				('FcRequestStatus', consts.RequestStatus.Null | 
 										consts.RequestStatus.Error | 
 										consts.RequestStatus.RemovedFromQueue
 										)
@@ -632,7 +631,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Pending | 
+				('FcRequestStatus', consts.RequestStatus.Null | 
 										consts.RequestStatus.Error
 										),
 				)
@@ -675,7 +674,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Pending | 
+				('FcRequestStatus', consts.RequestStatus.Null | 
 										consts.RequestStatus.Success | 
 										consts.RequestStatus.RemovedFromQueue
 										)
@@ -715,7 +714,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Pending | 
+				('FcRequestStatus', consts.RequestStatus.Null | 
 										consts.RequestStatus.Error | 
 										consts.RequestStatus.RemovedFromQueue
 										)
@@ -758,7 +757,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Pending | 
+				('FcRequestStatus', consts.RequestStatus.Null | 
 										consts.RequestStatus.Success |
 										consts.RequestStatus.RemovedFromQueue
 										)
@@ -798,7 +797,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Pending | 
+				('FcRequestStatus', consts.RequestStatus.Null | 
 										consts.RequestStatus.Success |
 										consts.RequestStatus.RemovedFromQueue
 										)
@@ -835,7 +834,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Pending | 
+				('FcRequestStatus', consts.RequestStatus.Null | 
 										consts.RequestStatus.Error | 
 										consts.RequestStatus.RemovedFromQueue
 										)
@@ -920,7 +919,7 @@
 		
 		# status of our request should be set to removed emidiately, but it should
 		# not be removed from the client
-		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Pending | 
+		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Null | 
 																				consts.RequestStatus.Removed
 																				)
 		self.failUnless(myIdentifier in self.fcpClient.getRequests())
@@ -1009,7 +1008,7 @@
 				self.fcpClient.events.RequestRestored,
 				consts.Message.ClientGet,
 				('Identifier', myIdentifier),
-				('FcRequestStatus', consts.RequestStatus.Null),		# no RequestStatus.Pending flag should be set here
+				('FcRequestStatus', consts.RequestStatus.Restored),		# no RequestStatus.Pending flag should be set here
 				)
 		
 		self.failUnless(myIdentifier in allRequests) 
@@ -1260,14 +1259,95 @@
 #***********************************************************************************
 #
 #***********************************************************************************
-#TODO: class TestSSKKeypair(BaseTestConnectedClient):	
+#TODO: class TestSSKKeypair(BaseTestConnectedClient):
+class TestGenerateKeypair(BaseTestConnectedClient):
+	
+	def testGeberateSSKKeypair(self):
+		myIdentifier = self.fcpClient.generateKeypair(consts.KeyType.SSK)
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
+		
+		self.sendResponseMessage(
+				'SSKKeypair',
+				Identifier=myIdentifier,
+				RequestURI='SSK@public',
+				InsertURI='SSK@private', 
+				)
+			
+		msg = self.assertHasNextEvent(
+				self.fcpClient.events.KeypairGenerated,
+				consts.Message.GenerateSSK,
+				('Identifier', myIdentifier),
+				('FcPublicKey','SSK@public'),
+				('FcPrivateKey','SSK@private'), 
+				('FcRequestStatus', consts.RequestStatus.Success | 
+													consts.RequestStatus.RemovedFromQueue
+													),
+				)
+		self.assertHasNextEvent(None)
+		self.failIf(myIdentifier in requestsAll)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
+		
+		
+	def testGeberateUSKKeypair(self):
+		myIdentifier = self.fcpClient.generateKeypair(consts.KeyType.USK)
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
+		
+		self.sendResponseMessage(
+				'SSKKeypair',
+				Identifier=myIdentifier,
+				RequestURI='SSK@public',
+				InsertURI='SSK@private', 
+				)
+			
+		msg = self.assertHasNextEvent(
+				self.fcpClient.events.KeypairGenerated,
+				consts.Message.GenerateSSK,
+				('Identifier', myIdentifier),
+				('FcPublicKey','USK@public'),
+				('FcPrivateKey','USK@private'), 
+				('FcRequestStatus', consts.RequestStatus.Success | 
+													consts.RequestStatus.RemovedFromQueue
+													),
+				)
+		self.assertHasNextEvent(None)
+		self.failIf(myIdentifier in requestsAll)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)	
+	
 
 #***********************************************************************************
 #
 #***********************************************************************************
-#TODO: class TestSubscribeUSK(BaseTestConnectedClient):
+class TestSubscribeUSK(BaseTestConnectedClient):
 
 
+	def testSubscribe(self):
+		
+		myIdentifier = self.fcpClient.subscribeUSK('arbitrary')
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
+				
+		self.failUnless(myIdentifier in requestsAll)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
+		
+		self.sendResponseMessage(
+				'SubscribedUSKUpdate',
+				Identifier=myIdentifier,
+				Edition=99,
+				URI='arbitryry/99/', 
+				)
+		
+		msg = self.assertHasNextEvent(
+				self.fcpClient.events.USKUpdated,
+				consts.Message.SubscribedUSKUpdate,
+				('Identifier', myIdentifier),
+				('Edition', 99),
+				('URI', 'arbitryry/99/'),
+				)
+		self.assertHasNextEvent(None)
+		
+		
 	
 #*********************************************************************************
 #
@@ -1282,6 +1362,9 @@
 			TestRestoreRequests,
 			TestDDA,
 			TestCollisions,
+			
+			TestGenerateKeypair,
+			TestSubscribeUSK,
 			)
 	
 	suite = unittest.TestSuite()


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

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

From: <ju...@us...> - 2008-02-08 23:41:32

Revision: 193
          http://fclient.svn.sourceforge.net/fclient/?rev=193&view=rev
Author:   jurner
Date:     2008-02-08 15:41:20 -0800 (Fri, 08 Feb 2008)

Log Message:
-----------
added test for removeRequest()

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-08 23:41:00 UTC (rev 192)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-08 23:41:20 UTC (rev 193)
@@ -856,6 +856,7 @@
 
 class TestRequests(BaseTestConnectedClient):
 
+	
 	def testModifyRequest(self):
 				
 		# request a arbitrary file
@@ -894,7 +895,7 @@
 		self.assertHasNextEvent(None)
 	
 	
-	def testRemoveRequest(self):
+	def testRemoveRequest_NonPersistent(self):
 				
 		# request a file
 		myIdentifier = self.fcpClient.getFile(
@@ -917,6 +918,43 @@
 		# now cancel request
 		self.fcpClient.removeRequest(myIdentifier)
 		
+		# of our request should be removed emidiately,
+		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Null | 
+																				consts.RequestStatus.Removed |
+																				consts.RequestStatus.Completed |
+																				consts.RequestStatus.RemovedFromQueue
+																				)
+		self.failIf(myIdentifier in self.fcpClient.getRequests())
+				
+		# now the request should have been removed
+		self.failIf(self.fcpClient.getRequests())
+		self.assertHasNextEvent(None)
+
+	
+	def testRemoveRequest_persistent(self):
+				
+		# request a file
+		myIdentifier = self.fcpClient.getFile(
+			'arbitrary-uri',
+			'arbitrary.txt',
+			persistence=consts.Persistence.Reboot,
+			)
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+				
+		# respond to the file request
+		self.sendResponseMessage(
+				'PersistentGet',
+				Started='false',
+				**myRequest.params
+				)
+							
+		# 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['FcRequestStatus'], consts.RequestStatus.Null | 
@@ -939,6 +977,59 @@
 		self.failIf(self.fcpClient.getRequests())
 		self.assertHasNextEvent(None)
 
+	
+	
+	def testResendRequest_NonPersistent(self):
+		
+		myIdentifier = self.fcpClient.getData('any-key')
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		allRequests = self.fcpClient.getRequests()
+		self.assertHasNextMessage(consts.Message.ClientGet)
+				
+		newIdentifier = self.fcpClient.resendRequest(myRequest)
+		
+		# client should remove old request emidiately
+		self.failIf(myIdentifier == newIdentifier)
+		self.failIf(myIdentifier in allRequests)
+		self.failUnless(newIdentifier in allRequests)
+		
+		self.assertHasNextMessage(consts.Message.ClientGet)
+		
+		
+		
+	def testResendRequest_Persistent(self):
+		
+		myIdentifier = self.fcpClient.getData('any-key', persistence=consts.Persistence.Reboot)
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		allRequests = self.fcpClient.getRequests()
+		self.assertHasNextMessage(consts.Message.ClientGet)		
+		
+		newIdentifier = self.fcpClient.resendRequest(myRequest)
+		self.failIf(myIdentifier == newIdentifier)
+		self.failUnless(newIdentifier in allRequests)
+		
+		# client should remove request from nodes queue
+		self.assertHasNextMessage(
+				consts.Message.RemovePersistentRequest,
+				('Identifier', myIdentifier)
+				)
+		self.assertHasNextMessage(
+				consts.Message.ClientGet,
+				('Identifier', newIdentifier)
+				)
+		self.sendResponseMessage(
+				'PersistentRequestRemoved',
+				Identifier=myIdentifier,
+				)
+		
+		self.failUnless(newIdentifier in allRequests)
+		self.failIf(myIdentifier in allRequests)
+		
+		
+		
+		
+		
+
 #***********************************************************************************
 #
 #***********************************************************************************


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

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

From: <ju...@us...> - 2008-02-09 09:34:51

Revision: 195
          http://fclient.svn.sourceforge.net/fclient/?rev=195&view=rev
Author:   jurner
Date:     2008-02-09 01:34:57 -0800 (Sat, 09 Feb 2008)

Log Message:
-----------
added plugin message test cases

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-09 09:34:37 UTC (rev 194)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-09 09:34:57 UTC (rev 195)
@@ -483,7 +483,7 @@
 			'arbitrary-uri',
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
-		allRequests = self.fcpClient.getRequests()		
+		requestsAll = self.fcpClient.getRequests()		
 		
 		# respond to the file request
 		self.sendResponseMessage(
@@ -534,18 +534,17 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Null | 
-										consts.RequestStatus.Success | 
-										consts.RequestStatus.RemovedFromQueue
-										),
+				('FcRequestStatus', 	consts.RequestStatus.Success | 
+													consts.RequestStatus.RemovedFromQueue
+													),
 				data=data
 				)
-		self.failIf(myIdentifier in allRequests)
+		self.failIf(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 			
 	
 		# cheat a bit to test peristence == Forever (client should not remove request)
-		allRequests[myIdentifier] =myRequest
+		requestsAll[myIdentifier] =myRequest
 		myRequest['Persistence'] = consts.Persistence.Forever
 		myRequest['FcRequestStatus'] &= ~(consts.RequestStatus.Success | 
 															consts.RequestStatus.Completed |
@@ -563,11 +562,10 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Null | 
-										consts.RequestStatus.Success),
+				('FcRequestStatus', consts.RequestStatus.Success),
 				data=data
 				)
-		self.failUnless(myIdentifier in allRequests)
+		self.failUnless(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
@@ -579,7 +577,7 @@
 			'arbitrary-uri',
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)		
-		allRequests = self.fcpClient.getRequests()	
+		requestsAll = self.fcpClient.getRequests()	
 		
 		# respond to the file request
 		self.sendResponseMessage(
@@ -601,10 +599,9 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Null | 
-										consts.RequestStatus.Error | 
-										consts.RequestStatus.RemovedFromQueue
-										)
+				('FcRequestStatus', consts.RequestStatus.Error | 
+													consts.RequestStatus.RemovedFromQueue
+													),
 				)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
@@ -613,7 +610,7 @@
 		
 		# cheat a bit to test peristence == Forever (client should not remove request)
 		
-		allRequests[myIdentifier] =myRequest
+		requestsAll[myIdentifier] =myRequest
 		myRequest['Persistence'] = consts.Persistence.Forever
 		myRequest['FcRequestStatus'] &= ~(consts.RequestStatus.Error | 
 															consts.RequestStatus.Completed |
@@ -631,11 +628,9 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Null | 
-										consts.RequestStatus.Error
-										),
+				('FcRequestStatus', consts.RequestStatus.Error),
 				)
-		self.failUnless(myIdentifier in allRequests)
+		self.failUnless(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 	
@@ -648,7 +643,7 @@
 			'arbitryry.txt'
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
-		allRequests = self.fcpClient.getRequests()
+		requestsAll = self.fcpClient.getRequests()
 		
 		self.assertHasNextMessage(consts.Message.ClientGet)
 				
@@ -674,12 +669,11 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Null | 
-										consts.RequestStatus.Success | 
-										consts.RequestStatus.RemovedFromQueue
-										)
+				('FcRequestStatus', consts.RequestStatus.Success | 
+													consts.RequestStatus.RemovedFromQueue
+													),
 				)
-		self.failIf(myIdentifier in allRequests)
+		self.failIf(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 
@@ -692,7 +686,7 @@
 			'arbitryry.txt'
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
-		allRequests = self.fcpClient.getRequests()
+		requestsAll = self.fcpClient.getRequests()
 		
 		self.assertHasNextMessage(consts.Message.ClientGet)
 				
@@ -714,12 +708,11 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Null | 
-										consts.RequestStatus.Error | 
-										consts.RequestStatus.RemovedFromQueue
-										)
+				('FcRequestStatus', consts.RequestStatus.Error | 
+												consts.RequestStatus.RemovedFromQueue
+												),
 				)
-		self.failIf(myIdentifier in allRequests)
+		self.failIf(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
@@ -731,7 +724,7 @@
 			'arbitrary-uri',
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
-		allRequests = self.fcpClient.getRequests()
+		requestsAll = self.fcpClient.getRequests()
 		
 		self.assertHasNextMessage(consts.Message.ClientGet)
 				
@@ -757,12 +750,11 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Null | 
-										consts.RequestStatus.Success |
-										consts.RequestStatus.RemovedFromQueue
-										)
+				('FcRequestStatus', consts.RequestStatus.Success |
+													consts.RequestStatus.RemovedFromQueue
+													),
 				)
-		self.failIf(myIdentifier in allRequests)
+		self.failIf(myIdentifier in requestsAll)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		
@@ -775,7 +767,7 @@
 			'arbitrary-uri',
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
-		allRequests = self.fcpClient.getRequests()
+		requestsAll = self.fcpClient.getRequests()
 		
 		self.assertHasNextMessage(consts.Message.ClientGet)
 		
@@ -797,10 +789,9 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Null | 
-										consts.RequestStatus.Success |
-										consts.RequestStatus.RemovedFromQueue
-										)
+				('FcRequestStatus', consts.RequestStatus.Success |
+												consts.RequestStatus.RemovedFromQueue
+												),
 				)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
@@ -834,10 +825,9 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Null | 
-										consts.RequestStatus.Error | 
-										consts.RequestStatus.RemovedFromQueue
-										)
+				('FcRequestStatus', consts.RequestStatus.Error | 
+												consts.RequestStatus.RemovedFromQueue
+												),
 				)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
@@ -850,10 +840,6 @@
 #***********************************************************************************
 #
 #***********************************************************************************
-#TODO: testGetRequest()
-#TODO: testGetRequest()
-#TODO: testResendRequest()
-
 class TestRequests(BaseTestConnectedClient):
 
 	
@@ -919,14 +905,20 @@
 		self.fcpClient.removeRequest(myIdentifier)
 		
 		# of our request should be removed emidiately,
-		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Null | 
-																				consts.RequestStatus.Removed |
+		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Removed |
 																				consts.RequestStatus.Completed |
 																				consts.RequestStatus.RemovedFromQueue
 																				)
 		self.failIf(myIdentifier in self.fcpClient.getRequests())
 				
 		# now the request should have been removed
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestRemoved,
+				consts.Message.ClientGet,
+				('FcRequestStatus', consts.RequestStatus.Removed | 
+											consts.RequestStatus.RemovedFromQueue
+											),
+				)
 		self.failIf(self.fcpClient.getRequests())
 		self.assertHasNextEvent(None)
 
@@ -957,9 +949,7 @@
 		
 		# status of our request should be set to removed emidiately, but it should
 		# not be removed from the client
-		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Null | 
-																				consts.RequestStatus.Removed
-																				)
+		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Removed)
 		self.failUnless(myIdentifier in self.fcpClient.getRequests())
 		
 		# client schould send a RemovePersistentRequest
@@ -974,6 +964,14 @@
 		# now the request should have been removed
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.RemovedFromQueue)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestRemoved,
+				consts.Message.ClientGet,
+				('FcRequestStatus', consts.RequestStatus.Removed | 
+										consts.RequestStatus.RemovedFromQueue
+										),
+				)
+		
 		self.failIf(self.fcpClient.getRequests())
 		self.assertHasNextEvent(None)
 
@@ -983,30 +981,36 @@
 		
 		myIdentifier = self.fcpClient.getData('any-key')
 		myRequest = self.fcpClient.getRequest(myIdentifier)
-		allRequests = self.fcpClient.getRequests()
+		requestsAll = self.fcpClient.getRequests()
 		self.assertHasNextMessage(consts.Message.ClientGet)
 				
 		newIdentifier = self.fcpClient.resendRequest(myRequest)
 		
 		# client should remove old request emidiately
 		self.failIf(myIdentifier == newIdentifier)
-		self.failIf(myIdentifier in allRequests)
-		self.failUnless(newIdentifier in allRequests)
-		
+		self.failIf(myIdentifier in requestsAll)
+		self.failUnless(newIdentifier in requestsAll)
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestRemoved,
+				consts.Message.ClientGet,
+				('FcRequestStatus', consts.RequestStatus.Removed | 
+										consts.RequestStatus.RemovedFromQueue
+										),
+				)
+				
 		self.assertHasNextMessage(consts.Message.ClientGet)
 		
-		
-		
+			
 	def testResendRequest_Persistent(self):
 		
 		myIdentifier = self.fcpClient.getData('any-key', persistence=consts.Persistence.Reboot)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
-		allRequests = self.fcpClient.getRequests()
+		requestsAll = self.fcpClient.getRequests()
 		self.assertHasNextMessage(consts.Message.ClientGet)		
 		
 		newIdentifier = self.fcpClient.resendRequest(myRequest)
 		self.failIf(myIdentifier == newIdentifier)
-		self.failUnless(newIdentifier in allRequests)
+		self.failUnless(newIdentifier in requestsAll)
 		
 		# client should remove request from nodes queue
 		self.assertHasNextMessage(
@@ -1021,14 +1025,17 @@
 				'PersistentRequestRemoved',
 				Identifier=myIdentifier,
 				)
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestRemoved,
+				consts.Message.ClientGet,
+				('FcRequestStatus', consts.RequestStatus.Removed | 
+										consts.RequestStatus.RemovedFromQueue
+										),
+				)
 		
-		self.failUnless(newIdentifier in allRequests)
-		self.failIf(myIdentifier in allRequests)
+		self.failUnless(newIdentifier in requestsAll)
+		self.failIf(myIdentifier in requestsAll)
 		
-		
-		
-		
-		
 
 #***********************************************************************************
 #
@@ -1072,7 +1079,7 @@
 			'arbitryry.txt'
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
-		allRequests = self.fcpClient.getRequests()
+		requestsAll = self.fcpClient.getRequests()
 					
 		self.fcpClient.removeRequest(myIdentifier)
 		self.sendResponseMessage(
@@ -1102,7 +1109,7 @@
 				('FcRequestStatus', consts.RequestStatus.Restored),		# no RequestStatus.Pending flag should be set here
 				)
 		
-		self.failUnless(myIdentifier in allRequests) 
+		self.failUnless(myIdentifier in requestsAll) 
 		self.assertHasNextEvent(None)
 				
 #***********************************************************************************
@@ -1342,15 +1349,154 @@
 #***********************************************************************************
 #
 #***********************************************************************************
-#TODO: class TestPlugins(BaseTestConnectedClient):	
+class TestPlugins(BaseTestConnectedClient):
+	
+	
+	def testGetPluginInfo_Success(self):
+		
+		myIdentifier = self.fcpClient.getPluginInfo('hi there')
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
+		
+		self.failUnless(myIdentifier in requestsAll)
+		self.assertHasNextMessage(
+				consts.Message.GetPluginInfo,
+				('Identifier', myIdentifier),
+				('PluginName', 'hi there'),
+				)
+				
+		self.sendResponseMessage(
+				consts.Message.PluginInfo,
+				PluginName='hi there',
+				Identifier=myIdentifier,
+				)
+				
+		msg = self.assertHasNextEvent(
+				self.fcpClient.events.PluginInfo, 
+				consts.Message.GetPluginInfo,
+				('Identifier', myIdentifier),
+				('PluginName', 'hi there'),
+				('FcRequestStatus', consts.RequestStatus.Success |
+													consts.RequestStatus.RemovedFromQueue
+													),
+				)
+		
+		self.assertHasNextEvent(None)
+		self.failIf(myIdentifier in requestsAll)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)	
+	
 
+	def testGetPluginInfo_Failure(self):
+		myIdentifier = self.fcpClient.getPluginInfo('hi there')
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
+		
+		self.failUnless(myIdentifier in requestsAll)
+		self.assertHasNextMessage(
+				consts.Message.GetPluginInfo,
+				('Identifier', myIdentifier),
+				('PluginName', 'hi there'),
+				)
+				
+		self.sendResponseMessage(
+				consts.Message.ProtocolError,
+				Code=32, 			# No such plugin
+				Identifier=myIdentifier,
+				)
+
+		msg = self.assertHasNextEvent(
+				self.fcpClient.events.PluginInfoFailed, 
+				consts.Message.GetPluginInfo,
+				#('PluginName', 'hi there'),
+				('Identifier', myIdentifier),
+				('FcRequestStatus', consts.RequestStatus.Error |
+													consts.RequestStatus.RemovedFromQueue
+													),
+				)
+				
+		self.assertHasNextEvent(None)
+		self.failIf(myIdentifier in requestsAll)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)	
+	
+	
+	def testSendPluginMessage_Success(self):
+		
+		myIdentifier = self.fcpClient.sendPluginMessage('hi there', {'foo': "bar"})
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
+		
+		self.failUnless(myIdentifier in requestsAll)
+		self.assertHasNextMessage(
+				consts.Message.FCPPluginMessage,
+				('Identifier', myIdentifier),
+				('PluginName', 'hi there'),
+				('foo', 'bar'),
+				)
+					
+		self.sendResponseMessage(
+				consts.Message.FCPPluginReply,
+				PluginName='hi there',
+				Identifier=myIdentifier,
+				baz='12345',
+				)
+				
+		msg = self.assertHasNextEvent(
+				self.fcpClient.events.PluginMessage, 
+				consts.Message.FCPPluginMessage,
+				('PluginName', 'hi there'),
+				('Identifier', myIdentifier),
+				('FcRequestStatus', consts.RequestStatus.Success |
+													consts.RequestStatus.RemovedFromQueue
+													),
+				)
+		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)	
+	
+
+	def testGetSendPluginMessage_Failure(self):
+		myIdentifier = self.fcpClient.sendPluginMessage('hi there', {'foo': "bar"})
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
+		
+		self.failUnless(myIdentifier in requestsAll)
+		self.assertHasNextMessage(
+				consts.Message.FCPPluginMessage,
+				('Identifier', myIdentifier),
+				('PluginName', 'hi there'),
+				('foo', 'bar'),
+				)
+					
+		self.sendResponseMessage(
+				consts.Message.ProtocolError,
+				Code=32, 			# No such plugin
+				Identifier=myIdentifier,
+				)
+
+		msg = self.assertHasNextEvent(
+				self.fcpClient.events.PluginMessageFailed, 
+				consts.Message.FCPPluginMessage,
+				#('PluginName', 'hi there'),
+				('Identifier', myIdentifier),
+				('FcRequestStatus', consts.RequestStatus.Error |
+													consts.RequestStatus.RemovedFromQueue
+													),
+				)
+				
+		self.assertHasNextEvent(None)
+		self.failIf(myIdentifier in requestsAll)
+		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)	
+	
+
 #***********************************************************************************
 #TODO: class TestConfig(BaseTestConnectedClient):	
 
 #***********************************************************************************
 #
 #***********************************************************************************
-#TODO: class TestSSKKeypair(BaseTestConnectedClient):
 class TestGenerateKeypair(BaseTestConnectedClient):
 	
 	def testGeberateSSKKeypair(self):
@@ -1454,6 +1600,7 @@
 			TestDDA,
 			TestCollisions,
 			
+			TestPlugins,
 			TestGenerateKeypair,
 			TestSubscribeUSK,
 			)


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

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

From: <ju...@us...> - 2008-02-09 18:03:57

Revision: 199
          http://fclient.svn.sourceforge.net/fclient/?rev=199&view=rev
Author:   jurner
Date:     2008-02-09 10:03:51 -0800 (Sat, 09 Feb 2008)

Log Message:
-----------
fix: PriorityClass can not be changed for requests with Persistence=connection. 
This is not possible Fcp

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-09 18:03:38 UTC (rev 198)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-09 18:03:51 UTC (rev 199)
@@ -842,8 +842,7 @@
 #***********************************************************************************
 class TestRequests(BaseTestConnectedClient):
 
-	
-	def testModifyRequest(self):
+	def testModifyRequest_Persistent(self):
 				
 		# request a arbitrary file
 		myIdentifier = self.fcpClient.getFile(
@@ -851,6 +850,7 @@
 			'arbitryry.txt',
 			persistentUserData='foo',
 			priorityClass=consts.Priority.Medium,
+			persistence=consts.Persistence.Reboot,
 			)
 		myRequest = self.fcpClient.getRequest(myIdentifier)
 		self.assertHasNextMessage(consts.Message.ClientGet)
@@ -881,6 +881,47 @@
 		self.assertHasNextEvent(None)
 	
 	
+	def testModifyRequest_NonPersistent(self):
+				
+		# request a arbitrary file
+		myIdentifier = self.fcpClient.getFile(
+			'arbitrary-uri',
+			'arbitryry.txt',
+			persistentUserData='foo',
+			priorityClass=consts.Priority.Medium,
+			)
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		self.assertHasNextMessage(consts.Message.ClientGet)
+		
+		# respond to the file request
+		self.sendResponseMessage(
+				'PersistentGet',
+				Started='false',
+				**myRequest.params
+				)
+						
+		# test modify persistent user data
+		self.fcpClient.modifyRequest(myIdentifier, persistentUserData='bar', priorityClass=consts.Priority.High)
+		
+		# no way to modify priority in Fcp. The client ignores all attempts to do so currently
+		# no message is send,instead the event is triggered emidiately
+		
+		#msg = self.assertHasNextMessage(consts.Message.ModifyPersistentRequest)
+		# respond to the file request
+		#self.sendResponseMessage(
+		#		'PersistentRequestModified',
+		#		**msg.params
+		#		)
+		self.assertHasNextEvent(self.fcpClient.events.RequestModified)
+		
+		self.failUnless(consts.RequestModified.PersistentUserData in myRequest['FcModified'])
+		#self.failUnless(consts.RequestModified.PriorityClass in myRequest['FcModified'])
+		self.assertEqual('bar', myRequest['FcPersistentUserData'])
+		#self.assertEqual(consts.Priority.High, myRequest['PriorityClass'])	
+		
+		self.assertHasNextEvent(None)
+	
+	
 	def testRemoveRequest_NonPersistent(self):
 				
 		# request a file


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

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

From: <ju...@us...> - 2008-02-11 10:55:22

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',
 				)
 				
...
 
[truncated message content]

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

From: <ju...@us...> - 2008-02-17 09:21:22

Revision: 223
          http://fclient.svn.sourceforge.net/fclient/?rev=223&view=rev
Author:   jurner
Date:     2008-02-17 01:21:27 -0800 (Sun, 17 Feb 2008)

Log Message:
-----------
new sys path hack

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-17 09:20:13 UTC (rev 222)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-17 09:21:27 UTC (rev 223)
@@ -9,12 +9,13 @@
 import unittest
 
 #--> rel import hack
-def parentdir(n, fpath):
-	fpath = os.path.abspath(fpath)
-	for i in xrange(n):
-		fpath = os.path.dirname(fpath)
-	return fpath
-sys.path.insert(0, parentdir(2, __file__))
+class SysPathHack(object):
+	def __init__(self, n):
+		fpath = os.path.abspath(__file__)
+		for i in xrange(n): fpath = os.path.dirname(fpath)
+		sys.path.insert(0, fpath)
+	def __del__(self): sys.path.pop(0)
+hack = SysPathHack(2)
 
 
 import fcp2_0_client
@@ -22,8 +23,7 @@
 import fcp2_0_consts as consts
 
 
-sys.path.pop(0)
-del parentdir
+del hack
 #<-- rel import hack
 
 from dummy_socket import DummySocket


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

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

From: <ju...@us...> - 2008-02-21 13:11:20

Revision: 238
          http://fclient.svn.sourceforge.net/fclient/?rev=238&view=rev
Author:   jurner
Date:     2008-02-21 05:11:07 -0800 (Thu, 21 Feb 2008)

Log Message:
-----------
RequestStatus.Completed flag is now set before listeners are informed

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-21 13:10:08 UTC (rev 237)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-21 13:11:07 UTC (rev 238)
@@ -621,7 +621,8 @@
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
 				('FcRequestStatus', 	consts.RequestStatus.Success | 
-													consts.RequestStatus.RemovedFromQueue
+													consts.RequestStatus.RemovedFromQueue |
+													consts.RequestStatus.Completed
 													),
 				data=data
 				)
@@ -648,7 +649,7 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Success),
+				('FcRequestStatus', consts.RequestStatus.Success | consts.RequestStatus.Completed),
 				data=data
 				)
 		self.failUnless(myIdentifier in requestsAll)
@@ -693,10 +694,10 @@
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
 				('FcRequestStatus', consts.RequestStatus.Error | 
-													consts.RequestStatus.RemovedFromQueue
+													consts.RequestStatus.RemovedFromQueue |
+													consts.RequestStatus.Completed
 													),
 				)
-		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		self.assertHasNextMessage(None)
 		
@@ -722,10 +723,9 @@
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
-				('FcRequestStatus', consts.RequestStatus.Error),
+				('FcRequestStatus', consts.RequestStatus.Error | consts.RequestStatus.Completed),
 				)
 		self.failUnless(myIdentifier in requestsAll)
-		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		self.assertHasNextMessage(None)
 		
@@ -768,7 +768,8 @@
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
 				('FcRequestStatus', consts.RequestStatus.Success | 
-													consts.RequestStatus.RemovedFromQueue
+													consts.RequestStatus.RemovedFromQueue |
+													consts.RequestStatus.Completed
 													),
 				)
 		self.failIf(myIdentifier in requestsAll)
@@ -806,15 +807,17 @@
 				Global='false',
 				# blah.. more here
 				)
+		
+		print consts.RequestStatus.humanReadable(myRequest['FcRequestStatus'])
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
 				('FcRequestStatus', consts.RequestStatus.Error | 
-												consts.RequestStatus.RemovedFromQueue
+												consts.RequestStatus.RemovedFromQueue |
+												consts.RequestStatus.Completed
 												),
 				)
 		self.failIf(myIdentifier in requestsAll)
-		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
 		self.assertHasNextEvent(None)
 		self.assertHasNextMessage(None)
 		
@@ -855,7 +858,8 @@
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
 				('FcRequestStatus', consts.RequestStatus.Success |
-													consts.RequestStatus.RemovedFromQueue
+													consts.RequestStatus.RemovedFromQueue |
+													consts.RequestStatus.Completed
 													),
 				)
 		self.failIf(myIdentifier in requestsAll)
@@ -897,7 +901,8 @@
 				self.fcpClient.events.RequestCompleted,
 				consts.Message.ClientGet,
 				('FcRequestStatus', consts.RequestStatus.Success |
-												consts.RequestStatus.RemovedFromQueue
+												consts.RequestStatus.RemovedFromQueue |
+												consts.RequestStatus.Completed
 												),
 				)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
@@ -938,7 +943,8 @@
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
 				('FcRequestStatus', consts.RequestStatus.Error | 
-												consts.RequestStatus.RemovedFromQueue
+												consts.RequestStatus.RemovedFromQueue |
+												consts.RequestStatus.Completed
 												),
 				)
 		self.failUnless(myRequest['FcRequestStatus'] & consts.RequestStatus.Completed)
@@ -1079,8 +1085,8 @@
 		
 		# of our request should be removed emidiately,
 		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Removed |
-																				consts.RequestStatus.Completed |
-																				consts.RequestStatus.RemovedFromQueue
+																				consts.RequestStatus.RemovedFromQueue |
+																				consts.RequestStatus.Completed
 																				)
 		self.failIf(myIdentifier in self.fcpClient.getRequests())
 				
@@ -1089,7 +1095,8 @@
 				self.fcpClient.events.RequestRemoved,
 				consts.Message.ClientGet,
 				('FcRequestStatus', consts.RequestStatus.Removed | 
-											consts.RequestStatus.RemovedFromQueue
+											consts.RequestStatus.RemovedFromQueue |
+											consts.RequestStatus.Completed
 											),
 				)
 		self.failIf(self.fcpClient.getRequests())
@@ -1147,7 +1154,8 @@
 				self.fcpClient.events.RequestRemoved,
 				consts.Message.ClientGet,
 				('FcRequestStatus', consts.RequestStatus.Removed | 
-										consts.RequestStatus.RemovedFromQueue
+										consts.RequestStatus.RemovedFromQueue |
+										consts.RequestStatus.Completed
 										),
 				)
 		
@@ -1176,7 +1184,8 @@
 				self.fcpClient.events.RequestRemoved,
 				consts.Message.ClientGet,
 				('FcRequestStatus', consts.RequestStatus.Removed | 
-										consts.RequestStatus.RemovedFromQueue
+										consts.RequestStatus.RemovedFromQueue |
+										consts.RequestStatus.Completed
 										),
 				)
 				
@@ -1217,7 +1226,8 @@
 				self.fcpClient.events.RequestRemoved,
 				consts.Message.ClientGet,
 				('FcRequestStatus', consts.RequestStatus.Removed | 
-										consts.RequestStatus.RemovedFromQueue
+										consts.RequestStatus.RemovedFromQueue |
+										consts.RequestStatus.Completed
 										),
 				)
 		
@@ -1594,7 +1604,8 @@
 				('Identifier', myIdentifier),
 				('PluginName', 'hi there'),
 				('FcRequestStatus', consts.RequestStatus.Success |
-													consts.RequestStatus.RemovedFromQueue
+													consts.RequestStatus.RemovedFromQueue |
+													consts.RequestStatus.Completed
 													),
 				)
 		
@@ -1632,7 +1643,8 @@
 				#('PluginName', 'hi there'),
 				('Identifier', myIdentifier),
 				('FcRequestStatus', consts.RequestStatus.Error |
-													consts.RequestStatus.RemovedFromQueue
+													consts.RequestStatus.RemovedFromQueue |
+													consts.RequestStatus.Completed
 													),
 				)
 				
@@ -1672,7 +1684,8 @@
 				('PluginName', 'hi there'),
 				('Identifier', myIdentifier),
 				('FcRequestStatus', consts.RequestStatus.Success |
-													consts.RequestStatus.RemovedFromQueue
+													consts.RequestStatus.RemovedFromQueue |
+													consts.RequestStatus.Completed
 													),
 				)
 		reply = msg['FcPluginReply']
@@ -1712,7 +1725,8 @@
 				#('PluginName', 'hi there'),
 				('Identifier', myIdentifier),
 				('FcRequestStatus', consts.RequestStatus.Error |
-													consts.RequestStatus.RemovedFromQueue
+													consts.RequestStatus.RemovedFromQueue |
+													consts.RequestStatus.Completed
 													),
 				)
 				
@@ -1752,7 +1766,8 @@
 				('FcPublicKey','SSK@public'),
 				('FcPrivateKey','SSK@private'), 
 				('FcRequestStatus', consts.RequestStatus.Success | 
-													consts.RequestStatus.RemovedFromQueue
+													consts.RequestStatus.RemovedFromQueue |
+													consts.RequestStatus.Completed
 													),
 				)
 		self.failIf(myIdentifier in requestsAll)
@@ -1783,7 +1798,8 @@
 				('FcPublicKey','USK@public'),
 				('FcPrivateKey','USK@private'), 
 				('FcRequestStatus', consts.RequestStatus.Success | 
-													consts.RequestStatus.RemovedFromQueue
+													consts.RequestStatus.RemovedFromQueue |
+													consts.RequestStatus.Completed													
 													),
 				)
 		self.failIf(myIdentifier in requestsAll)


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

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

From: <ju...@us...> - 2008-02-23 08:18:14

Revision: 243
          http://fclient.svn.sourceforge.net/fclient/?rev=243&view=rev
Author:   jurner
Date:     2008-02-23 00:18:18 -0800 (Sat, 23 Feb 2008)

Log Message:
-----------
adapt to removed Fcp bugfix

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-23 08:17:33 UTC (rev 242)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-23 08:18:18 UTC (rev 243)
@@ -808,7 +808,6 @@
 				# blah.. more here
 				)
 		
-		print consts.RequestStatus.humanReadable(myRequest['FcRequestStatus'])
 		self.assertHasNextEvent(
 				self.fcpClient.events.RequestFailed,
 				consts.Message.ClientGet,
@@ -1135,7 +1134,7 @@
 		
 		# status of our request should be set to removed emidiately, but it should
 		# not be removed from the client
-		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Removed)
+		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Removed | consts.RequestStatus.Completed)
 		self.failUnless(myIdentifier in self.fcpClient.getRequests())
 		
 		# client schould send a RemovePersistentRequest


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

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

From: <ju...@us...> - 2008-02-24 11:50:22

Revision: 245
          http://fclient.svn.sourceforge.net/fclient/?rev=245&view=rev
Author:   jurner
Date:     2008-02-24 03:50:25 -0800 (Sun, 24 Feb 2008)

Log Message:
-----------
added tests for putRedirect()

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-24 11:48:04 UTC (rev 244)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-24 11:50:25 UTC (rev 245)
@@ -548,7 +548,6 @@
 		self.assertHasNextEvent(None)
 				
 		self.failUnless(myIdentifier in requestsAll)
-		myRequest = self.fcpClient.getRequest(myIdentifier)
 		self.assertEqual(myIdentifier, myRequest['Identifier'])
 		self.assertEqual(myRequest['FcRequestStatus'], consts.RequestStatus.Null)
 		
@@ -955,7 +954,79 @@
 #***********************************************************************************
 #
 #***********************************************************************************
-#TODO: class TestClientPut(BaseTestConnectedClient):
+#TODO:
+#
+#
+#
+class TestClientPut(BaseTestClient):
+	
+	
+	def testPutRedirect_Success(self):
+		# request a arbitrary file
+		myIdentifier = self.fcpClient.putRedirect(
+			'my-redirect-name',
+			'SSK@arbitrary-uri',
+			)
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
+		
+		self.assertHasNextMessage(consts.Message.ClientPut)
+		self.failUnless(myIdentifier in requestsAll)
+		
+		self.sendResponseMessage(
+				'PutSuccessful',
+				Identifier=myIdentifier,
+				URI='KSK@my-redirect-name'
+				)
+				
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestCompleted,
+				consts.Message.ClientPut,
+				('FcRequestStatus', 	consts.RequestStatus.Success | 
+													consts.RequestStatus.RemovedFromQueue |
+													consts.RequestStatus.Completed
+													),
+				)		
+				
+		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		self.failIf(requestsAll)		
+			
+		
+	def testPutRedirect_Failure(self):
+		# request a arbitrary file
+		myIdentifier = self.fcpClient.putRedirect(
+			'my-redirect-name',
+			'SSK@arbitrary-uri',
+			)
+		myRequest = self.fcpClient.getRequest(myIdentifier)
+		requestsAll = self.fcpClient.getRequests()
+		
+		self.assertHasNextMessage(consts.Message.ClientPut)
+		self.failUnless(myIdentifier in requestsAll)
+		
+		self.sendResponseMessage(
+				'PutFailed',
+				Identifier=myIdentifier,
+				Code='5', 			# rout not found
+				)
+				
+		self.assertHasNextEvent(
+				self.fcpClient.events.RequestFailed,
+				consts.Message.ClientPut,
+				('FcRequestStatus', 	consts.RequestStatus.Error | 
+													consts.RequestStatus.RemovedFromQueue |
+													consts.RequestStatus.Completed
+													),
+				)		
+				
+		self.assertHasNextEvent(None)
+		self.assertHasNextMessage(None)
+		self.failIf(requestsAll)		
+			
+		
+		
+		
 
 #***********************************************************************************
 #
@@ -1856,6 +1927,7 @@
 			TestConnect,
 			TestDisconnectReason,
 			TestClientGet,
+			TestClientPut,
 			TestRequests,
 			TestRestoreRequests,
 			TestDDA,


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

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

From: <ju...@us...> - 2008-02-26 09:09:38

Revision: 252
          http://fclient.svn.sourceforge.net/fclient/?rev=252&view=rev
Author:   jurner
Date:     2008-02-26 01:09:30 -0800 (Tue, 26 Feb 2008)

Log Message:
-----------
documentation fix

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-26 09:08:58 UTC (rev 251)
+++ trunk/sandbox/fcp/test_fcp/test_fcp2_0_client.py	2008-02-26 09:09:30 UTC (rev 252)
@@ -76,7 +76,7 @@
 class MySocketFactory(object):
 	"""Real and alive socket. Can be used to test against the running node. Not used currently
 	
-	Usage:
+	Usage::
 
 		DummySocketModule.socket = MySocketFactory()
 	


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