Pylint 29. (#791)

Author: janiversen

test/test_file_message.py

@@ -3,24 +3,31 @@
 Bit Message Test Fixture
 --------------------------------
 
-This fixture tests the functionality of all the 
+This fixture tests the functionality of all the
 bit based request/response messages:
 
 * Read/Write Discretes
 * Read Coils
 '''
 import unittest
-from pymodbus.file_message import *
-from pymodbus.exceptions import *
+from pymodbus.file_message import (
+    WriteFileRecordResponse,
+    FileRecord,
+    WriteFileRecordRequest,
+    ReadFileRecordRequest,
+    ReadFileRecordResponse,
+    ReadFifoQueueRequest,
+    ReadFifoQueueResponse,
+)
 from pymodbus.pdu import ModbusExceptions
 
 from .modbus_mocks import MockContext
 
 #---------------------------------------------------------------------------#
 # Fixture
 #---------------------------------------------------------------------------#
-class ModbusBitMessageTests(unittest.TestCase):
-
+class ModbusBitMessageTests(unittest.TestCase): # pylint: disable=too-many-public-methods
+    """ Modbus bit message tests. """
     #-----------------------------------------------------------------------#
     # Setup/TearDown
     #-----------------------------------------------------------------------#
@@ -30,29 +37,27 @@ def setUp(self):
         Initializes the test environment and builds request/result
         encoding pairs
         '''
-        pass
 
     def tearDown(self):
         ''' Cleans up the test environment '''
-        pass
 
     #-----------------------------------------------------------------------#
     # Read Fifo Queue
     #-----------------------------------------------------------------------#
 
-    def testReadFifoQueueRequestEncode(self):
+    def test_read_fifo_queue_request_encode(self):
         ''' Test basic bit message encoding/decoding '''
         handle  = ReadFifoQueueRequest(0x1234)
         result  = handle.encode()
         self.assertEqual(result, b'\x12\x34')
 
-    def testReadFifoQueueRequestDecode(self):
+    def test_read_fifo_queue_request_decode(self):
         ''' Test basic bit message encoding/decoding '''
         handle  = ReadFifoQueueRequest(0x0000)
         handle.decode(b'\x12\x34')
         self.assertEqual(handle.address, 0x1234)
 
-    def testReadFifoQueueRequest(self):
+    def test_read_fifo_queue_request(self):
         ''' Test basic bit message encoding/decoding '''
         context = MockContext()
         handle  = ReadFifoQueueRequest(0x1234)
@@ -69,29 +74,29 @@ def testReadFifoQueueRequest(self):
         self.assertEqual(ModbusExceptions.IllegalValue,
                 result.exception_code)
 
-    def testReadFifoQueueRequestError(self):
+    def test_read_fifo_queue_request_error(self):
         ''' Test basic bit message encoding/decoding '''
         context = MockContext()
         handle  = ReadFifoQueueRequest(0x1234)
         handle.values = [0x00]*32
         result = handle.execute(context)
         self.assertEqual(result.function_code, 0x98)
 
-    def testReadFifoQueueResponseEncode(self):
+    def test_read_fifo_queue_response_encode(self):
         ''' Test that the read fifo queue response can encode '''
         message = b'\x00\n\x00\x08\x00\x01\x00\x02\x00\x03\x00\x04'
         handle  = ReadFifoQueueResponse([1,2,3,4])
         result  = handle.encode()
         self.assertEqual(result, message)
 
-    def testReadFifoQueueResponseDecode(self):
+    def test_read_fifo_queue_response_decode(self):
         ''' Test that the read fifo queue response can decode '''
         message = b'\x00\n\x00\x08\x00\x01\x00\x02\x00\x03\x00\x04'
         handle  = ReadFifoQueueResponse([1,2,3,4])
         handle.decode(message)
         self.assertEqual(handle.values, [1,2,3,4])
 
-    def testRtuFrameSize(self):
+    def test_rtu_frame_size(self):
         ''' Test that the read fifo queue response can decode '''
         message = b'\x00\n\x00\x08\x00\x01\x00\x02\x00\x03\x00\x04'
         result  = ReadFifoQueueResponse.calculateRtuFrameSize(message)
@@ -101,14 +106,14 @@ def testRtuFrameSize(self):
     # File Record
     #-----------------------------------------------------------------------#
 
-    def testFileRecordLength(self):
+    def test_file_record_length(self):
         ''' Test file record length generation '''
         record = FileRecord(file_number=0x01, record_number=0x02,
             record_data=b'\x00\x01\x02\x04')
         self.assertEqual(record.record_length, 0x02)
         self.assertEqual(record.response_length, 0x05)
 
-    def testFileRecordComapre(self):
+    def test_file_record_compare(self):
         ''' Test file record comparison operations '''
         record1 = FileRecord(file_number=0x01, record_number=0x02, record_data=b'\x00\x01\x02\x04')
         record2 = FileRecord(file_number=0x01, record_number=0x02, record_data=b'\x00\x0a\x0e\x04')
@@ -128,29 +133,29 @@ def testFileRecordComapre(self):
     # Read File Record Request
     #-----------------------------------------------------------------------#
 
-    def testReadFileRecordRequestEncode(self):
+    def test_read_file_record_request_encode(self):
         ''' Test basic bit message encoding/decoding '''
         records = [FileRecord(file_number=0x01, record_number=0x02)]
         handle  = ReadFileRecordRequest(records)
         result  = handle.encode()
         self.assertEqual(result, b'\x07\x06\x00\x01\x00\x02\x00\x00')
 
-    def testReadFileRecordRequestDecode(self):
+    def test_read_file_record_request_decode(self):
         ''' Test basic bit message encoding/decoding '''
         record  = FileRecord(file_number=0x04, record_number=0x01, record_length=0x02)
         request = b'\x0e\x06\x00\x04\x00\x01\x00\x02\x06\x00\x03\x00\x09\x00\x02'
         handle  = ReadFileRecordRequest()
         handle.decode(request)
         self.assertEqual(handle.records[0], record)
 
-    def testReadFileRecordRequestRtuFrameSize(self):
+    def test_read_file_record_request_rtu_frame_size(self):
         ''' Test basic bit message encoding/decoding '''
         request = b'\x00\x00\x0e\x06\x00\x04\x00\x01\x00\x02\x06\x00\x03\x00\x09\x00\x02'
         handle  = ReadFileRecordRequest()
         size    = handle.calculateRtuFrameSize(request)
         self.assertEqual(size, 0x0e + 5)
 
-    def testReadFileRecordRequestExecute(self):
+    def test_read_file_record_request_execute(self):
         ''' Test basic bit message encoding/decoding '''
         handle  = ReadFileRecordRequest()
         result  = handle.execute(None)
@@ -160,14 +165,14 @@ def testReadFileRecordRequestExecute(self):
     # Read File Record Response
     #-----------------------------------------------------------------------#
 
-    def testReadFileRecordResponseEncode(self):
+    def test_read_file_record_response_encode(self):
         ''' Test basic bit message encoding/decoding '''
         records = [FileRecord(record_data=b'\x00\x01\x02\x03')]
         handle  = ReadFileRecordResponse(records)
         result  = handle.encode()
         self.assertEqual(result, b'\x06\x06\x02\x00\x01\x02\x03')
 
-    def testReadFileRecordResponseDecode(self):
+    def test_read_file_record_response_decode(self):
         ''' Test basic bit message encoding/decoding '''
         record  = FileRecord(file_number=0x00, record_number=0x00,
             record_data=b'\x0d\xfe\x00\x20')
@@ -176,7 +181,7 @@ def testReadFileRecordResponseDecode(self):
         handle.decode(request)
         self.assertEqual(handle.records[0], record)
 
-    def testReadFileRecordResponseRtuFrameSize(self):
+    def test_read_file_record_response_rtu_frame_size(self):
         ''' Test basic bit message encoding/decoding '''
         request = b'\x00\x00\x0c\x05\x06\x0d\xfe\x00\x20\x05\x05\x06\x33\xcd\x00\x40'
         handle  = ReadFileRecordResponse()
@@ -187,14 +192,15 @@ def testReadFileRecordResponseRtuFrameSize(self):
     # Write File Record Request
     #-----------------------------------------------------------------------#
 
-    def testWriteFileRecordRequestEncode(self):
+    def test_write_file_record_request_encode(self):
         ''' Test basic bit message encoding/decoding '''
-        records = [FileRecord(file_number=0x01, record_number=0x02, record_data=b'\x00\x01\x02\x03')]
+        records = [FileRecord(file_number=0x01, record_number=0x02,
+                record_data=b'\x00\x01\x02\x03')]
         handle  = WriteFileRecordRequest(records)
         result  = handle.encode()
         self.assertEqual(result, b'\x0b\x06\x00\x01\x00\x02\x00\x02\x00\x01\x02\x03')
 
-    def testWriteFileRecordRequestDecode(self):
+    def test_write_file_record_request_decode(self):
         ''' Test basic bit message encoding/decoding '''
         record  = FileRecord(file_number=0x04, record_number=0x07,
             record_data=b'\x06\xaf\x04\xbe\x10\x0d')
@@ -203,14 +209,14 @@ def testWriteFileRecordRequestDecode(self):
         handle.decode(request)
         self.assertEqual(handle.records[0], record)
 
-    def testWriteFileRecordRequestRtuFrameSize(self):
+    def test_write_file_record_request_rtu_frame_size(self):
         ''' Test write file record request rtu frame size calculation '''
         request = b'\x00\x00\x0d\x06\x00\x04\x00\x07\x00\x03\x06\xaf\x04\xbe\x10\x0d'
         handle  = WriteFileRecordRequest()
         size    = handle.calculateRtuFrameSize(request)
         self.assertEqual(size, 0x0d + 5)
 
-    def testWriteFileRecordRequestExecute(self):
+    def test_write_file_record_request_execute(self):
         ''' Test basic bit message encoding/decoding '''
         handle  = WriteFileRecordRequest()
         result  = handle.execute(None)
@@ -220,14 +226,15 @@ def testWriteFileRecordRequestExecute(self):
     # Write File Record Response
     #-----------------------------------------------------------------------#
 
-    def testWriteFileRecordResponseEncode(self):
+    def test_write_file_record_response_encode(self):
         ''' Test basic bit message encoding/decoding '''
-        records = [FileRecord(file_number=0x01, record_number=0x02, record_data=b'\x00\x01\x02\x03')]
+        records = [FileRecord(file_number=0x01, record_number=0x02,
+            record_data=b'\x00\x01\x02\x03')]
         handle  = WriteFileRecordResponse(records)
         result  = handle.encode()
         self.assertEqual(result, b'\x0b\x06\x00\x01\x00\x02\x00\x02\x00\x01\x02\x03')
 
-    def testWriteFileRecordResponseDecode(self):
+    def test_write_file_record_response_decode(self):
         ''' Test basic bit message encoding/decoding '''
         record  = FileRecord(file_number=0x04, record_number=0x07,
             record_data=b'\x06\xaf\x04\xbe\x10\x0d')
@@ -236,7 +243,7 @@ def testWriteFileRecordResponseDecode(self):
         handle.decode(request)
         self.assertEqual(handle.records[0], record)
 
-    def testWriteFileRecordResponseRtuFrameSize(self):
+    def test_write_file_record_response_rtu_frame_size(self):
         ''' Test write file record response rtu frame size calculation '''
         request = b'\x00\x00\x0d\x06\x00\x04\x00\x07\x00\x03\x06\xaf\x04\xbe\x10\x0d'
         handle  = WriteFileRecordResponse()