test updates

Author: dhoomakethu

test/test_bit_read_messages.py

@@ -45,7 +45,7 @@ def testReadBitBaseClassMethods(self):
         msg    = "ReadBitRequest(1,1)"
         self.assertEqual(msg, str(handle))
         handle = ReadBitsResponseBase([1,1])
-        msg    = "ReadBitResponse(2)"
+        msg    = "ReadBitsResponseBase(2)"
         self.assertEqual(msg, str(handle))
 
     def testBitReadBaseRequestEncoding(self):

test/test_client_sync.py

@@ -192,8 +192,10 @@ def testBasicSyncTcpClient(self, mock_select):
     def testTcpClientConnect(self):
         ''' Test the tcp client connection method'''
         with patch.object(socket, 'create_connection') as mock_method:
-            mock_method.return_value = object()
+            _socket = MagicMock()
+            mock_method.return_value = _socket
             client = ModbusTcpClient()
+            _socket.getsockname.return_value = ('dmmy', 1234)
             self.assertTrue(client.connect())
 
         with patch.object(socket, 'create_connection') as mock_method:

test/test_server_asyncio.py

@@ -72,6 +72,7 @@ def tearDown(self):
     # Test ModbusConnectedRequestHandler
     #-----------------------------------------------------------------------#
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testStartTcpServer(self):
         ''' Test that the modbus tcp asyncio server starts correctly '''
         identity = ModbusDeviceIdentification(info={0x00: 'VendorName'})
@@ -99,6 +100,7 @@ def testTcpServerServeForever(self):
             serve.assert_awaited()
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testTcpServerServeForeverTwice(self):
         ''' Call on serve_forever() twice should result in a runtime error '''
         server = yield from StartTcpServer(context=self.context,address=("127.0.0.1", 0), loop=self.loop)
@@ -112,6 +114,7 @@ def testTcpServerServeForeverTwice(self):
         server.server_close()
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testTcpServerReceiveData(self):
         ''' Test data sent on socket is received by internals - doesn't not process data '''
         data = b'\x01\x00\x00\x00\x00\x06\x01\x03\x00\x00\x00\x19'
@@ -146,6 +149,7 @@ def eof_received(self):
             server.server_close()
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testTcpServerRoundtrip(self):
         ''' Test sending and receiving data on tcp socket '''
         data = b"\x01\x00\x00\x00\x00\x06\x01\x03\x00\x00\x00\x01" # unit 1, read register
@@ -186,6 +190,7 @@ def eof_received(self):
         server.server_close()
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testTcpServerConnectionLost(self):
         ''' Test tcp stream interruption '''
         data = b"\x01\x00\x00\x00\x00\x06\x01\x01\x00\x00\x00\x01"
@@ -222,6 +227,7 @@ def connection_made(self, transport):
         server.server_close()
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testTcpServerCloseActiveConnection(self):
         ''' Test server_close() while there are active TCP connections '''
         data = b"\x01\x00\x00\x00\x00\x06\x01\x01\x00\x00\x00\x01"
@@ -254,6 +260,7 @@ def connection_made(self, transport):
         self.assertTrue( len(server.active_connections) == 0 )
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testTcpServerNoSlave(self):
         ''' Test unknown slave unit exception '''
         context = ModbusServerContext(slaves={0x01: self.store, 0x02: self.store  }, single=False)
@@ -290,6 +297,7 @@ def eof_received(self):
         server.server_close()
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testTcpServerModbusError(self):
         ''' Test sending garbage data on a TCP socket should drop the connection '''
         data = b"\x01\x00\x00\x00\x00\x06\x01\x03\x00\x00\x00\x01"  # get slave 5 function 3 (holding register)
@@ -329,6 +337,7 @@ def eof_received(self):
             server.server_close()
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testTcpServerInternalException(self):
         ''' Test sending garbage data on a TCP socket should drop the connection '''
         data = b"\x01\x00\x00\x00\x00\x06\x01\x03\x00\x00\x00\x01"  # get slave 5 function 3 (holding register)
