Subversion Repositories HomeAutomation

Rev

Rev 743 | Blame | Compare with Previous | Last modification | View Log | SVN | RSS feed

  1. import logging as log
  2. log.basicConfig(level=log.DEBUG,
  3.                 format='%(asctime)s %(levelname)s %(message)s',
  4.                 filename=__name__ + '.log',
  5.                 filemode='w')
  6. import unittest
  7.  
  8. from TCPServer import TCPServer
  9. from TCPClient import TCPClient
  10. import time
  11.  
  12. SERVER_BASE_PORT = 27000
  13. NUMBER_OF_SERVERS_FOR_MULTISERVER_TEST = 10
  14. NUMBER_OF_CLIENT_PER_SERVER_FOR_MULTISERVER_TEST = 10
  15.  
  16. class CanPktTests(unittest.TestCase):
  17.  
  18.     def setUp(self):
  19.         """Call before every test case."""
  20.         pass
  21.        
  22.     def tearDown(self):
  23.         """Call after every test case."""
  24.         pass
  25.     # -----------------------------------------
  26.  
  27.     class ServerRunner():
  28.        
  29.         serverNotifier = None
  30.         serverRunning = False
  31.         server = None
  32.         serverPort = None
  33.        
  34.         class ServerNotifier():
  35.            
  36.             parent = None
  37.             UNDEFINED = 0
  38.             TERMINATE = 1
  39.            
  40.             def __init__(self, parent):
  41.                 self.parent = parent
  42.        
  43.             def notify(self, msg):
  44.                 if msg == self.TERMINATE:
  45.                     log.debug('Server terminate notify')
  46.                     self.parent.serverRunning = False
  47.        
  48.         def __init__(self, port):
  49.             log.debug('Creating ServerRunner, port ' + str(port))
  50.             self.serverPort = port
  51.             pass
  52.        
  53.         def startServer(self):
  54.             self.serverNotifier = self.ServerNotifier(self)
  55.             self.server = TCPServer(self.serverPort, self.serverNotifier)
  56.             assert self.server.start() == True
  57.             self.serverRunning = True
  58.             return True
  59.            
  60.         def stopServer(self):
  61.             assert self.serverRunning == True
  62.             self.server.stop()
  63.             waitTime = 0
  64.             while self.serverRunning:
  65.                 log.debug('Waiting 0.2s for server shutdown..')
  66.                 time.sleep(0.2)
  67.                 waitTime += 0.2
  68.                 if waitTime > 4:
  69.                     log.debug('Giving up!')
  70.                     assert False
  71.                     break
  72.             self.server = None
  73.             return True
  74.        
  75.     # -----------------------------------------
  76.        
  77.     class ClientRunner():
  78.        
  79.         client = None
  80.         serverPort = None
  81.        
  82.         def __init__(self, port):
  83.             log.debug('Creating ClientRunner, port ' + str(port))
  84.             self.serverPort = port
  85.             pass
  86.        
  87.         def startClient(self):
  88.             self.client = TCPClient('localhost', self.serverPort)
  89.             return self.client.connect(2)
  90.    
  91.         def stopClient(self):
  92.             self.client.disconnect()
  93.             time.sleep(0.1)
  94.             self.client = None
  95.            
  96.     # -----------------------------------------
  97.    
  98.     def testA_TcpServer(self):
  99.         log.debug('testATcpServer')
  100.         serverRunner = self.ServerRunner(SERVER_BASE_PORT)
  101.         assert serverRunner.startServer() == True
  102.         assert serverRunner.stopServer() == True
  103.         serverRunner = None
  104.  
  105.     def testB_TcpClientNegative(self):
  106.         log.debug('testBTcpClientNegative')
  107.         clientRunner = self.ClientRunner(SERVER_BASE_PORT)
  108.         assert clientRunner.startClient() == False
  109.         clientRunner.stopClient()
  110.  
  111.     def testC_TcpServerWithSingleClient(self):
  112.         log.debug('testCTcpServerWithSingleClient')
  113.         serverRunner = self.ServerRunner(SERVER_BASE_PORT)
  114.         clientRunner = self.ClientRunner(SERVER_BASE_PORT)
  115.         assert serverRunner.startServer() == True
  116.         assert clientRunner.startClient() == True
  117.         clientRunner.stopClient()
  118.         assert serverRunner.stopServer() == True
  119.  
  120.     def testD_TcpConnection(self):
  121.         log.debug('testDTcpConnection')
  122.         serverRunner = self.ServerRunner(SERVER_BASE_PORT)
  123.         clientRunner = self.ClientRunner(SERVER_BASE_PORT)
  124.         assert serverRunner.startServer() == True
  125.         assert clientRunner.startClient() == True
  126.         log.debug('Server sends hej')
  127.         assert serverRunner.server.writeAll('hej') == True
  128.         time.sleep(1.0)
  129.         resp = str(clientRunner.client.read())
  130.         log.debug('Client gets:' + resp)
  131.         assert (resp == '\'hej\'')
  132.         clientRunner.stopClient()
  133.         assert serverRunner.stopServer() == True
  134.        
  135.     def testE_MultipleServersAndClients(self):
  136.         log.debug('testEMultipleServers')
  137.         serverList = []
  138.         clientList = []
  139.         for i in range(0, NUMBER_OF_SERVERS_FOR_MULTISERVER_TEST):
  140.             currentPort = SERVER_BASE_PORT + i
  141.             newServer = self.ServerRunner(currentPort)
  142.             serverList.append(newServer)
  143.             newServer.startServer()
  144.             for j in range(0, NUMBER_OF_CLIENT_PER_SERVER_FOR_MULTISERVER_TEST):
  145.                 newClient = self.ClientRunner(currentPort)
  146.                 clientList.append(newClient)
  147.                 newClient.startClient()
  148.                 log.debug('Client to ' + str(newClient.serverPort) + ' writing')
  149.                 newClient.client.write('hej')
  150.                
  151.         log.debug('Waiting 2 s for threads to work..')
  152.         time.sleep(2.0)
  153.         for s in serverList:
  154.             clientData = s.server.readAll()
  155.             log.debug(clientData)
  156.             log.debug(len(clientData))
  157.             assert len(clientData) == NUMBER_OF_CLIENT_PER_SERVER_FOR_MULTISERVER_TEST
  158.             assert s.stopServer() == True
  159.    
  160.