Subversion Repositories HomeAutomation

Rev

Rev 742 | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | SVN | RSS feed

Rev 742 Rev 743
Line 6... Line 6...
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 
 
- 
 
 12 
SERVER_BASE_PORT = 27000
- 
 
 13 
NUMBER_OF_SERVERS_FOR_MULTISERVER_TEST = 10
- 
 
 14 
NUMBER_OF_CLIENT_PER_SERVER_FOR_MULTISERVER_TEST = 10
11 
 
 15 
 
12 
class CanPktTests(unittest.TestCase):
 16 
class CanPktTests(unittest.TestCase):
13 
   
 - 
 
14 
    client = None
 - 
 
15 
   
 - 
 
16 
    server = None
 - 
 
17 
    serverNotifier = None
 - 
 
18 
    serverRunning = False
 - 
 
19 
 
 17 
 
20 
    def setUp(self):
 18 
    def setUp(self):
21 
        """Call before every test case."""
 19 
        """Call before every test case."""
22 
        pass
 20 
        pass
23 
       
 21 
       
24 
    def tearDown(self):
 22 
    def tearDown(self):
25 
        """Call after every test case."""
 23 
        """Call after every test case."""
- 
 
 24 
        pass
- 
 
 25 
    # -----------------------------------------
- 
 
 26 
 
- 
 
 27 
    class ServerRunner():
- 
 
 28 
       
- 
 
 29 
        serverNotifier = None
26 
        if self.serverRunning:
 30 
        serverRunning = False
- 
 
 31 
        server = None
27 
            self.stopServer()
 32 
        serverPort = None
28 
   
 33 
       
29 
    class ServerNotifier():
 34 
        class ServerNotifier():
30 
       
 35 
           
31 
        parent = None
 36 
            parent = None
32 
        UNDEFINED = 0
 37 
            UNDEFINED = 0
33 
        TERMINATE = 1
 38 
            TERMINATE = 1
Line 37... Line 42...
37 
   
 42 
       
38 
        def notify(self, msg):
 43 
            def notify(self, msg):
39 
            if msg == self.TERMINATE:
 44 
                if msg == self.TERMINATE:
40 
                log.debug('Server terminate notify')
 45 
                    log.debug('Server terminate notify')
41 
                self.parent.serverRunning = False
 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
42 
   
 52 
       
43 
    def startServer(self):
 53 
        def startServer(self):
44 
        self.serverNotifier = self.ServerNotifier(self)
 54 
            self.serverNotifier = self.ServerNotifier(self)
45 
        self.server = TCPServer(27000, self.serverNotifier)
 55 
            self.server = TCPServer(self.serverPort, self.serverNotifier)
46 
        assert self.server.start() == True
 56 
            assert self.server.start() == True
47 
        self.serverRunning = True
 57 
            self.serverRunning = True
- 
 
 58 
            return True
48 
       
 59 
           
49 
    def stopServer(self):
 60 
        def stopServer(self):
50 
        assert self.serverRunning == True
 61 
            assert self.serverRunning == True
51 
        self.server.stop()
 62 
            self.server.stop()
52 
        waitTime = 0
 63 
            waitTime = 0
Line 56... Line 67...
56 
            waitTime += 0.2
 67 
                waitTime += 0.2
57 
            if waitTime > 4:
 68 
                if waitTime > 4:
58 
                log.debug('Giving up!')
 69 
                    log.debug('Giving up!')
59 
                assert False
 70 
                    assert False
60 
                break
 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
61 
       
 86 
       
62 
    def startClient(self):
 87 
        def startClient(self):
63 
        self.client = TCPClient('localhost', 27000)
 88 
            self.client = TCPClient('localhost', self.serverPort)
64 
        return self.client.connect(1)
 89 
            return self.client.connect(2)
65 
 
 90 
   
66 
    def stopClient(self):
 91 
        def stopClient(self):
67 
        self.client.disconnect()
 92 
            self.client.disconnect()
68 
        time.sleep(0.1)
 93 
            time.sleep(0.1)
- 
 
 94 
            self.client = None
69 
   
 95 
           
70 
    def testATcpServer(self):
 96 
    # -----------------------------------------
71 
        self.startServer()
 - 
 
72 
        self.stopServer()
 - 
 
73 
 
 97 
   
74 
    def testBTcpClientNegative(self):
 98 
    def testA_TcpServer(self):
- 
 
 99 
        log.debug('testATcpServer')
- 
 
 100 
        serverRunner = self.ServerRunner(SERVER_BASE_PORT)
75 
        assert self.startClient() == False
 101 
        assert serverRunner.startServer() == True
- 
 
 102 
        assert serverRunner.stopServer() == True
76 
        self.stopClient()
 103 
        serverRunner = None
77 
 
 104 
 
78 
    def testCTcpServerWithSingleClient(self):
 105 
    def testB_TcpClientNegative(self):
79 
        self.startServer()
 106 
        log.debug('testBTcpClientNegative')
80 
        self.startClient()
 107 
        clientRunner = self.ClientRunner(SERVER_BASE_PORT)
81 
        self.stopClient()
 108 
        assert clientRunner.startClient() == False
82 
        self.stopServer()
 109 
        clientRunner.stopClient()
83 
 
 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 
 
84 
    def testDTcpConnection(self):
 120 
    def testD_TcpConnection(self):
85 
        log.debug('testTcpConnection')
 121 
        log.debug('testDTcpConnection')
- 
 
 122 
        serverRunner = self.ServerRunner(SERVER_BASE_PORT)
- 
 
 123 
        clientRunner = self.ClientRunner(SERVER_BASE_PORT)
86 
        self.startServer()
 124 
        assert serverRunner.startServer() == True
87 
        assert self.startClient() == True
 125 
        assert clientRunner.startClient() == True
88 
        log.debug('Server sends hej')
 126 
        log.debug('Server sends hej')
89 
        self.server.writeAll('hej')
 127 
        assert serverRunner.server.writeAll('hej') == True
90 
        time.sleep(0.5)
 128 
        time.sleep(1.0)
91 
        resp = str(self.client.read())
 129 
        resp = str(clientRunner.client.read())
92 
        log.debug('Client gets:' + resp)
 130 
        log.debug('Client gets:' + resp)
93 
        assert (resp == '\'hej\'')
 131 
        assert (resp == '\'hej\'')
94 
        self.stopClient()
 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)
95 
        self.stopServer()
 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