WebSVN – HomeAutomation – Diff – /branches/modules/PcSoftware/pyCanDaemon/tests/TCPClientServerTests.py


import logging as log
log.basicConfig(level=log.DEBUG,
                format='%(asctime)s %(levelname)s %(message)s',
                filename=__name__ + '.log',
                filemode='w')
import unittest
 
from TCPServer import TCPServer
from TCPClient import TCPClient
import time
 
SERVER_BASE_PORT = 27000
NUMBER_OF_SERVERS_FOR_MULTISERVER_TEST = 10
NUMBER_OF_CLIENT_PER_SERVER_FOR_MULTISERVER_TEST = 10
 
class CanPktTests(unittest.TestCase):
 
    def setUp(self):
        """Call before every test case."""
        pass
       
    def tearDown(self):
        """Call after every test case."""
        pass
    # -----------------------------------------
 
    class ServerRunner():
       
        serverNotifier = None
        serverRunning = False
        server = None
        serverPort = None
       
        class ServerNotifier():
           
            parent = None
            UNDEFINED = 0
            TERMINATE = 1
           
            def __init__(self, parent):
                self.parent = parent
       
            def notify(self, msg):
                if msg == self.TERMINATE:
                    log.debug('Server terminate notify')
                    self.parent.serverRunning = False
       
        def __init__(self, port):
            log.debug('Creating ServerRunner, port ' + str(port))
            self.serverPort = port
            pass
       
        def startServer(self):
            self.serverNotifier = self.ServerNotifier(self)
            self.server = TCPServer(self.serverPort, self.serverNotifier)
            assert self.server.start() == True
            self.serverRunning = True
            return True
           
        def stopServer(self):
            assert self.serverRunning == True
            self.server.stop()
            waitTime = 0
            while self.serverRunning:
                log.debug('Waiting 0.2s for server shutdown..')
                time.sleep(0.2)
                waitTime += 0.2
                if waitTime > 4:
                    log.debug('Giving up!')
                    assert False
                    break
            self.server = None
            return True
       
    # -----------------------------------------
       
    class ClientRunner():
       
        client = None
        serverPort = None
       
        def __init__(self, port):
            log.debug('Creating ClientRunner, port ' + str(port))
            self.serverPort = port
            pass
       
        def startClient(self):
            self.client = TCPClient('localhost', self.serverPort)
            return self.client.connect(2)
   
        def stopClient(self):
            self.client.disconnect()
            time.sleep(0.1)
            self.client = None
           
    # -----------------------------------------
   
    def testA_TcpServer(self):
        log.debug('testATcpServer')
        serverRunner = self.ServerRunner(SERVER_BASE_PORT)
        assert serverRunner.startServer() == True
        assert serverRunner.stopServer() == True
        serverRunner = None
 
    def testB_TcpClientNegative(self):
        log.debug('testBTcpClientNegative')
        clientRunner = self.ClientRunner(SERVER_BASE_PORT)
        assert clientRunner.startClient() == False
        clientRunner.stopClient()
 
    def testC_TcpServerWithSingleClient(self):
        log.debug('testCTcpServerWithSingleClient')
        serverRunner = self.ServerRunner(SERVER_BASE_PORT)
        clientRunner = self.ClientRunner(SERVER_BASE_PORT)
        assert serverRunner.startServer() == True
        assert clientRunner.startClient() == True
        clientRunner.stopClient()
        assert serverRunner.stopServer() == True
 
    def testD_TcpConnection(self):
        log.debug('testDTcpConnection')
        serverRunner = self.ServerRunner(SERVER_BASE_PORT)
        clientRunner = self.ClientRunner(SERVER_BASE_PORT)
        assert serverRunner.startServer() == True
        assert clientRunner.startClient() == True
        log.debug('Server sends hej')
        assert serverRunner.server.writeAll('hej') == True
        time.sleep(1.0)
        resp = str(clientRunner.client.read())
        log.debug('Client gets:' + resp)
        assert (resp == '\'hej\'')
        clientRunner.stopClient()
        assert serverRunner.stopServer() == True
       
    def testE_MultipleServersAndClients(self):
        log.debug('testEMultipleServers')
        serverList = []
        clientList = []
        for i in range(0, NUMBER_OF_SERVERS_FOR_MULTISERVER_TEST):
            currentPort = SERVER_BASE_PORT + i
            newServer = self.ServerRunner(currentPort)
            serverList.append(newServer)
            newServer.startServer()
            for j in range(0, NUMBER_OF_CLIENT_PER_SERVER_FOR_MULTISERVER_TEST):
                newClient = self.ClientRunner(currentPort)
                clientList.append(newClient)
                newClient.startClient()
                log.debug('Client to ' + str(newClient.serverPort) + ' writing')
                newClient.client.write('hej')
               
        log.debug('Waiting 2 s for threads to work..')
        time.sleep(2.0)
        for s in serverList:
            clientData = s.server.readAll()
            log.debug(clientData)
            log.debug(len(clientData))
            assert len(clientData) == NUMBER_OF_CLIENT_PER_SERVER_FOR_MULTISERVER_TEST
            assert s.stopServer() == True
   
       

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

Subversion Repositories HomeAutomation

(root)/branches/modules/PcSoftware/pyCanDaemon/tests/TCPClientServerTests.py – Rev 743 → 800