@@ -373,6 +382,7 @@ def eof_received(self):
     # Test ModbusTlsProtocol
     #-----------------------------------------------------------------------#
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testStartTlsServer(self):
         ''' Test that the modbus tls asyncio server starts correctly '''
         with patch.object(ssl.SSLContext, 'load_cert_chain') as mock_method:
@@ -404,6 +414,7 @@ def testTlsServerServeForever(self):
                 serve.assert_awaited()
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testTlsServerServeForeverTwice(self):
         ''' Call on serve_forever() twice should result in a runtime error '''
         with patch.object(ssl.SSLContext, 'load_cert_chain') as mock_method:
@@ -423,6 +434,7 @@ def testTlsServerServeForeverTwice(self):
     #-----------------------------------------------------------------------#
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testStartUdpServer(self):
         ''' Test that the modbus udp asyncio server starts correctly '''
         identity = ModbusDeviceIdentification(info={0x00: 'VendorName'})
@@ -449,6 +461,7 @@ def testUdpServerServeForeverStart(self):
             serve.assert_awaited()
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testUdpServerServeForeverClose(self):
         ''' Test StartUdpServer serve_forever() method '''
         server = yield from StartUdpServer(context=self.context,address=("127.0.0.1", 0), loop=self.loop)
@@ -465,6 +478,7 @@ def testUdpServerServeForeverClose(self):
         self.assertTrue(server.protocol.is_closing())
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testUdpServerServeForeverTwice(self):
         ''' Call on serve_forever() twice should result in a runtime error '''
         identity = ModbusDeviceIdentification(info={0x00: 'VendorName'})
@@ -480,6 +494,7 @@ def testUdpServerServeForeverTwice(self):
         server.server_close()
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testUdpServerReceiveData(self):
         ''' Test that the sending data on datagram socket gets data pushed to framer '''
         server = yield from StartUdpServer(context=self.context,address=("127.0.0.1", 0),loop=self.loop)
@@ -501,6 +516,7 @@ def testUdpServerReceiveData(self):
             server.server_close()
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testUdpServerSendData(self):
         ''' Test that the modbus udp asyncio server correctly sends data outbound '''
         identity = ModbusDeviceIdentification(info={0x00: 'VendorName'})
@@ -543,6 +559,7 @@ def datagram_received(self, data, addr):
         yield from asyncio.sleep(0.1)
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testUdpServerRoundtrip(self):
         ''' Test sending and receiving data on udp socket'''
         data = b"\x01\x00\x00\x00\x00\x06\x01\x03\x00\x00\x00\x01" # unit 1, read register
@@ -581,6 +598,7 @@ def datagram_received(self, data, addr):
         server.server_close()
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testUdpServerException(self):
         ''' Test sending garbage data on a TCP socket should drop the connection '''
         garbage = b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF'
@@ -619,16 +637,19 @@ def datagram_received(self, data, addr):
     # -----------------------------------------------------------------------#
     # Test ModbusServerFactory
     # -----------------------------------------------------------------------#
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testModbusServerFactory(self):
         ''' Test the base class for all the clients '''
         with self.assertWarns(DeprecationWarning):
             factory = ModbusServerFactory(store=None)
 
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testStopServer(self):
         with self.assertWarns(DeprecationWarning):
             StopServer()
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testTcpServerException(self):
         ''' Sending garbage data on a TCP socket should drop the connection '''
         garbage = b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF'
@@ -669,6 +690,7 @@ def eof_received(self):
 
 
     @asyncio.coroutine
+    @pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
     def testTcpServerException(self):
         ''' Sending garbage data on a TCP socket should drop the connection '''
         garbage = b'\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF'

test/test_server_sync.py

@@ -365,9 +365,9 @@ def testSerialServerServeForever(self):
             with patch('pymodbus.server.sync.CustomSingleRequestHandler') as mock_handler:
                 server = ModbusSerialServer(None)
                 instance = mock_handler.return_value
-                instance.handle.side_effect = server.server_close
+                instance.response_manipulator.side_effect = server.server_close
                 server.serve_forever()
-                instance.handle.assert_any_call()
+                instance.response_manipulator.assert_any_call()
 
     def testSerialServerClose(self):
         ''' test that the synchronous serial server closes correctly '''