%s
\n' % doc packageContext.clean ( classes, object ) packageContext.clean ( funcs, object ) packageContext.clean ( data, object ) if hasattr(object, '__path__'): modpkgs = [] modnames = [] for file in os.listdir(object.__path__[0]): path = os.path.join(object.__path__[0], file) modname = inspect.getmodulename(file) if modname and modname not in modnames: modpkgs.append((modname, name, 0, 0)) modnames.append(modname) elif pydoc.ispackage(path): modpkgs.append((file, name, 1, 0)) modpkgs.sort() contents = self.multicolumn(modpkgs, self.modpkglink) ## result = result + self.bigsection( ## 'Package Contents', '#ffffff', '#aa55cc', contents) result = result + self.moduleSection( object, packageContext) elif modules: contents = self.multicolumn( modules, lambda (key, value), s=self: s.modulelink(value)) result = result + self.bigsection( 'Modules', '#fffff', '#aa55cc', contents) if classes: classlist = map(lambda (key, value): value, classes) contents = [ self.formattree(inspect.getclasstree(classlist, 1), name)] for key, value in classes: contents.append(self.document(value, key, name, fdict, cdict)) result = result + self.bigsection( 'Classes', '#ffffff', '#ee77aa', join(contents)) if funcs: contents = [] for key, value in funcs: contents.append(self.document(value, key, name, fdict, cdict)) result = result + self.bigsection( 'Functions', '#ffffff', '#eeaa77', join(contents)) if data: contents = [] for key, value in data: try: contents.append(self.document(value, key)) except Exception, err: pass result = result + self.bigsection( 'Data', '#ffffff', '#55aa55', join(contents, '
"""
if self.pre:
return '%d.%d.%d.%s' % (self.major, self.minor, self.micro, self.pre)
else:
return '%d.%d.%d' % (self.major, self.minor, self.micro)
def __str__(self):
""" Returns a string representation of the object
:returns: A string representation of this object
"""
return '[%s, version %s]' % (self.package, self.short())
version = Version('pymodbus', 2, 1, 0)
version.__name__ = 'pymodbus' # fix epydoc error
# --------------------------------------------------------------------------- #
# Exported symbols
# --------------------------------------------------------------------------- #
__all__ = ["version"]
pymodbus-2.1.0/requirements-checks.txt 0000664 0000000 0000000 00000000155 13355134677 0020115 0 ustar 00root root 0000000 0000000 # Python packages required to run `make check'.
flake8 >= 2.6.0
flake8-docstrings >= 0.2.8
pyflakes >= 1.2.3
pymodbus-2.1.0/requirements-docs.txt 0000664 0000000 0000000 00000001021 13355134677 0017576 0 ustar 00root root 0000000 0000000 # Python packages required to run `make docs'.
cryptography>= 2.3 # Required to parse some files
humanfriendly==4.4.1
pyasn1==0.4.2 # Required to parse some files
pyserial-asyncio==0.4.0;python_version>="3.4"
pyserial==3.4 # Required to parse some files
redis==2.10.6 # Required to parse some files
recommonmark==0.4.0
Sphinx==1.6.5
sphinx-rtd-theme==0.2.4
SQLAlchemy==1.1.15 # Required to parse some files
tornado==4.5.2 # Required to parse some files
twisted>= 12.2.0 # Required to parse some files
pymodbus-2.1.0/requirements-tests.txt 0000664 0000000 0000000 00000000501 13355134677 0020012 0 ustar 00root root 0000000 0000000 capturer >= 2.2
coverage >= 4.2
cryptography>=1.8.1
mock >= 1.0.1
pyserial-asyncio==0.4.0;python_version>="3.4"
pep8>=1.7.0
pyasn1>=0.2.3
pycrypto>=2.6.1
pyserial>=3.4
pytest-cov>=2.5.1
pytest>=3.5.0
redis>=2.10.5
sqlalchemy>=1.1.15
#wsgiref>=0.1.2
verboselogs >= 1.5
tornado==4.5.3
Twisted>=17.1.0
zope.interface>=4.4.0
pymodbus-2.1.0/requirements.txt 0000664 0000000 0000000 00000003377 13355134677 0016670 0 ustar 00root root 0000000 0000000 six==1.11.0
# -------------------------------------------------------------------
# if want to use the pymodbus serial stack, uncomment these
# -------------------------------------------------------------------
# pyserial>=3.4
# -------------------------------------------------------------------
# if you want to run the tests and code coverage, uncomment these
# -------------------------------------------------------------------
#coverage==4.4
#mock==2.0.0
#nose==1.3.7
#pep8==1.7.0
# -------------------------------------------------------------------
# if you want to use the Twisted asynchronous version, uncomment these
# -------------------------------------------------------------------
#Twisted==17.1.0
#zope.interface==4.4.0
#pyasn1==0.2.3
#pycrypto==2.6.1
#wsgiref==0.1.2
#cryptography==1.8.1
# -------------------------------------------------------------------
# if you want to use the Tornado asynchronous version, uncomment these
# -------------------------------------------------------------------
# tornado==4.5.2
# -------------------------------------------------------------------
# if you want to use the Asyncio asynchronous version, uncomment these
# -------------------------------------------------------------------
# pyserial-asyncio==0.4.0;python_version>="3.4"
# -------------------------------------------------------------------
# if you want to build the documentation, uncomment these
# -------------------------------------------------------------------
#Jinja2==2.9.6
#Pygments==2.2.0
#Sphinx==1.5.5
#docutils==0.13.1
#pydoctor==16.3.0
# -------------------------------------------------------------------
# if you want to use pymodbus REPL
# -------------------------------------------------------------------
# click>=6.7
# prompt-toolkit==2.0.4 pymodbus-2.1.0/scripts/ 0000775 0000000 0000000 00000000000 13355134677 0015061 5 ustar 00root root 0000000 0000000 pymodbus-2.1.0/scripts/travis.sh 0000775 0000000 0000000 00000000346 13355134677 0016733 0 ustar 00root root 0000000 0000000 #!/bin/bash -e
if [ "$TRAVIS_OS_NAME" = osx ]; then
VIRTUAL_ENV="$HOME/.virtualenvs/python2.7"
if [ ! -x "$VIRTUAL_ENV/bin/python" ]; then
virtualenv "$VIRTUAL_ENV"
fi
source "$VIRTUAL_ENV/bin/activate"
fi
eval "$@"
pymodbus-2.1.0/setup.cfg 0000664 0000000 0000000 00000000570 13355134677 0015215 0 ustar 00root root 0000000 0000000 [aliases]
upload_docs = build_sphinx upload_docs
package = build_apidocs build_sphinx sdist
test=pytest
[egg_info]
#tag_build = dev
tag_svn_revision = false
[build-sphinx]
source-dir = doc/sphinx/
build-dir = doc/sphinx/build
all_files = 1
[upload_docs]
upload-dir = build/sphinx/html
[bdist_wheel]
universal=1
[tool:pytest]
testpaths = test
addopts = -p no:warnings
pymodbus-2.1.0/setup.py 0000664 0000000 0000000 00000006524 13355134677 0015113 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
"""
Installs pymodbus using distutils
Run:
python setup.py install
to install the package from the source archive.
For information about setuptools
http://peak.telecommunity.com/DevCenter/setuptools#new-and-changed-setup-keywords
"""
# --------------------------------------------------------------------------- #
# initialization
# --------------------------------------------------------------------------- #
try: # if not installed, install and proceed
from setuptools import setup, find_packages
except ImportError:
from ez_setup import use_setuptools
use_setuptools()
from setuptools import setup, find_packages
try:
from setup_commands import command_classes
except ImportError:
command_classes={}
from pymodbus import __version__, __author__, __maintainer__
with open('requirements.txt') as reqs:
install_requires = [
line for line in reqs.read().split('\n')
if (line and not line.startswith('--'))
]
install_requires.append("pyserial >= 3.4")
# --------------------------------------------------------------------------- #
# configuration
# --------------------------------------------------------------------------- #
setup(
name="pymodbus",
version=__version__,
description="A fully featured modbus protocol stack in python",
long_description="""
Pymodbus aims to be a fully implemented modbus protocol stack
implemented using twisted/asyncio/tornado.
Its orignal goal was to allow simulation of thousands of modbus devices
on a single machine for monitoring software testing.
""",
classifiers=[
'Development Status :: 4 - Beta',
'Environment :: Console',
'Environment :: X11 Applications :: GTK',
'Framework :: Twisted',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Operating System :: POSIX :: Linux',
'Operating System :: Unix',
'Programming Language :: Python',
'Topic :: System :: Networking',
'Topic :: Utilities'
],
keywords='modbus, twisted, scada',
author=__author__,
author_email='bashwork@gmail.com',
maintainer=__maintainer__,
maintainer_email='otlasanju@gmail.com',
url='https://github.com/riptideio/pymodbus/',
license='BSD',
packages=find_packages(exclude=['examples', 'test']),
exclude_package_data={'': ['examples', 'test', 'tools', 'doc']},
py_modules=['ez_setup'],
platforms=['Linux', 'Mac OS X', 'Win'],
include_package_data=True,
zip_safe=True,
install_requires=install_requires,
extras_require={
'quality': [
'coverage >= 3.5.3',
'nose >= 1.2.1',
'mock >= 1.0.0',
'pep8 >= 1.3.3'
],
'documents': ['sphinx >= 1.1.3',
'sphinx_rtd_theme',
'humanfriendly'],
'twisted': [
'twisted >= 12.2.0',
'pyasn1 >= 0.1.4',
'pycrypto >= 2.6'
],
'tornado': [
'tornado >= 4.5.3'
],
'repl': [
'click>=6.7',
'prompt-toolkit==2.0.4',
'pygments==2.2.0'
]
},
entry_points={
'console_scripts': ['pymodbus.console=pymodbus.repl.main:main'],
},
test_suite='nose.collector',
cmdclass=command_classes,
)
pymodbus-2.1.0/setup_commands.py 0000775 0000000 0000000 00000012705 13355134677 0016775 0 ustar 00root root 0000000 0000000 from distutils.core import Command
import sys, os, shutil
# --------------------------------------------------------------------------- #
# Extra Commands
# --------------------------------------------------------------------------- #
class BuildApiDocsCommand(Command):
""" Helper command to build the available api documents
This scans all the subdirectories under api and runs the
build.py script underneath trying to build the api
documentation for the given format.
"""
description = "build all the projects api documents"
user_options = []
def initialize_options(self):
""" options setup """
if not os.path.exists('./build'):
os.mkdir('./build')
def finalize_options(self):
""" options teardown """
pass
def run(self):
""" command runner """
old_cwd = os.getcwd()
directories = (d for d in os.listdir('./doc/api') if not d.startswith('.'))
for entry in directories:
os.chdir('./doc/api/%s' % entry)
os.system('python build.py')
os.chdir(old_cwd)
class DeepCleanCommand(Command):
"""
Helper command to return the directory to a completely
clean state.
"""
description = "clean everything that we don't want"
user_options = []
trash = ['build', 'dist', 'pymodbus.egg-info',
os.path.join(os.path.join('doc', 'sphinx'), 'build'),
]
def initialize_options(self):
""" options setup """
pass
def finalize_options(self):
pass
def run(self):
""" command runner """
self._delete_pyc_files()
self._delete_trash_dirs()
def _delete_trash_dirs(self):
""" remove all directories created in building """
self._delete_pyc_files()
for directory in self.trash:
if os.path.exists(directory):
shutil.rmtree(directory)
@staticmethod
def _delete_pyc_files():
""" remove all python cache files """
for root, dirs, files in os.walk('.'):
for file in files:
if file.endswith('.pyc'):
os.remove(os.path.join(root,file))
class LintCommand(Command):
"""
Helper command to perform a lint scan of the
sourcecode and return the results.
"""
description = "perform a lint scan of the code"
user_options = []
def initialize_options(self):
""" options setup """
if not os.path.exists('./build'):
os.mkdir('./build')
def finalize_options(self):
pass
def run(self):
""" command runner """
scanners = [s for s in dir(self) if s.find('__try') >= 0]
for scanner in scanners:
if getattr(self, scanner)():
break
def _try_pyflakes(self):
try:
from pyflakes.scripts.pyflakes import main
sys.argv = """pyflakes pymodbus""".split()
main()
return True
except Exception:
return False
def _try_pychecker(self):
try:
import pychecker
sys.argv = """pychecker pymodbus/*.py""".split()
main()
return True
except: return False
def _try_pylint(self):
try:
import pylint
sys.argv = """pylint pymodbus/*.py""".split()
main()
return True
except: return False
class Python3Command(Command):
""" Helper command to scan for potential python 3
errors.
./setup.py scan_2to3 > build/diffs_2to3 build/report_2to3
"""
description = "perform 2to3 scan of the code"
user_options = []
directories = ['pymodbus', 'test', 'examples']
def initialize_options(self):
""" options setup """
if not os.path.exists('./build'):
os.mkdir('./build')
def finalize_options(self):
pass
def run(self):
""" command runner """
self._run_python3()
def _run_python3(self):
try:
from lib2to3.main import main
sys.argv = ['2to3'] + self.directories
main("lib2to3.fixes")
return True
except: return False
class Pep8Command(Command):
"""
Helper command to scan for potential pep8 violations
"""
description = "perform pep8 scan of the code"
user_options = []
directories = ['pymodbus']
def initialize_options(self):
""" options setup """
if not os.path.exists('./build'):
os.mkdir('./build')
def finalize_options(self):
pass
def run(self):
""" command runner """
self._run_pep8()
def _run_pep8(self):
try:
from pep8 import _main as main
sys.argv = """pep8 --repeat --count --statistics
""".split() + self.directories
main()
return True
except Exception:
return False
# --------------------------------------------------------------------------- #
# Command Configuration
# --------------------------------------------------------------------------- #
command_classes = {
'deep_clean': DeepCleanCommand,
'build_apidocs': BuildApiDocsCommand,
'lint': LintCommand,
'scan_2to3': Python3Command,
'pep8': Pep8Command,
}
# --------------------------------------------------------------------------- #
# Export command list
# --------------------------------------------------------------------------- #
__all__ = ['command_classes']
pymodbus-2.1.0/test/ 0000775 0000000 0000000 00000000000 13355134677 0014351 5 ustar 00root root 0000000 0000000 pymodbus-2.1.0/test/__init__.py 0000664 0000000 0000000 00000000000 13355134677 0016450 0 ustar 00root root 0000000 0000000 pymodbus-2.1.0/test/asyncio_test_helper.py 0000664 0000000 0000000 00000003343 13355134677 0020771 0 ustar 00root root 0000000 0000000 from pymodbus.compat import IS_PYTHON3
if IS_PYTHON3:
import functools
def _yielded_return(return_value, *args):
"""Generator factory function with return value."""
def _():
"""Actual generator producing value."""
yield
return return_value
# return new generator each time this function is called:
return _()
def return_as_coroutine(return_value=None):
"""Creates a function that behaves like an asyncio coroutine and returns the given value.
Typically used as a side effect of a mocked coroutine like this:
# in module mymod:
@asyncio.coroutine
def my_coro_under_test():
yield from asyncio.sleep(1)
yield from asyncio.sleep(2)
return 42
# in test module:
@mock.patch('mymod.asyncio.sleep')
def test_it(mock_sleep):
mock_sleep.side_effect = return_as_coroutine()
result = run_coroutine(my_coro_under_test)
assert mock_sleep.call_count == 2
assert mock_sleep.call_args_list == [mock.call(1), mock.call(2)]
assert result == 42
"""
return functools.partial(_yielded_return, return_value)
def run_coroutine(coro):
"""Runs a coroutine as top-level task by iterating through all yielded steps."""
result = None
try:
# step through all parts of coro without scheduling anything else:
while True:
result = coro.send(result)
except StopIteration as ex:
# coro reached end pass on its return value:
return ex.value
except:
raise
pymodbus-2.1.0/test/modbus_mocks.py 0000664 0000000 0000000 00000001467 13355134677 0017420 0 ustar 00root root 0000000 0000000 from pymodbus.interfaces import IModbusSlaveContext
#---------------------------------------------------------------------------#
# Mocks
#---------------------------------------------------------------------------#
class mock(object): pass
class MockContext(IModbusSlaveContext):
def __init__(self, valid=False, default=True):
self.valid = valid
self.default = default
def validate(self, fx, address, count):
return self.valid
def getValues(self, fx, address, count):
return [self.default] * count
def setValues(self, fx, address, count):
pass
class FakeList(object):
''' todo, replace with magic mock '''
def __init__(self, size):
self.size = size
def __len__(self):
return self.size
def __iter__(self):
return []
pymodbus-2.1.0/test/test_all_messages.py 0000664 0000000 0000000 00000006632 13355134677 0020430 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.constants import Defaults
from pymodbus.bit_read_message import *
from pymodbus.bit_write_message import *
from pymodbus.register_read_message import *
from pymodbus.register_write_message import *
#---------------------------------------------------------------------------#
# Fixture
#---------------------------------------------------------------------------#
class ModbusAllMessagesTests(unittest.TestCase):
#-----------------------------------------------------------------------#
# Setup/TearDown
#-----------------------------------------------------------------------#
def setUp(self):
'''
Initializes the test environment and builds request/result
encoding pairs
'''
arguments = {
'read_address': 1, 'read_count': 1,
'write_address': 1, 'write_registers': 1
}
self.requests = [
lambda unit: ReadCoilsRequest(1, 5, unit=unit),
lambda unit: ReadDiscreteInputsRequest(1, 5, unit=unit),
lambda unit: WriteSingleCoilRequest(1, 1, unit=unit),
lambda unit: WriteMultipleCoilsRequest(1, [1], unit=unit),
lambda unit: ReadHoldingRegistersRequest(1, 5, unit=unit),
lambda unit: ReadInputRegistersRequest(1, 5, unit=unit),
lambda unit: ReadWriteMultipleRegistersRequest(unit=unit, **arguments),
lambda unit: WriteSingleRegisterRequest(1, 1, unit=unit),
lambda unit: WriteMultipleRegistersRequest(1, [1], unit=unit),
]
self.responses = [
lambda unit: ReadCoilsResponse([1], unit=unit),
lambda unit: ReadDiscreteInputsResponse([1], unit=unit),
lambda unit: WriteSingleCoilResponse(1, 1, unit=unit),
lambda unit: WriteMultipleCoilsResponse(1, [1], unit=unit),
lambda unit: ReadHoldingRegistersResponse([1], unit=unit),
lambda unit: ReadInputRegistersResponse([1], unit=unit),
lambda unit: ReadWriteMultipleRegistersResponse([1], unit=unit),
lambda unit: WriteSingleRegisterResponse(1, 1, unit=unit),
lambda unit: WriteMultipleRegistersResponse(1, 1, unit=unit),
]
def tearDown(self):
''' Cleans up the test environment '''
pass
def testInitializingSlaveAddressRequest(self):
''' Test that every request can initialize the unit id '''
unit_id = 0x12
for factory in self.requests:
request = factory(unit_id)
self.assertEqual(request.unit_id, unit_id)
def testInitializingSlaveAddressResponse(self):
''' Test that every response can initialize the unit id '''
unit_id = 0x12
for factory in self.responses:
response = factory(unit_id)
self.assertEqual(response.unit_id, unit_id)
def testForwardingKwargsToPdu(self):
''' Test that the kwargs are forwarded to the pdu correctly '''
request = ReadCoilsRequest(1,5, unit=0x12, transaction=0x12, protocol=0x12)
self.assertEqual(request.unit_id, 0x12)
self.assertEqual(request.transaction_id, 0x12)
self.assertEqual(request.protocol_id, 0x12)
request = ReadCoilsRequest(1,5)
self.assertEqual(request.unit_id, Defaults.UnitId)
self.assertEqual(request.transaction_id, Defaults.TransactionId)
self.assertEqual(request.protocol_id, Defaults.ProtocolId)
pymodbus-2.1.0/test/test_bit_read_messages.py 0000664 0000000 0000000 00000011563 13355134677 0021430 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
"""
Bit Message Test Fixture
--------------------------------
This fixture tests the functionality of all the
bit based request/response messages:
* Read/Write Discretes
* Read Coils
"""
import unittest, struct
from pymodbus.bit_read_message import *
from pymodbus.bit_read_message import ReadBitsRequestBase
from pymodbus.bit_read_message import ReadBitsResponseBase
from pymodbus.exceptions import *
from pymodbus.pdu import ModbusExceptions
from pymodbus.compat import iteritems
from .modbus_mocks import MockContext
res = [True] * 21
res.extend([False] * 3)
#---------------------------------------------------------------------------#
# Fixture
#---------------------------------------------------------------------------#
class ModbusBitMessageTests(unittest.TestCase):
#-----------------------------------------------------------------------#
# Setup/TearDown
#-----------------------------------------------------------------------#
def setUp(self):
"""
Initializes the test environment and builds request/result
encoding pairs
"""
pass
def tearDown(self):
""" Cleans up the test environment """
pass
def testReadBitBaseClassMethods(self):
""" Test basic bit message encoding/decoding """
handle = ReadBitsRequestBase(1, 1)
msg = "ReadBitRequest(1,1)"
self.assertEqual(msg, str(handle))
handle = ReadBitsResponseBase([1,1])
msg = "ReadBitResponse(2)"
self.assertEqual(msg, str(handle))
def testBitReadBaseRequestEncoding(self):
""" Test basic bit message encoding/decoding """
for i in range(20):
handle = ReadBitsRequestBase(i, i)
result = struct.pack('>HH',i, i)
self.assertEqual(handle.encode(), result)
handle.decode(result)
self.assertEqual((handle.address, handle.count), (i,i))
def testBitReadBaseResponseEncoding(self):
""" Test basic bit message encoding/decoding """
for i in range(20):
input = [True] * i
handle = ReadBitsResponseBase(input)
result = handle.encode()
handle.decode(result)
self.assertEqual(handle.bits[:i], input)
def testBitReadBaseResponseHelperMethods(self):
""" Test the extra methods on a ReadBitsResponseBase """
input = [False] * 8
handle = ReadBitsResponseBase(input)
for i in [1,3,5]: handle.setBit(i, True)
for i in [1,3,5]: handle.resetBit(i)
for i in range(8):
self.assertEqual(handle.getBit(i), False)
def testBitReadBaseRequests(self):
""" Test bit read request encoding """
messages = {
ReadBitsRequestBase(12, 14) : b'\x00\x0c\x00\x0e',
ReadBitsResponseBase([1,0,1,1,0]) : b'\x01\x0d'
}
for request, expected in iteritems(messages):
self.assertEqual(request.encode(), expected)
def testBitReadMessageExecuteValueErrors(self):
""" Test bit read request encoding """
context = MockContext()
requests = [
ReadCoilsRequest(1,0x800),
ReadDiscreteInputsRequest(1,0x800),
]
for request in requests:
result = request.execute(context)
self.assertEqual(ModbusExceptions.IllegalValue,
result.exception_code)
def testBitReadMessageExecuteAddressErrors(self):
""" Test bit read request encoding """
context = MockContext()
requests = [
ReadCoilsRequest(1,5),
ReadDiscreteInputsRequest(1,5),
]
for request in requests:
result = request.execute(context)
self.assertEqual(ModbusExceptions.IllegalAddress, result.exception_code)
def testBitReadMessageExecuteSuccess(self):
""" Test bit read request encoding """
context = MockContext()
context.validate = lambda a,b,c: True
requests = [
ReadCoilsRequest(1,5),
ReadDiscreteInputsRequest(1,5),
]
for request in requests:
result = request.execute(context)
self.assertEqual(result.bits, [True] * 5)
def testBitReadMessageGetResponsePDU(self):
requests = {
ReadCoilsRequest(1,5): 3,
ReadCoilsRequest(1, 8): 3,
ReadCoilsRequest(0, 16): 4,
ReadDiscreteInputsRequest(1, 21): 5,
ReadDiscreteInputsRequest(1, 24): 5,
ReadDiscreteInputsRequest(1, 1900): 240,
}
for request, expected in iteritems(requests):
pdu_len = request.get_response_pdu_size()
self.assertEqual(pdu_len, expected)
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_bit_write_messages.py 0000664 0000000 0000000 00000011267 13355134677 0021650 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
'''
Bit Message Test Fixture
--------------------------------
This fixture tests the functionality of all the
bit based request/response messages:
* Read/Write Discretes
* Read Coils
'''
import unittest
from pymodbus.bit_write_message import *
from pymodbus.exceptions import *
from pymodbus.pdu import ModbusExceptions
from pymodbus.compat import iteritems
from .modbus_mocks import MockContext, FakeList
#---------------------------------------------------------------------------#
# Fixture
#---------------------------------------------------------------------------#
class ModbusBitMessageTests(unittest.TestCase):
#-----------------------------------------------------------------------#
# Setup/TearDown
#-----------------------------------------------------------------------#
def setUp(self):
'''
Initializes the test environment and builds request/result
encoding pairs
'''
pass
def tearDown(self):
''' Cleans up the test environment '''
pass
def testBitWriteBaseRequests(self):
messages = {
WriteSingleCoilRequest(1, 0xabcd) : b'\x00\x01\xff\x00',
WriteSingleCoilResponse(1, 0xabcd) : b'\x00\x01\xff\x00',
WriteMultipleCoilsRequest(1, [True]*5) : b'\x00\x01\x00\x05\x01\x1f',
WriteMultipleCoilsResponse(1, 5) : b'\x00\x01\x00\x05',
}
for request, expected in iteritems(messages):
self.assertEqual(request.encode(), expected)
def testBitWriteMessageGetResponsePDU(self):
requests = {
WriteSingleCoilRequest(1, 0xabcd): 5
}
for request, expected in iteritems(requests):
pdu_len = request.get_response_pdu_size()
self.assertEqual(pdu_len, expected)
def testWriteMultipleCoilsRequest(self):
request = WriteMultipleCoilsRequest(1, [True]*5)
request.decode(b'\x00\x01\x00\x05\x01\x1f')
self.assertEqual(request.byte_count, 1)
self.assertEqual(request.address, 1)
self.assertEqual(request.values, [True]*5)
def testInvalidWriteMultipleCoilsRequest(self):
request = WriteMultipleCoilsRequest(1, None)
self.assertEqual(request.values, [])
def testWriteSingleCoilRequestEncode(self):
request = WriteSingleCoilRequest(1, False)
self.assertEqual(request.encode(), b'\x00\x01\x00\x00')
def testWriteSingleCoilExecute(self):
context = MockContext(False, default=True)
request = WriteSingleCoilRequest(2, True)
result = request.execute(context)
self.assertEqual(result.exception_code, ModbusExceptions.IllegalAddress)
context.valid = True
result = request.execute(context)
self.assertEqual(result.encode(), b'\x00\x02\xff\x00')
context = MockContext(True, default=False)
request = WriteSingleCoilRequest(2, False)
result = request.execute(context)
self.assertEqual(result.encode(), b'\x00\x02\x00\x00')
def testWriteMultipleCoilsExecute(self):
context = MockContext(False)
# too many values
request = WriteMultipleCoilsRequest(2, FakeList(0x123456))
result = request.execute(context)
self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)
# bad byte count
request = WriteMultipleCoilsRequest(2, [0x00]*4)
request.byte_count = 0x00
result = request.execute(context)
self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)
# does not validate
context.valid = False
request = WriteMultipleCoilsRequest(2, [0x00]*4)
result = request.execute(context)
self.assertEqual(result.exception_code, ModbusExceptions.IllegalAddress)
# validated request
context.valid = True
result = request.execute(context)
self.assertEqual(result.encode(), b'\x00\x02\x00\x04')
def testWriteMultipleCoilsResponse(self):
response = WriteMultipleCoilsResponse()
response.decode(b'\x00\x80\x00\x08')
self.assertEqual(response.address, 0x80)
self.assertEqual(response.count, 0x08)
def testSerializingToString(self):
requests = [
WriteSingleCoilRequest(1, 0xabcd),
WriteSingleCoilResponse(1, 0xabcd),
WriteMultipleCoilsRequest(1, [True]*5),
WriteMultipleCoilsResponse(1, 5),
]
for request in requests:
self.assertTrue(str(request) != None)
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_client_async.py 0000664 0000000 0000000 00000025162 13355134677 0020443 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
import pytest
from pymodbus.compat import IS_PYTHON3, PYTHON_VERSION
if IS_PYTHON3 and PYTHON_VERSION >= (3, 4):
from unittest.mock import patch, Mock, MagicMock
import asyncio
from pymodbus.client.async.asyncio import AsyncioModbusSerialClient
from serial_asyncio import SerialTransport
else:
from mock import patch, Mock, MagicMock
import platform
from distutils.version import LooseVersion
from pymodbus.client.async.serial import AsyncModbusSerialClient
from pymodbus.client.async.tcp import AsyncModbusTCPClient
from pymodbus.client.async.udp import AsyncModbusUDPClient
from pymodbus.client.async.tornado import AsyncModbusSerialClient as AsyncTornadoModbusSerialClient
from pymodbus.client.async.tornado import AsyncModbusTCPClient as AsyncTornadoModbusTcpClient
from pymodbus.client.async.tornado import AsyncModbusUDPClient as AsyncTornadoModbusUdoClient
from pymodbus.client.async import schedulers
from pymodbus.factory import ClientDecoder
from pymodbus.exceptions import ConnectionException
from pymodbus.transaction import ModbusSocketFramer, ModbusRtuFramer, ModbusAsciiFramer, ModbusBinaryFramer
from pymodbus.client.async.twisted import ModbusSerClientProtocol
IS_DARWIN = platform.system().lower() == "darwin"
OSX_SIERRA = LooseVersion("10.12")
if IS_DARWIN:
IS_HIGH_SIERRA_OR_ABOVE = LooseVersion(platform.mac_ver()[0])
SERIAL_PORT = '/dev/ttyp0' if not IS_HIGH_SIERRA_OR_ABOVE else '/dev/ptyp0'
else:
IS_HIGH_SIERRA_OR_ABOVE = False
SERIAL_PORT = "/dev/ptmx"
# ---------------------------------------------------------------------------#
# Fixture
# ---------------------------------------------------------------------------#
def mock_asyncio_gather(coro):
return coro
class TestAsynchronousClient(object):
"""
This is the unittest for the pymodbus.client.async module
"""
# -----------------------------------------------------------------------#
# Test TCP Client client
# -----------------------------------------------------------------------#
def testTcpTwistedClient(self):
"""
Test the TCP Twisted client
:return:
"""
from twisted.internet import reactor
with patch("twisted.internet.reactor") as mock_reactor:
def test_callback(client):
pass
def test_errback(client):
pass
AsyncModbusTCPClient(schedulers.REACTOR,
framer=ModbusSocketFramer(ClientDecoder()),
callback=test_callback,
errback=test_errback)
@patch("pymodbus.client.async.tornado.IOLoop")
@patch("pymodbus.client.async.tornado.IOStream")
def testTcpTornadoClient(self, mock_iostream, mock_ioloop):
""" Test the TCP tornado client client initialize """
protocol, future = AsyncModbusTCPClient(schedulers.IO_LOOP, framer=ModbusSocketFramer(ClientDecoder()))
client = future.result()
assert(isinstance(client, AsyncTornadoModbusTcpClient))
assert(0 == len(list(client.transaction)))
assert(isinstance(client.framer, ModbusSocketFramer))
assert(client.port == 502)
assert client._connected
assert(client.stream.connect.call_count == 1)
assert(client.stream.read_until_close.call_count == 1)
def handle_failure(failure):
assert(isinstance(failure.exception(), ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
assert(client._connected)
client.close()
protocol.stop()
assert(not client._connected)
@pytest.mark.skipif(not IS_PYTHON3 or PYTHON_VERSION < (3, 4),
reason="requires python3.4 or above")
@patch("asyncio.get_event_loop")
@patch("asyncio.gather")
def testTcpAsyncioClient(self, mock_gather, mock_loop):
"""
Test the TCP Twisted client
:return:
"""
pytest.skip("TBD")
# -----------------------------------------------------------------------#
# Test UDP client
# -----------------------------------------------------------------------#
@patch("pymodbus.client.async.tornado.IOLoop")
@patch("pymodbus.client.async.tornado.IOStream")
def testUdpTornadoClient(self, mock_iostream, mock_ioloop):
""" Test the udp tornado client client initialize """
protocol, future = AsyncModbusUDPClient(schedulers.IO_LOOP, framer=ModbusSocketFramer(ClientDecoder()))
client = future.result()
assert(isinstance(client, AsyncTornadoModbusUdoClient))
assert(0 == len(list(client.transaction)))
assert(isinstance(client.framer, ModbusSocketFramer))
assert(client.port == 502)
assert(client._connected)
def handle_failure(failure):
assert(isinstance(failure.exception(), ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
assert(client._connected)
client.close()
protocol.stop()
assert(not client._connected)
def testUdpTwistedClient(self):
""" Test the udp twisted client client initialize """
with pytest.raises(NotImplementedError):
AsyncModbusUDPClient(schedulers.REACTOR,
framer=ModbusSocketFramer(ClientDecoder()))
@pytest.mark.skipif(not IS_PYTHON3 or PYTHON_VERSION < (3, 4),
reason="requires python3.4 or above")
@patch("asyncio.get_event_loop")
@patch("asyncio.gather", side_effect=mock_asyncio_gather)
def testUdpAsycioClient(self, mock_gather, mock_event_loop):
"""Test the udp asyncio client"""
pytest.skip("TBD")
pass
# -----------------------------------------------------------------------#
# Test Serial client
# -----------------------------------------------------------------------#
@pytest.mark.parametrize("method, framer", [("rtu", ModbusRtuFramer),
("socket", ModbusSocketFramer),
("binary", ModbusBinaryFramer),
("ascii", ModbusAsciiFramer)])
def testSerialTwistedClient(self, method, framer):
""" Test the serial tornado client client initialize """
from serial import Serial
with patch("serial.Serial") as mock_sp:
from twisted.internet import reactor
from twisted.internet.serialport import SerialPort
with patch('twisted.internet.reactor') as mock_reactor:
protocol, client = AsyncModbusSerialClient(schedulers.REACTOR,
method=method,
port=SERIAL_PORT,
proto_cls=ModbusSerClientProtocol)
assert (isinstance(client, SerialPort))
assert (isinstance(client.protocol, ModbusSerClientProtocol))
assert (0 == len(list(client.protocol.transaction)))
assert (isinstance(client.protocol.framer, framer))
assert (client.protocol._connected)
def handle_failure(failure):
assert (isinstance(failure.exception(), ConnectionException))
d = client.protocol._buildResponse(0x00)
d.addCallback(handle_failure)
assert (client.protocol._connected)
client.protocol.close()
protocol.stop()
assert (not client.protocol._connected)
@pytest.mark.parametrize("method, framer", [("rtu", ModbusRtuFramer),
("socket", ModbusSocketFramer),
("binary", ModbusBinaryFramer),
("ascii", ModbusAsciiFramer)])
def testSerialTornadoClient(self, method, framer):
""" Test the serial tornado client client initialize """
protocol, future = AsyncModbusSerialClient(schedulers.IO_LOOP, method=method, port=SERIAL_PORT)
client = future.result()
assert(isinstance(client, AsyncTornadoModbusSerialClient))
assert(0 == len(list(client.transaction)))
assert(isinstance(client.framer, framer))
assert(client.port == SERIAL_PORT)
assert(client._connected)
def handle_failure(failure):
assert(isinstance(failure.exception(), ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
assert(client._connected)
client.close()
protocol.stop()
assert(not client._connected)
@pytest.mark.skipif(IS_PYTHON3 , reason="requires python2.7")
def testSerialAsyncioClientPython2(self):
"""
Test Serial async asyncio client exits on python2
:return:
"""
with pytest.raises(SystemExit) as pytest_wrapped_e:
AsyncModbusSerialClient(schedulers.ASYNC_IO, method="rtu", port=SERIAL_PORT)
assert pytest_wrapped_e.type == SystemExit
assert pytest_wrapped_e.value.code == 1
@pytest.mark.skipif(not IS_PYTHON3 or PYTHON_VERSION < (3, 4), reason="requires python3.4 or above")
@patch("asyncio.get_event_loop")
@patch("asyncio.gather", side_effect=mock_asyncio_gather)
@pytest.mark.parametrize("method, framer", [("rtu", ModbusRtuFramer),
("socket", ModbusSocketFramer),
("binary", ModbusBinaryFramer),
("ascii", ModbusAsciiFramer)])
def testSerialAsyncioClient(self, mock_gather, mock_event_loop, method, framer):
"""
Test that AsyncModbusSerialClient instantiates AsyncioModbusSerialClient for asyncio scheduler.
:return:
"""
loop = asyncio.get_event_loop()
loop, client = AsyncModbusSerialClient(schedulers.ASYNC_IO, method=method, port=SERIAL_PORT, loop=loop,
baudrate=19200, parity='E', stopbits=2, bytesize=7)
assert(isinstance(client, AsyncioModbusSerialClient))
assert(isinstance(client.framer, framer))
assert(client.port == SERIAL_PORT)
assert(client.baudrate == 19200)
assert(client.parity == 'E')
assert(client.stopbits == 2)
assert(client.bytesize == 7)
# ---------------------------------------------------------------------------#
# Main
# ---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_client_async_asyncio.py 0000664 0000000 0000000 00000026543 13355134677 0022174 0 ustar 00root root 0000000 0000000 from pymodbus.compat import IS_PYTHON3, PYTHON_VERSION
import pytest
if IS_PYTHON3 and PYTHON_VERSION >= (3, 4):
from unittest import mock
from pymodbus.client.async.asyncio import (
ReconnectingAsyncioModbusTcpClient,
ModbusClientProtocol, ModbusUdpClientProtocol)
from test.asyncio_test_helper import return_as_coroutine, run_coroutine
from pymodbus.factory import ClientDecoder
from pymodbus.exceptions import ConnectionException
from pymodbus.transaction import ModbusSocketFramer
from pymodbus.bit_read_message import ReadCoilsRequest, ReadCoilsResponse
protocols = [ModbusUdpClientProtocol, ModbusClientProtocol]
else:
import mock
protocols = [None, None]
@pytest.mark.skipif(not IS_PYTHON3, reason="requires python3.4 or above")
class TestAsyncioClient(object):
def test_protocol_connection_state_propagation_to_factory(self):
protocol = ModbusClientProtocol()
assert protocol.factory is None
assert protocol.transport is None
assert not protocol._connected
protocol.factory = mock.MagicMock()
protocol.connection_made(mock.sentinel.TRANSPORT)
assert protocol.transport is mock.sentinel.TRANSPORT
protocol.factory.protocol_made_connection.assert_called_once_with(protocol)
assert protocol.factory.protocol_lost_connection.call_count == 0
protocol.factory.reset_mock()
protocol.connection_lost(mock.sentinel.REASON)
assert protocol.transport is None
assert protocol.factory.protocol_made_connection.call_count == 0
protocol.factory.protocol_lost_connection.assert_called_once_with(protocol)
def test_factory_initialization_state(self):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
assert not client.connected
assert client.delay_ms < client.DELAY_MAX_MS
assert client.loop is mock_loop
assert client.protocol_class is mock_protocol_class
def test_factory_reset_wait_before_reconnect(self):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
initial_delay = client.delay_ms
assert initial_delay > 0
client.delay_ms *= 2
assert client.delay_ms > initial_delay
client.reset_delay()
assert client.delay_ms == initial_delay
def test_factory_stop(self):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
assert not client.connected
client.stop()
assert not client.connected
# fake connected client:
client.protocol = mock.MagicMock()
client.connected = True
client.stop()
client.protocol.transport.close.assert_called_once_with()
def test_factory_protocol_made_connection(self):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
assert not client.connected
assert client.protocol is None
client.protocol_made_connection(mock.sentinel.PROTOCOL)
assert client.connected
assert client.protocol is mock.sentinel.PROTOCOL
client.protocol_made_connection(mock.sentinel.PROTOCOL_UNEXPECTED)
assert client.connected
assert client.protocol is mock.sentinel.PROTOCOL
@mock.patch('pymodbus.client.async.asyncio.asyncio.async')
def test_factory_protocol_lost_connection(self, mock_async):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
assert not client.connected
assert client.protocol is None
client.protocol_lost_connection(mock.sentinel.PROTOCOL_UNEXPECTED)
assert not client.connected
# fake client ist connected and *then* looses connection:
client.connected = True
client.host = mock.sentinel.HOST
client.port = mock.sentinel.PORT
client.protocol = mock.sentinel.PROTOCOL
with mock.patch('pymodbus.client.async.asyncio.ReconnectingAsyncioModbusTcpClient._reconnect') as mock_reconnect:
mock_reconnect.return_value = mock.sentinel.RECONNECT_GENERATOR
client.protocol_lost_connection(mock.sentinel.PROTOCOL)
mock_async.assert_called_once_with(mock.sentinel.RECONNECT_GENERATOR, loop=mock_loop)
assert not client.connected
assert client.protocol is None
@mock.patch('pymodbus.client.async.asyncio.asyncio.async')
def test_factory_start_success(self, mock_async):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
run_coroutine(client.start(mock.sentinel.HOST, mock.sentinel.PORT))
mock_loop.create_connection.assert_called_once_with(mock.ANY, mock.sentinel.HOST, mock.sentinel.PORT)
assert mock_async.call_count == 0
@mock.patch('pymodbus.client.async.asyncio.asyncio.async')
def test_factory_start_failing_and_retried(self, mock_async):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
mock_loop.create_connection = mock.MagicMock(side_effect=Exception('Did not work.'))
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
# check whether reconnect is called upon failed connection attempt:
with mock.patch('pymodbus.client.async.asyncio.ReconnectingAsyncioModbusTcpClient._reconnect') as mock_reconnect:
mock_reconnect.return_value = mock.sentinel.RECONNECT_GENERATOR
run_coroutine(client.start(mock.sentinel.HOST, mock.sentinel.PORT))
mock_reconnect.assert_called_once_with()
mock_async.assert_called_once_with(mock.sentinel.RECONNECT_GENERATOR, loop=mock_loop)
@mock.patch('pymodbus.client.async.asyncio.asyncio.sleep')
def test_factory_reconnect(self, mock_sleep):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
client.delay_ms = 5000
mock_sleep.side_effect = return_as_coroutine()
run_coroutine(client._reconnect())
mock_sleep.assert_called_once_with(5)
assert mock_loop.create_connection.call_count == 1
@pytest.mark.parametrize("protocol", protocols)
def testClientProtocolConnectionMade(self, protocol):
"""
Test the client protocol close
:return:
"""
protocol = protocol(ModbusSocketFramer(ClientDecoder()))
transport = mock.MagicMock()
factory = mock.MagicMock()
if isinstance(protocol, ModbusUdpClientProtocol):
protocol.factory = factory
protocol.connection_made(transport)
assert protocol.transport == transport
assert protocol.connected
if isinstance(protocol, ModbusUdpClientProtocol):
assert protocol.factory.protocol_made_connection.call_count == 1
@pytest.mark.parametrize("protocol", protocols)
def testClientProtocolClose(self, protocol):
"""
Test the client protocol close
:return:
"""
protocol = protocol(ModbusSocketFramer(ClientDecoder()))
transport = mock.MagicMock()
factory = mock.MagicMock()
if isinstance(protocol, ModbusUdpClientProtocol):
protocol.factory = factory
protocol.connection_made(transport)
assert protocol.transport == transport
assert protocol.connected
protocol.close()
transport.close.assert_called_once_with()
assert not protocol.connected
@pytest.mark.parametrize("protocol", protocols)
def testClientProtocolConnectionLost(self, protocol):
''' Test the client protocol connection lost'''
framer = ModbusSocketFramer(None)
protocol = protocol(framer=framer)
transport = mock.MagicMock()
factory = mock.MagicMock()
if isinstance(protocol, ModbusUdpClientProtocol):
protocol.factory = factory
protocol.connection_made(transport)
protocol.transport.write = mock.Mock()
request = ReadCoilsRequest(1, 1)
d = protocol.execute(request)
protocol.connection_lost("REASON")
excp = d.exception()
assert (isinstance(excp, ConnectionException))
if isinstance(protocol, ModbusUdpClientProtocol):
assert protocol.factory.protocol_lost_connection.call_count == 1
@pytest.mark.parametrize("protocol", protocols)
def testClientProtocolDataReceived(self, protocol):
''' Test the client protocol data received '''
protocol = protocol(ModbusSocketFramer(ClientDecoder()))
transport = mock.MagicMock()
protocol.connection_made(transport)
assert protocol.transport == transport
assert protocol.connected
data = b'\x00\x00\x12\x34\x00\x06\xff\x01\x01\x02\x00\x04'
# setup existing request
d = protocol._buildResponse(0x00)
if isinstance(protocol, ModbusClientProtocol):
protocol.data_received(data)
else:
protocol.datagram_received(data, None)
result = d.result()
assert isinstance(result, ReadCoilsResponse)
@pytest.mark.parametrize("protocol", protocols)
def testClientProtocolExecute(self, protocol):
''' Test the client protocol execute method '''
framer = ModbusSocketFramer(None)
protocol = protocol(framer=framer)
transport = mock.MagicMock()
protocol.connection_made(transport)
protocol.transport.write = mock.Mock()
request = ReadCoilsRequest(1, 1)
d = protocol.execute(request)
tid = request.transaction_id
assert d == protocol.transaction.getTransaction(tid)
@pytest.mark.parametrize("protocol", protocols)
def testClientProtocolHandleResponse(self, protocol):
''' Test the client protocol handles responses '''
protocol = protocol()
transport = mock.MagicMock()
protocol.connection_made(transport=transport)
reply = ReadCoilsRequest(1, 1)
reply.transaction_id = 0x00
# handle skipped cases
protocol._handleResponse(None)
protocol._handleResponse(reply)
# handle existing cases
d = protocol._buildResponse(0x00)
protocol._handleResponse(reply)
result = d.result()
assert result == reply
@pytest.mark.parametrize("protocol", protocols)
def testClientProtocolBuildResponse(self, protocol):
''' Test the udp client protocol builds responses '''
protocol = protocol()
assert not len(list(protocol.transaction))
d = protocol._buildResponse(0x00)
excp = d.exception()
assert (isinstance(excp, ConnectionException))
assert not len(list(protocol.transaction))
protocol._connected = True
protocol._buildResponse(0x00)
assert len(list(protocol.transaction)) == 1
pymodbus-2.1.0/test/test_client_async_tornado.py 0000664 0000000 0000000 00000031605 13355134677 0022170 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.compat import IS_PYTHON3
if IS_PYTHON3:
from unittest.mock import patch, Mock
else: # Python 2
from mock import patch, Mock
from pymodbus.client.async.tornado import (BaseTornadoClient,
AsyncModbusSerialClient, AsyncModbusUDPClient, AsyncModbusTCPClient
)
from pymodbus.client.async import schedulers
from pymodbus.factory import ClientDecoder
from pymodbus.client.async.twisted import ModbusClientFactory
from pymodbus.exceptions import ConnectionException
from pymodbus.transaction import ModbusSocketFramer, ModbusRtuFramer
from pymodbus.bit_read_message import ReadCoilsRequest, ReadCoilsResponse
# ---------------------------------------------------------------------------#
# Fixture
# ---------------------------------------------------------------------------#
import platform
from distutils.version import LooseVersion
IS_DARWIN = platform.system().lower() == "darwin"
OSX_SIERRA = LooseVersion("10.12")
if IS_DARWIN:
IS_HIGH_SIERRA_OR_ABOVE = LooseVersion(platform.mac_ver()[0])
SERIAL_PORT = '/dev/ttyp0' if not IS_HIGH_SIERRA_OR_ABOVE else '/dev/ptyp0'
else:
IS_HIGH_SIERRA_OR_ABOVE = False
SERIAL_PORT = "/dev/ptmx"
class AsynchronousClientTest(unittest.TestCase):
"""
This is the unittest for the pymodbus.client.async module
"""
# -----------------------------------------------------------------------#
# Test Client client
# -----------------------------------------------------------------------#
def testBaseClientInit(self):
""" Test the client client initialize """
client = BaseTornadoClient()
self.assertTrue(client.port ==502)
self.assertTrue(client.host =="127.0.0.1")
self.assertEqual(0, len(list(client.transaction)))
self.assertFalse(client._connected)
self.assertTrue(client.io_loop is None)
self.assertTrue(isinstance(client.framer, ModbusSocketFramer))
framer = object()
client = BaseTornadoClient(framer=framer, ioloop=schedulers.IO_LOOP)
self.assertEqual(0, len(list(client.transaction)))
self.assertFalse(client._connected)
self.assertTrue(client.io_loop == schedulers.IO_LOOP)
self.assertTrue(framer is client.framer)
@patch("pymodbus.client.async.tornado.IOLoop")
@patch("pymodbus.client.async.tornado.IOStream")
def testBaseClientOn_receive(self, mock_iostream, mock_ioloop):
""" Test the BaseTornado client data received """
client = AsyncModbusTCPClient(port=5020)
client.connect()
out = []
data = b'\x00\x00\x12\x34\x00\x06\xff\x01\x01\x02\x00\x04'
# setup existing request
d = client._build_response(0x00)
d.add_done_callback(lambda v: out.append(v))
client.on_receive(data)
self.assertTrue(isinstance(out[0].result(), ReadCoilsResponse))
data = b''
out = []
d = client._build_response(0x01)
client.on_receive(data)
d.add_done_callback(lambda v: out.append(v))
self.assertFalse(out)
@patch("pymodbus.client.async.tornado.IOLoop")
@patch("pymodbus.client.async.tornado.IOStream")
def testBaseClientExecute(self, mock_iostream, mock_ioloop):
""" Test the BaseTornado client execute method """
client = AsyncModbusTCPClient(port=5020)
client.connect()
client.stream = Mock()
client.stream.write = Mock()
request = ReadCoilsRequest(1, 1)
d = client.execute(request)
tid = request.transaction_id
self.assertEqual(d, client.transaction.getTransaction(tid))
@patch("pymodbus.client.async.tornado.IOLoop")
@patch("pymodbus.client.async.tornado.IOStream")
def testBaseClientHandleResponse(self, mock_iostream, mock_ioloop):
""" Test the BaseTornado client handles responses """
client = AsyncModbusTCPClient(port=5020)
client.connect()
out = []
reply = ReadCoilsRequest(1, 1)
reply.transaction_id = 0x00
# handle skipped cases
client._handle_response(None)
client._handle_response(reply)
# handle existing cases
d = client._build_response(0x00)
d.add_done_callback(lambda v: out.append(v))
client._handle_response(reply)
self.assertEqual(out[0].result(), reply)
@patch("pymodbus.client.async.tornado.IOLoop")
@patch("pymodbus.client.async.tornado.IOStream")
def testBaseClientBuildResponse(self, mock_iostream, mock_ioloop):
""" Test the BaseTornado client client builds responses """
client = BaseTornadoClient()
self.assertEqual(0, len(list(client.transaction)))
def handle_failure(failure):
exc = failure.exception()
self.assertTrue(isinstance(exc, ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
self.assertEqual(0, len(list(client.transaction)))
client._connected = True
d = client._build_response(0x00)
self.assertEqual(1, len(list(client.transaction)))
# -----------------------------------------------------------------------#
# Test TCP Client client
# -----------------------------------------------------------------------#
def testTcpClientInit(self):
""" Test the tornado tcp client client initialize """
client = AsyncModbusTCPClient()
self.assertEqual(0, len(list(client.transaction)))
self.assertTrue(isinstance(client.framer, ModbusSocketFramer))
framer = object()
client = AsyncModbusTCPClient(framer=framer)
self.assertTrue(framer is client.framer)
@patch("pymodbus.client.async.tornado.IOLoop")
@patch("pymodbus.client.async.tornado.IOStream")
def testTcpClientConnect(self, mock_iostream, mock_ioloop):
""" Test the tornado tcp client client connect """
client = AsyncModbusTCPClient(port=5020)
self.assertTrue(client.port, 5020)
self.assertFalse(client._connected)
client.connect()
self.assertTrue(client._connected)
@patch("pymodbus.client.async.tornado.IOLoop")
@patch("pymodbus.client.async.tornado.IOStream")
def testTcpClientDisconnect(self, mock_iostream, mock_ioloop):
""" Test the tornado tcp client client disconnect """
client = AsyncModbusTCPClient(port=5020)
client.connect()
def handle_failure(failure):
self.assertTrue(isinstance(failure.exception(), ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
self.assertTrue(client._connected)
client.close()
self.assertFalse(client._connected)
# -----------------------------------------------------------------------#
# Test Serial Client client
# -----------------------------------------------------------------------#
def testSerialClientInit(self):
""" Test the tornado serial client client initialize """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP, framer=ModbusRtuFramer(ClientDecoder()), port=SERIAL_PORT)
self.assertEqual(0, len(list(client.transaction)))
self.assertTrue(isinstance(client.framer, ModbusRtuFramer))
framer = object()
client = AsyncModbusSerialClient(framer=framer)
self.assertTrue(framer is client.framer)
@patch("pymodbus.client.async.tornado.IOLoop")
@patch("pymodbus.client.async.tornado.SerialIOStream")
@patch("pymodbus.client.async.tornado.Serial")
def testSerialClientConnect(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client connect """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
self.assertTrue(client.port, SERIAL_PORT)
self.assertFalse(client._connected)
client.connect()
self.assertTrue(client._connected)
client.close()
@patch("pymodbus.client.async.tornado.IOLoop")
@patch("pymodbus.client.async.tornado.SerialIOStream")
@patch("pymodbus.client.async.tornado.Serial")
def testSerialClientDisconnect(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client disconnect """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
client.connect()
self.assertTrue(client._connected)
def handle_failure(failure):
self.assertTrue(isinstance(failure.exception(), ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
client.close()
self.assertFalse(client._connected)
@patch("pymodbus.client.async.tornado.IOLoop")
@patch("pymodbus.client.async.tornado.SerialIOStream")
@patch("pymodbus.client.async.tornado.Serial")
def testSerialClientExecute(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client execute method """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
client.connect()
client.stream = Mock()
client.stream.write = Mock()
request = ReadCoilsRequest(1, 1)
d = client.execute(request)
tid = request.transaction_id
self.assertEqual(d, client.transaction.getTransaction(tid))
@patch("pymodbus.client.async.tornado.IOLoop")
@patch("pymodbus.client.async.tornado.SerialIOStream")
@patch("pymodbus.client.async.tornado.Serial")
def testSerialClientHandleResponse(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client handles responses """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
client.connect()
out = []
reply = ReadCoilsRequest(1, 1)
reply.transaction_id = 0x00
# handle skipped cases
client._handle_response(None)
client._handle_response(reply)
# handle existing cases
d = client._build_response(0x00)
d.add_done_callback(lambda v: out.append(v))
client._handle_response(reply)
self.assertEqual(out[0].result(), reply)
@patch("pymodbus.client.async.tornado.IOLoop")
@patch("pymodbus.client.async.tornado.SerialIOStream")
@patch("pymodbus.client.async.tornado.Serial")
def testSerialClientBuildResponse(self, mock_serial, mock_seriostream, mock_ioloop):
""" Test the tornado serial client client builds responses """
client = AsyncModbusSerialClient(ioloop=schedulers.IO_LOOP,
framer=ModbusRtuFramer(
ClientDecoder()),
port=SERIAL_PORT)
self.assertEqual(0, len(list(client.transaction)))
def handle_failure(failure):
exc = failure.exception()
self.assertTrue(isinstance(exc, ConnectionException))
d = client._build_response(0x00)
d.add_done_callback(handle_failure)
self.assertEqual(0, len(list(client.transaction)))
client._connected = True
d = client._build_response(0x00)
self.assertEqual(1, len(list(client.transaction)))
# -----------------------------------------------------------------------#
# Test Udp Client client
# -----------------------------------------------------------------------#
def testUdpClientInit(self):
""" Test the udp client client initialize """
client = AsyncModbusUDPClient()
self.assertEqual(0, len(list(client.transaction)))
self.assertTrue(isinstance(client.framer, ModbusSocketFramer))
framer = object()
client = AsyncModbusUDPClient(framer=framer)
self.assertTrue(framer is client.framer)
# -----------------------------------------------------------------------#
# Test Client Factories
# -----------------------------------------------------------------------#
def testModbusClientFactory(self):
""" Test the base class for all the clients """
factory = ModbusClientFactory()
self.assertTrue(factory is not None)
# ---------------------------------------------------------------------------#
# Main
# ---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_client_async_twisted.py 0000664 0000000 0000000 00000021304 13355134677 0022200 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.compat import IS_PYTHON3
if IS_PYTHON3:
from unittest.mock import patch, Mock
else: # Python 2
from mock import patch, Mock
from pymodbus.client.async.twisted import (
ModbusClientProtocol, ModbusUdpClientProtocol, ModbusSerClientProtocol, ModbusTcpClientProtocol
)
from pymodbus.factory import ClientDecoder
from pymodbus.client.async.twisted import ModbusClientFactory
from pymodbus.exceptions import ConnectionException
from pymodbus.transaction import ModbusSocketFramer, ModbusRtuFramer
from pymodbus.bit_read_message import ReadCoilsRequest, ReadCoilsResponse
#---------------------------------------------------------------------------#
# Fixture
#---------------------------------------------------------------------------#
class AsynchronousClientTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.client.async module
'''
#-----------------------------------------------------------------------#
# Test Client Protocol
#-----------------------------------------------------------------------#
def testClientProtocolInit(self):
''' Test the client protocol initialize '''
protocol = ModbusClientProtocol()
self.assertEqual(0, len(list(protocol.transaction)))
self.assertFalse(protocol._connected)
self.assertTrue(isinstance(protocol.framer, ModbusSocketFramer))
framer = object()
protocol = ModbusClientProtocol(framer=framer)
self.assertEqual(0, len(list(protocol.transaction)))
self.assertFalse(protocol._connected)
self.assertTrue(framer is protocol.framer)
def testClientProtocolConnect(self):
''' Test the client protocol connect '''
decoder = object()
framer = ModbusSocketFramer(decoder)
protocol = ModbusClientProtocol(framer=framer)
self.assertFalse(protocol._connected)
protocol.connectionMade()
self.assertTrue(protocol._connected)
def testClientProtocolDisconnect(self):
''' Test the client protocol disconnect '''
protocol = ModbusClientProtocol()
protocol.connectionMade()
def handle_failure(failure):
self.assertTrue(isinstance(failure.value, ConnectionException))
d = protocol._buildResponse(0x00)
d.addErrback(handle_failure)
self.assertTrue(protocol._connected)
protocol.connectionLost('because')
self.assertFalse(protocol._connected)
def testClientProtocolDataReceived(self):
''' Test the client protocol data received '''
protocol = ModbusClientProtocol(ModbusSocketFramer(ClientDecoder()))
protocol.connectionMade()
out = []
data = b'\x00\x00\x12\x34\x00\x06\xff\x01\x01\x02\x00\x04'
# setup existing request
d = protocol._buildResponse(0x00)
d.addCallback(lambda v: out.append(v))
protocol.dataReceived(data)
self.assertTrue(isinstance(out[0], ReadCoilsResponse))
def testClientProtocolExecute(self):
''' Test the client protocol execute method '''
framer = ModbusSocketFramer(None)
protocol = ModbusClientProtocol(framer=framer)
protocol.connectionMade()
protocol.transport = Mock()
protocol.transport.write = Mock()
request = ReadCoilsRequest(1, 1)
d = protocol.execute(request)
tid = request.transaction_id
self.assertEqual(d, protocol.transaction.getTransaction(tid))
def testClientProtocolHandleResponse(self):
''' Test the client protocol handles responses '''
protocol = ModbusClientProtocol()
protocol.connectionMade()
out = []
reply = ReadCoilsRequest(1, 1)
reply.transaction_id = 0x00
# handle skipped cases
protocol._handleResponse(None)
protocol._handleResponse(reply)
# handle existing cases
d = protocol._buildResponse(0x00)
d.addCallback(lambda v: out.append(v))
protocol._handleResponse(reply)
self.assertEqual(out[0], reply)
def testClientProtocolBuildResponse(self):
''' Test the udp client protocol builds responses '''
protocol = ModbusClientProtocol()
self.assertEqual(0, len(list(protocol.transaction)))
def handle_failure(failure):
self.assertTrue(isinstance(failure.value, ConnectionException))
d = protocol._buildResponse(0x00)
d.addErrback(handle_failure)
self.assertEqual(0, len(list(protocol.transaction)))
protocol._connected = True
d = protocol._buildResponse(0x00)
self.assertEqual(1, len(list(protocol.transaction)))
#-----------------------------------------------------------------------#
# Test TCP Client Protocol
#-----------------------------------------------------------------------#
def testTcpClientProtocolInit(self):
''' Test the udp client protocol initialize '''
protocol = ModbusTcpClientProtocol()
self.assertEqual(0, len(list(protocol.transaction)))
self.assertTrue(isinstance(protocol.framer, ModbusSocketFramer))
framer = object()
protocol = ModbusClientProtocol(framer=framer)
self.assertTrue(framer is protocol.framer)
#-----------------------------------------------------------------------#
# Test Serial Client Protocol
#-----------------------------------------------------------------------#
def testSerialClientProtocolInit(self):
''' Test the udp client protocol initialize '''
protocol = ModbusSerClientProtocol()
self.assertEqual(0, len(list(protocol.transaction)))
self.assertTrue(isinstance(protocol.framer, ModbusRtuFramer))
framer = object()
protocol = ModbusClientProtocol(framer=framer)
self.assertTrue(framer is protocol.framer)
#-----------------------------------------------------------------------#
# Test Udp Client Protocol
#-----------------------------------------------------------------------#
def testUdpClientProtocolInit(self):
''' Test the udp client protocol initialize '''
protocol = ModbusUdpClientProtocol()
self.assertEqual(0, len(list(protocol.transaction)))
self.assertTrue(isinstance(protocol.framer, ModbusSocketFramer))
framer = object()
protocol = ModbusClientProtocol(framer=framer)
self.assertTrue(framer is protocol.framer)
def testUdpClientProtocolDataReceived(self):
''' Test the udp client protocol data received '''
protocol = ModbusUdpClientProtocol()
out = []
data = b'\x00\x00\x12\x34\x00\x06\xff\x01\x01\x02\x00\x04'
server = ('127.0.0.1', 12345)
# setup existing request
d = protocol._buildResponse(0x00)
d.addCallback(lambda v: out.append(v))
protocol.datagramReceived(data, server)
self.assertTrue(isinstance(out[0], ReadCoilsResponse))
def testUdpClientProtocolExecute(self):
''' Test the udp client protocol execute method '''
protocol = ModbusUdpClientProtocol()
protocol.transport = Mock()
protocol.transport.write = Mock()
request = ReadCoilsRequest(1, 1)
d = protocol.execute(request)
tid = request.transaction_id
self.assertEqual(d, protocol.transaction.getTransaction(tid))
def testUdpClientProtocolHandleResponse(self):
''' Test the udp client protocol handles responses '''
protocol = ModbusUdpClientProtocol()
out = []
reply = ReadCoilsRequest(1, 1)
reply.transaction_id = 0x00
# handle skipped cases
protocol._handleResponse(None)
protocol._handleResponse(reply)
# handle existing cases
d = protocol._buildResponse(0x00)
d.addCallback(lambda v: out.append(v))
protocol._handleResponse(reply)
self.assertEqual(out[0], reply)
def testUdpClientProtocolBuildResponse(self):
''' Test the udp client protocol builds responses '''
protocol = ModbusUdpClientProtocol()
self.assertEqual(0, len(list(protocol.transaction)))
d = protocol._buildResponse(0x00)
self.assertEqual(1, len(list(protocol.transaction)))
#-----------------------------------------------------------------------#
# Test Client Factories
#-----------------------------------------------------------------------#
def testModbusClientFactory(self):
''' Test the base class for all the clients '''
factory = ModbusClientFactory()
self.assertTrue(factory is not None)
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_client_common.py 0000664 0000000 0000000 00000005132 13355134677 0020611 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.client.common import ModbusClientMixin
from pymodbus.bit_read_message import *
from pymodbus.bit_write_message import *
from pymodbus.file_message import *
from pymodbus.register_read_message import *
from pymodbus.register_write_message import *
#---------------------------------------------------------------------------#
# Mocks
#---------------------------------------------------------------------------#
class MockClient(ModbusClientMixin):
def execute(self, request):
return request
#---------------------------------------------------------------------------#
# Fixture
#---------------------------------------------------------------------------#
class ModbusCommonClientTests(unittest.TestCase):
#-----------------------------------------------------------------------#
# Setup/TearDown
#-----------------------------------------------------------------------#
def setUp(self):
'''
Initializes the test environment and builds request/result
encoding pairs
'''
self.client = MockClient()
def tearDown(self):
''' Cleans up the test environment '''
del self.client
#-----------------------------------------------------------------------#
# Tests
#-----------------------------------------------------------------------#
def testModbusClientMixinMethods(self):
''' This tests that the mixing returns the correct request object '''
arguments = {
'read_address': 1, 'read_count': 1,
'write_address': 1, 'write_registers': 1
}
self.assertTrue(isinstance(self.client.read_coils(1,1), ReadCoilsRequest))
self.assertTrue(isinstance(self.client.read_discrete_inputs(1,1), ReadDiscreteInputsRequest))
self.assertTrue(isinstance(self.client.write_coil(1,True), WriteSingleCoilRequest))
self.assertTrue(isinstance(self.client.write_coils(1,[True]), WriteMultipleCoilsRequest))
self.assertTrue(isinstance(self.client.write_register(1,0x00), WriteSingleRegisterRequest))
self.assertTrue(isinstance(self.client.write_registers(1,[0x00]), WriteMultipleRegistersRequest))
self.assertTrue(isinstance(self.client.read_holding_registers(1,1), ReadHoldingRegistersRequest))
self.assertTrue(isinstance(self.client.read_input_registers(1,1), ReadInputRegistersRequest))
self.assertTrue(isinstance(self.client.readwrite_registers(**arguments), ReadWriteMultipleRegistersRequest))
self.assertTrue(isinstance(self.client.mask_write_register(1,0,0), MaskWriteRegisterRequest))
pymodbus-2.1.0/test/test_client_sync.py 0000664 0000000 0000000 00000032535 13355134677 0020304 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.compat import IS_PYTHON3
if IS_PYTHON3: # Python 3
from unittest.mock import patch, Mock, MagicMock
else: # Python 2
from mock import patch, Mock, MagicMock
import socket
import serial
from pymodbus.client.sync import ModbusTcpClient, ModbusUdpClient
from pymodbus.client.sync import ModbusSerialClient, BaseModbusClient
from pymodbus.exceptions import ConnectionException, NotImplementedException
from pymodbus.exceptions import ParameterException
from pymodbus.transaction import ModbusAsciiFramer, ModbusRtuFramer
from pymodbus.transaction import ModbusBinaryFramer
# ---------------------------------------------------------------------------#
# Mock Classes
# ---------------------------------------------------------------------------#
class mockSocket(object):
timeout = 2
def close(self): return True
def recv(self, size): return b'\x00' * size
def read(self, size): return b'\x00' * size
def send(self, msg): return len(msg)
def write(self, msg): return len(msg)
def recvfrom(self, size): return [b'\x00' * size]
def sendto(self, msg, *args): return len(msg)
def setblocking(self, flag): return None
def in_waiting(self): return None
# ---------------------------------------------------------------------------#
# Fixture
# ---------------------------------------------------------------------------#
class SynchronousClientTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.client.sync module
'''
# -----------------------------------------------------------------------#
# Test Base Client
# -----------------------------------------------------------------------#
def testBaseModbusClient(self):
''' Test the base class for all the clients '''
client = BaseModbusClient(None)
client.transaction = None
self.assertRaises(NotImplementedException, lambda: client.connect())
self.assertRaises(NotImplementedException, lambda: client._send(None))
self.assertRaises(NotImplementedException, lambda: client._recv(None))
self.assertRaises(NotImplementedException, lambda: client.__enter__())
self.assertRaises(NotImplementedException, lambda: client.execute())
self.assertRaises(NotImplementedException, lambda: client.is_socket_open())
self.assertEqual("Null Transport", str(client))
client.close()
client.__exit__(0, 0, 0)
# a successful execute
client.connect = lambda: True
client.transaction = Mock(**{'execute.return_value': True})
self.assertEqual(client, client.__enter__())
self.assertTrue(client.execute())
# a unsuccessful connect
client.connect = lambda: False
self.assertRaises(ConnectionException, lambda: client.__enter__())
self.assertRaises(ConnectionException, lambda: client.execute())
# -----------------------------------------------------------------------#
# Test UDP Client
# -----------------------------------------------------------------------#
def testSyncUdpClientInstantiation(self):
client = ModbusUdpClient()
self.assertNotEqual(client, None)
def testBasicSyncUdpClient(self):
''' Test the basic methods for the udp sync client'''
# receive/send
client = ModbusUdpClient()
client.socket = mockSocket()
self.assertEqual(0, client._send(None))
self.assertEqual(1, client._send(b'\x00'))
self.assertEqual(b'\x00', client._recv(1))
# connect/disconnect
self.assertTrue(client.connect())
client.close()
# already closed socket
client.socket = False
client.close()
self.assertEqual("ModbusUdpClient(127.0.0.1:502)", str(client))
def testUdpClientAddressFamily(self):
''' Test the Udp client get address family method'''
client = ModbusUdpClient()
self.assertEqual(socket.AF_INET,
client._get_address_family('127.0.0.1'))
self.assertEqual(socket.AF_INET6, client._get_address_family('::1'))
def testUdpClientConnect(self):
''' Test the Udp client connection method'''
with patch.object(socket, 'socket') as mock_method:
class DummySocket(object):
def settimeout(self, *a, **kwa):
pass
mock_method.return_value = DummySocket()
client = ModbusUdpClient()
self.assertTrue(client.connect())
with patch.object(socket, 'socket') as mock_method:
mock_method.side_effect = socket.error()
client = ModbusUdpClient()
self.assertFalse(client.connect())
def testUdpClientSend(self):
''' Test the udp client send method'''
client = ModbusUdpClient()
self.assertRaises(ConnectionException, lambda: client._send(None))
client.socket = mockSocket()
self.assertEqual(0, client._send(None))
self.assertEqual(4, client._send('1234'))
def testUdpClientRecv(self):
''' Test the udp client receive method'''
client = ModbusUdpClient()
self.assertRaises(ConnectionException, lambda: client._recv(1024))
client.socket = mockSocket()
self.assertEqual(b'', client._recv(0))
self.assertEqual(b'\x00' * 4, client._recv(4))
def testUdpClientRepr(self):
client = ModbusUdpClient()
rep = "<{} at {} socket={}, ipaddr={}, port={}, timeout={}>".format(
client.__class__.__name__, hex(id(client)), client.socket,
client.host, client.port, client.timeout
)
self.assertEqual(repr(client), rep)
# -----------------------------------------------------------------------#
# Test TCP Client
# -----------------------------------------------------------------------#
def testSyncTcpClientInstantiation(self):
client = ModbusTcpClient()
self.assertNotEqual(client, None)
@patch('pymodbus.client.sync.select')
def testBasicSyncTcpClient(self, mock_select):
''' Test the basic methods for the tcp sync client'''
# receive/send
mock_select.select.return_value = [True]
client = ModbusTcpClient()
client.socket = mockSocket()
self.assertEqual(0, client._send(None))
self.assertEqual(1, client._send(b'\x00'))
self.assertEqual(b'\x00', client._recv(1))
# connect/disconnect
self.assertTrue(client.connect())
client.close()
# already closed socket
client.socket = False
client.close()
self.assertEqual("ModbusTcpClient(127.0.0.1:502)", str(client))
def testTcpClientConnect(self):
''' Test the tcp client connection method'''
with patch.object(socket, 'create_connection') as mock_method:
mock_method.return_value = object()
client = ModbusTcpClient()
self.assertTrue(client.connect())
with patch.object(socket, 'create_connection') as mock_method:
mock_method.side_effect = socket.error()
client = ModbusTcpClient()
self.assertFalse(client.connect())
def testTcpClientSend(self):
''' Test the tcp client send method'''
client = ModbusTcpClient()
self.assertRaises(ConnectionException, lambda: client._send(None))
client.socket = mockSocket()
self.assertEqual(0, client._send(None))
self.assertEqual(4, client._send('1234'))
@patch('pymodbus.client.sync.select')
def testTcpClientRecv(self, mock_select):
''' Test the tcp client receive method'''
mock_select.select.return_value = [True]
client = ModbusTcpClient()
self.assertRaises(ConnectionException, lambda: client._recv(1024))
client.socket = mockSocket()
self.assertEqual(b'', client._recv(0))
self.assertEqual(b'\x00' * 4, client._recv(4))
mock_socket = MagicMock()
mock_socket.recv.side_effect = iter([b'\x00', b'\x01', b'\x02'])
client.socket = mock_socket
client.timeout = 1
self.assertEqual(b'\x00\x01\x02', client._recv(3))
mock_socket.recv.side_effect = iter([b'\x00', b'\x01', b'\x02'])
self.assertEqual(b'\x00\x01', client._recv(2))
mock_select.select.return_value = [False]
self.assertEqual(b'', client._recv(2))
client.socket = mockSocket()
mock_select.select.return_value = [True]
self.assertIn(b'\x00', client._recv(None))
def testSerialClientRpr(self):
client = ModbusTcpClient()
rep = "<{} at {} socket={}, ipaddr={}, port={}, timeout={}>".format(
client.__class__.__name__, hex(id(client)), client.socket,
client.host, client.port, client.timeout
)
self.assertEqual(repr(client), rep)
# -----------------------------------------------------------------------#
# Test Serial Client
# -----------------------------------------------------------------------#
def testSyncSerialClientInstantiation(self):
client = ModbusSerialClient()
self.assertNotEqual(client, None)
self.assertTrue(isinstance(ModbusSerialClient(method='ascii').framer,
ModbusAsciiFramer))
self.assertTrue(isinstance(ModbusSerialClient(method='rtu').framer,
ModbusRtuFramer))
self.assertTrue(isinstance(ModbusSerialClient(method='binary').framer,
ModbusBinaryFramer))
self.assertRaises(ParameterException,
lambda: ModbusSerialClient(method='something'))
def testSyncSerialRTUClientTimeouts(self):
client = ModbusSerialClient(method="rtu", baudrate=9600)
assert client.silent_interval == round((3.5 * 11 / 9600), 6)
client = ModbusSerialClient(method="rtu", baudrate=38400)
assert client.silent_interval == round((1.75 / 1000), 6)
@patch("serial.Serial")
def testBasicSyncSerialClient(self, mock_serial):
''' Test the basic methods for the serial sync client'''
# receive/send
mock_serial.in_waiting = 0
mock_serial.write = lambda x: len(x)
mock_serial.read = lambda size: b'\x00' * size
client = ModbusSerialClient()
client.socket = mock_serial
client.state = 0
self.assertEqual(0, client._send(None))
client.state = 0
self.assertEqual(1, client._send(b'\x00'))
self.assertEqual(b'\x00', client._recv(1))
# connect/disconnect
self.assertTrue(client.connect())
client.close()
# already closed socket
client.socket = False
client.close()
self.assertEqual('ModbusSerialClient(ascii baud[19200])', str(client))
def testSerialClientConnect(self):
''' Test the serial client connection method'''
with patch.object(serial, 'Serial') as mock_method:
mock_method.return_value = object()
client = ModbusSerialClient()
self.assertTrue(client.connect())
with patch.object(serial, 'Serial') as mock_method:
mock_method.side_effect = serial.SerialException()
client = ModbusSerialClient()
self.assertFalse(client.connect())
@patch("serial.Serial")
def testSerialClientSend(self, mock_serial):
''' Test the serial client send method'''
mock_serial.in_waiting = None
mock_serial.write = lambda x: len(x)
client = ModbusSerialClient()
self.assertRaises(ConnectionException, lambda: client._send(None))
# client.connect()
client.socket = mock_serial
client.state = 0
self.assertEqual(0, client._send(None))
client.state = 0
self.assertEqual(4, client._send('1234'))
@patch("serial.Serial")
def testSerialClientCleanupBufferBeforeSend(self, mock_serial):
''' Test the serial client send method'''
mock_serial.in_waiting = 4
mock_serial.read = lambda x: b'1' * x
mock_serial.write = lambda x: len(x)
client = ModbusSerialClient()
self.assertRaises(ConnectionException, lambda: client._send(None))
# client.connect()
client.socket = mock_serial
client.state = 0
self.assertEqual(0, client._send(None))
client.state = 0
self.assertEqual(4, client._send('1234'))
def testSerialClientRecv(self):
''' Test the serial client receive method'''
client = ModbusSerialClient()
self.assertRaises(ConnectionException, lambda: client._recv(1024))
client.socket = mockSocket()
self.assertEqual(b'', client._recv(0))
self.assertEqual(b'\x00' * 4, client._recv(4))
client.socket = MagicMock()
client.socket.read.return_value = b''
self.assertEqual(b'', client._recv(None))
client.socket.timeout = 0
self.assertEqual(b'', client._recv(0))
def testSerialClientRepr(self):
client = ModbusSerialClient()
rep = "<{} at {} socket={}, method={}, timeout={}>".format(
client.__class__.__name__, hex(id(client)), client.socket,
client.method, client.timeout
)
self.assertEqual(repr(client), rep)
# ---------------------------------------------------------------------------#
# Main
# ---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_datastore.py 0000664 0000000 0000000 00000031450 13355134677 0017753 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
import mock
from mock import MagicMock
import redis
import random
from pymodbus.datastore import *
from pymodbus.datastore.store import BaseModbusDataBlock
from pymodbus.datastore.database import SqlSlaveContext
from pymodbus.datastore.database import RedisSlaveContext
from pymodbus.exceptions import NotImplementedException
from pymodbus.exceptions import NoSuchSlaveException
from pymodbus.exceptions import ParameterException
from pymodbus.datastore.remote import RemoteSlaveContext
class ModbusDataStoreTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.datastore module
'''
def setUp(self):
pass
def tearDown(self):
''' Cleans up the test environment '''
pass
def testModbusDataBlock(self):
''' Test a base data block store '''
block = BaseModbusDataBlock()
block.default(10, True)
self.assertNotEqual(str(block), None)
self.assertEqual(block.default_value, True)
self.assertEqual(block.values, [True]*10)
block.default_value = False
block.reset()
self.assertEqual(block.values, [False]*10)
def testModbusDataBlockIterate(self):
''' Test a base data block store '''
block = BaseModbusDataBlock()
block.default(10, False)
for idx,value in block:
self.assertEqual(value, False)
block.values = {0 : False, 2 : False, 3 : False }
for idx,value in block:
self.assertEqual(value, False)
def testModbusDataBlockOther(self):
''' Test a base data block store '''
block = BaseModbusDataBlock()
self.assertRaises(NotImplementedException, lambda: block.validate(1,1))
self.assertRaises(NotImplementedException, lambda: block.getValues(1,1))
self.assertRaises(NotImplementedException, lambda: block.setValues(1,1))
def testModbusSequentialDataBlock(self):
''' Test a sequential data block store '''
block = ModbusSequentialDataBlock(0x00, [False]*10)
self.assertFalse(block.validate(-1, 0))
self.assertFalse(block.validate(0, 20))
self.assertFalse(block.validate(10, 1))
self.assertTrue(block.validate(0x00, 10))
block.setValues(0x00, True)
self.assertEqual(block.getValues(0x00, 1), [True])
block.setValues(0x00, [True]*10)
self.assertEqual(block.getValues(0x00, 10), [True]*10)
def testModbusSequentialDataBlockFactory(self):
''' Test the sequential data block store factory '''
block = ModbusSequentialDataBlock.create()
self.assertEqual(block.getValues(0x00, 65536), [False]*65536)
block = ModbusSequentialDataBlock(0x00, 0x01)
self.assertEqual(block.values, [0x01])
def testModbusSparseDataBlock(self):
''' Test a sparse data block store '''
values = dict(enumerate([True]*10))
block = ModbusSparseDataBlock(values)
self.assertFalse(block.validate(-1, 0))
self.assertFalse(block.validate(0, 20))
self.assertFalse(block.validate(10, 1))
self.assertTrue(block.validate(0x00, 10))
self.assertTrue(block.validate(0x00, 10))
self.assertFalse(block.validate(0, 0))
self.assertFalse(block.validate(5, 0))
block.setValues(0x00, True)
self.assertEqual(block.getValues(0x00, 1), [True])
block.setValues(0x00, [True]*10)
self.assertEqual(block.getValues(0x00, 10), [True]*10)
block.setValues(0x00, dict(enumerate([False]*10)))
self.assertEqual(block.getValues(0x00, 10), [False]*10)
def testModbusSparseDataBlockFactory(self):
''' Test the sparse data block store factory '''
block = ModbusSparseDataBlock.create()
self.assertEqual(block.getValues(0x00, 65536), [False]*65536)
def testModbusSparseDataBlockOther(self):
block = ModbusSparseDataBlock([True]*10)
self.assertEqual(block.getValues(0x00, 10), [True]*10)
self.assertRaises(ParameterException,
lambda: ModbusSparseDataBlock(True))
def testModbusSlaveContext(self):
''' Test a modbus slave context '''
store = {
'di' : ModbusSequentialDataBlock(0, [False]*10),
'co' : ModbusSequentialDataBlock(0, [False]*10),
'ir' : ModbusSequentialDataBlock(0, [False]*10),
'hr' : ModbusSequentialDataBlock(0, [False]*10),
}
context = ModbusSlaveContext(**store)
self.assertNotEqual(str(context), None)
for fx in [1,2,3,4]:
context.setValues(fx, 0, [True]*10)
self.assertTrue(context.validate(fx, 0,10))
self.assertEqual(context.getValues(fx, 0,10), [True]*10)
context.reset()
for fx in [1,2,3,4]:
self.assertTrue(context.validate(fx, 0,10))
self.assertEqual(context.getValues(fx, 0,10), [False]*10)
def testModbusServerContext(self):
''' Test a modbus server context '''
def _set(ctx):
ctx[0xffff] = None
context = ModbusServerContext(single=False)
self.assertRaises(NoSuchSlaveException, lambda: _set(context))
self.assertRaises(NoSuchSlaveException, lambda: context[0xffff])
class RedisDataStoreTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.datastore.database.redis module
'''
def setUp(self):
self.slave = RedisSlaveContext()
def tearDown(self):
''' Cleans up the test environment '''
pass
def testStr(self):
# slave = RedisSlaveContext()
self.assertEqual(str(self.slave), "Redis Slave Context %s" % self.slave.client)
def testReset(self):
assert isinstance(self.slave.client, redis.Redis)
self.slave.client = MagicMock()
self.slave.reset()
self.slave.client.flushall.assert_called_once_with()
def testValCallbacksSuccess(self):
self.slave._build_mapping()
mock_count = 3
mock_offset = 0
self.slave.client.mset = MagicMock()
self.slave.client.mget = MagicMock(return_value=['11'])
for key in ('d', 'c', 'h', 'i'):
self.assertTrue(
self.slave._val_callbacks[key](mock_offset, mock_count)
)
def testValCallbacksFailure(self):
self.slave._build_mapping()
mock_count = 3
mock_offset = 0
self.slave.client.mset = MagicMock()
self.slave.client.mget = MagicMock(return_value=['11', None])
for key in ('d', 'c', 'h', 'i'):
self.assertFalse(
self.slave._val_callbacks[key](mock_offset, mock_count)
)
def testGetCallbacks(self):
self.slave._build_mapping()
mock_count = 3
mock_offset = 0
self.slave.client.mget = MagicMock(return_value='11')
for key in ('d', 'c'):
resp = self.slave._get_callbacks[key](mock_offset, mock_count)
self.assertEqual(resp, [True, False, False])
for key in ('h', 'i'):
resp = self.slave._get_callbacks[key](mock_offset, mock_count)
self.assertEqual(resp, ['1', '1'])
def testSetCallbacks(self):
self.slave._build_mapping()
mock_values = [3]
mock_offset = 0
self.slave.client.mset = MagicMock()
self.slave.client.mget = MagicMock()
for key in ['c', 'd']:
self.slave._set_callbacks[key](mock_offset, [3])
k = "pymodbus:{}:{}".format(key, mock_offset)
self.slave.client.mset.assert_called_with(
{k: '\x01'}
)
for key in ('h', 'i'):
self.slave._set_callbacks[key](mock_offset, [3])
k = "pymodbus:{}:{}".format(key, mock_offset)
self.slave.client.mset.assert_called_with(
{k: mock_values[0]}
)
def testValidate(self):
self.slave.client.mget = MagicMock(return_value=[123])
self.assertTrue(self.slave.validate(0x01, 3000))
def testSetValue(self):
self.slave.client.mset = MagicMock()
self.slave.client.mget = MagicMock()
self.assertEqual(self.slave.setValues(0x01, 1000, [12]), None)
def testGetValue(self):
self.slave.client.mget = MagicMock(return_value=["123"])
self.assertEqual(self.slave.getValues(0x01, 23), [])
class MockSqlResult(object):
def __init__(self, rowcount=0, value=0):
self.rowcount = rowcount
self.value = value
class SqlDataStoreTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.datastore.database.SqlSlaveContesxt
module
'''
def setUp(self):
self.slave = SqlSlaveContext()
self.slave._metadata.drop_all = MagicMock()
self.slave._db_create = MagicMock()
self.slave._table.select = MagicMock()
self.slave._connection = MagicMock()
self.mock_addr = random.randint(0, 65000)
self.mock_values = random.sample(range(1, 100), 5)
self.mock_function = 0x01
self.mock_type = 'h'
self.mock_offset = 0
self.mock_count = 1
self.function_map = {2: 'd', 4: 'i'}
self.function_map.update([(i, 'h') for i in [3, 6, 16, 22, 23]])
self.function_map.update([(i, 'c') for i in [1, 5, 15]])
def tearDown(self):
''' Cleans up the test environment '''
pass
def testStr(self):
self.assertEqual(str(self.slave), "Modbus Slave Context")
def testReset(self):
self.slave.reset()
self.slave._metadata.drop_all.assert_called_once_with()
self.slave._db_create.assert_called_once_with(
self.slave.table, self.slave.database
)
def testValidateSuccess(self):
mock_result = MockSqlResult(
rowcount=len(self.mock_values)
)
self.slave._connection.execute = MagicMock(return_value=mock_result)
self.assertTrue(self.slave.validate(
self.mock_function, self.mock_addr, len(self.mock_values))
)
def testValidateFailure(self):
wrong_count = 9
mock_result = MockSqlResult(rowcount=len(self.mock_values))
self.slave._connection.execute = MagicMock(return_value=mock_result)
self.assertFalse(self.slave.validate(
self.mock_function, self.mock_addr, wrong_count)
)
def testBuildSet(self):
mock_set = [
{
'index': 0,
'type': 'h',
'value': 11
},
{
'index': 1,
'type': 'h',
'value': 12
}
]
self.assertListEqual(self.slave._build_set('h', 0, [11, 12]), mock_set)
def testCheckSuccess(self):
mock_success_results = [1, 2, 3]
self.slave._get = MagicMock(return_value=mock_success_results)
self.assertFalse(self.slave._check('h', 0, 1))
def testCheckFailure(self):
mock_success_results = []
self.slave._get = MagicMock(return_value=mock_success_results)
self.assertTrue(self.slave._check('h', 0, 1))
def testGetValues(self):
self.slave._get = MagicMock()
for key, value in self.function_map.items():
self.slave.getValues(key, self.mock_addr, self.mock_count)
self.slave._get.assert_called_with(
value, self.mock_addr + 1, self.mock_count
)
def testSetValues(self):
self.slave._set = MagicMock()
for key, value in self.function_map.items():
self.slave.setValues(key, self.mock_addr, self.mock_values)
self.slave._set.assert_called_with(
value, self.mock_addr + 1, self.mock_values
)
def testSet(self):
self.slave._check = MagicMock(return_value=True)
self.slave._connection.execute = MagicMock(
return_value=MockSqlResult(rowcount=len(self.mock_values))
)
self.assertTrue(self.slave._set(
self.mock_type, self.mock_offset, self.mock_values)
)
self.slave._check = MagicMock(return_value=False)
self.assertFalse(
self.slave._set(self.mock_type, self.mock_offset, self.mock_values)
)
def testUpdateSuccess(self):
self.slave._connection.execute = MagicMock(
return_value=MockSqlResult(rowcount=len(self.mock_values))
)
self.assertTrue(
self.slave._update(self.mock_type, self.mock_offset, self.mock_values)
)
def testUpdateFailure(self):
self.slave._connection.execute = MagicMock(
return_value=MockSqlResult(rowcount=100)
)
self.assertFalse(
self.slave._update(self.mock_type, self.mock_offset, self.mock_values)
)
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_device.py 0000664 0000000 0000000 00000033765 13355134677 0017237 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.device import *
from pymodbus.events import ModbusEvent, RemoteReceiveEvent
from pymodbus.constants import DeviceInformation
#---------------------------------------------------------------------------#
# Fixture
#---------------------------------------------------------------------------#
class SimpleDataStoreTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.device module
'''
#-----------------------------------------------------------------------#
# Setup/TearDown
#-----------------------------------------------------------------------#
def setUp(self):
self.info = {
0x00: 'Bashwork', # VendorName
0x01: 'PTM', # ProductCode
0x02: '1.0', # MajorMinorRevision
0x03: 'http://internets.com', # VendorUrl
0x04: 'pymodbus', # ProductName
0x05: 'bashwork', # ModelName
0x06: 'unittest', # UserApplicationName
0x07: 'x', # reserved
0x08: 'x', # reserved
0x10: 'reserved', # reserved
0x80: 'custom1', # device specific start
0x82: 'custom2', # device specific
0xFF: 'customlast', # device specific last
}
self.ident = ModbusDeviceIdentification(self.info)
self.control = ModbusControlBlock()
self.access = ModbusAccessControl()
self.control.reset()
def tearDown(self):
''' Cleans up the test environment '''
del self.ident
del self.control
del self.access
def testUpdateIdentity(self):
''' Test device identification reading '''
self.control.Identity.update(self.ident)
self.assertEqual(self.control.Identity.VendorName, 'Bashwork')
self.assertEqual(self.control.Identity.ProductCode, 'PTM')
self.assertEqual(self.control.Identity.MajorMinorRevision, '1.0')
self.assertEqual(self.control.Identity.VendorUrl, 'http://internets.com')
self.assertEqual(self.control.Identity.ProductName, 'pymodbus')
self.assertEqual(self.control.Identity.ModelName, 'bashwork')
self.assertEqual(self.control.Identity.UserApplicationName, 'unittest')
def testDeviceInformationFactory(self):
''' Test device identification reading '''
self.control.Identity.update(self.ident)
result = DeviceInformationFactory.get(self.control, DeviceInformation.Specific, 0x00)
self.assertEqual(result[0x00], 'Bashwork')
result = DeviceInformationFactory.get(self.control, DeviceInformation.Basic, 0x00)
self.assertEqual(result[0x00], 'Bashwork')
self.assertEqual(result[0x01], 'PTM')
self.assertEqual(result[0x02], '1.0')
result = DeviceInformationFactory.get(self.control, DeviceInformation.Regular, 0x00)
self.assertEqual(result[0x00], 'Bashwork')
self.assertEqual(result[0x01], 'PTM')
self.assertEqual(result[0x02], '1.0')
self.assertEqual(result[0x03], 'http://internets.com')
self.assertEqual(result[0x04], 'pymodbus')
self.assertEqual(result[0x05], 'bashwork')
self.assertEqual(result[0x06], 'unittest')
def testDeviceInformationFactoryLookup(self):
result = DeviceInformationFactory.get(self.control, DeviceInformation.Basic, 0x00)
self.assertEqual(sorted(result.keys()), [0x00, 0x01, 0x02])
result = DeviceInformationFactory.get(self.control, DeviceInformation.Basic, 0x02)
self.assertEqual(sorted(result.keys()), [0x02])
result = DeviceInformationFactory.get(self.control, DeviceInformation.Regular, 0x00)
self.assertEqual(sorted(result.keys()), [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06])
result = DeviceInformationFactory.get(self.control, DeviceInformation.Regular, 0x01)
self.assertEqual(sorted(result.keys()), [0x01, 0x02, 0x03, 0x04, 0x05, 0x06])
result = DeviceInformationFactory.get(self.control, DeviceInformation.Regular, 0x05)
self.assertEqual(sorted(result.keys()), [0x05, 0x06])
result = DeviceInformationFactory.get(self.control, DeviceInformation.Extended, 0x00)
self.assertEqual(sorted(result.keys()), [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x80, 0x82, 0xFF])
result = DeviceInformationFactory.get(self.control, DeviceInformation.Extended, 0x02)
self.assertEqual(sorted(result.keys()), [0x02, 0x03, 0x04, 0x05, 0x06, 0x80, 0x82, 0xFF])
result = DeviceInformationFactory.get(self.control, DeviceInformation.Extended, 0x06)
self.assertEqual(sorted(result.keys()), [0x06, 0x80, 0x82, 0xFF])
result = DeviceInformationFactory.get(self.control, DeviceInformation.Extended, 0x80)
self.assertEqual(sorted(result.keys()), [0x80, 0x82, 0xFF])
result = DeviceInformationFactory.get(self.control, DeviceInformation.Extended, 0x82)
self.assertEqual(sorted(result.keys()), [0x82, 0xFF])
result = DeviceInformationFactory.get(self.control, DeviceInformation.Extended, 0x81)
self.assertEqual(sorted(result.keys()), [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x80, 0x82, 0xFF])
def testBasicCommands(self):
''' Test device identification reading '''
self.assertEqual(str(self.ident), "DeviceIdentity")
self.assertEqual(str(self.control), "ModbusControl")
def testModbusDeviceIdentificationGet(self):
''' Test device identification reading '''
self.assertEqual(self.ident[0x00], 'Bashwork')
self.assertEqual(self.ident[0x01], 'PTM')
self.assertEqual(self.ident[0x02], '1.0')
self.assertEqual(self.ident[0x03], 'http://internets.com')
self.assertEqual(self.ident[0x04], 'pymodbus')
self.assertEqual(self.ident[0x05], 'bashwork')
self.assertEqual(self.ident[0x06], 'unittest')
self.assertNotEqual(self.ident[0x07], 'x')
self.assertNotEqual(self.ident[0x08], 'x')
self.assertNotEqual(self.ident[0x10], 'reserved')
self.assertEqual(self.ident[0x54], '')
def testModbusDeviceIdentificationSummary(self):
''' Test device identification summary creation '''
summary = sorted(self.ident.summary().values())
expected = sorted(list(self.info.values())[:0x07]) # remove private
self.assertEqual(summary, expected)
def testModbusDeviceIdentificationSet(self):
''' Test a device identification writing '''
self.ident[0x07] = 'y'
self.ident[0x08] = 'y'
self.ident[0x10] = 'public'
self.ident[0x54] = 'testing'
self.assertNotEqual('y', self.ident[0x07])
self.assertNotEqual('y', self.ident[0x08])
self.assertEqual('public', self.ident[0x10])
self.assertEqual('testing', self.ident[0x54])
def testModbusControlBlockAsciiModes(self):
''' Test a server control block ascii mode '''
self.assertEqual(id(self.control), id(ModbusControlBlock()))
self.control.Mode = 'RTU'
self.assertEqual('RTU', self.control.Mode)
self.control.Mode = 'FAKE'
self.assertNotEqual('FAKE', self.control.Mode)
def testModbusControlBlockCounters(self):
''' Tests the MCB counters methods '''
self.assertEqual(0x0, self.control.Counter.BusMessage)
for _ in range(10):
self.control.Counter.BusMessage += 1
self.control.Counter.SlaveMessage += 1
self.assertEqual(10, self.control.Counter.BusMessage)
self.control.Counter.BusMessage = 0x00
self.assertEqual(0, self.control.Counter.BusMessage)
self.assertEqual(10, self.control.Counter.SlaveMessage)
self.control.Counter.reset()
self.assertEqual(0, self.control.Counter.SlaveMessage)
def testModbusControlBlockUpdate(self):
''' Tests the MCB counters upate methods '''
values = {'SlaveMessage':5, 'BusMessage':5}
self.control.Counter.BusMessage += 1
self.control.Counter.SlaveMessage += 1
self.control.Counter.update(values)
self.assertEqual(6, self.control.Counter.SlaveMessage)
self.assertEqual(6, self.control.Counter.BusMessage)
def testModbusControlBlockIterator(self):
''' Tests the MCB counters iterator '''
self.control.Counter.reset()
for _,count in self.control:
self.assertEqual(0, count)
def testModbusCountersHandlerIterator(self):
''' Tests the MCB counters iterator '''
self.control.Counter.reset()
for _,count in self.control.Counter:
self.assertEqual(0, count)
def testModbusControlBlockCounterSummary(self):
''' Tests retrieving the current counter summary '''
self.assertEqual(0x00, self.control.Counter.summary())
for _ in range(10):
self.control.Counter.BusMessage += 1
self.control.Counter.SlaveMessage += 1
self.control.Counter.SlaveNAK += 1
self.control.Counter.BusCharacterOverrun += 1
self.assertEqual(0xa9, self.control.Counter.summary())
self.control.Counter.reset()
self.assertEqual(0x00, self.control.Counter.summary())
def testModbusControlBlockListen(self):
''' Tests the MCB listen flag methods '''
self.control.ListenOnly = False
self.assertEqual(self.control.ListenOnly, False)
self.control.ListenOnly = not self.control.ListenOnly
self.assertEqual(self.control.ListenOnly, True)
def testModbusControlBlockDelimiter(self):
''' Tests the MCB delimiter setting methods '''
self.control.Delimiter = b'\r'
self.assertEqual(self.control.Delimiter, b'\r')
self.control.Delimiter = '='
self.assertEqual(self.control.Delimiter, b'=')
self.control.Delimiter = 61
self.assertEqual(self.control.Delimiter, b'=')
def testModbusControlBlockDiagnostic(self):
''' Tests the MCB delimiter setting methods '''
self.assertEqual([False] * 16, self.control.getDiagnosticRegister())
for i in [1,3,4,6]:
self.control.setDiagnostic({i:True});
self.assertEqual(True, self.control.getDiagnostic(1))
self.assertEqual(False, self.control.getDiagnostic(2))
actual = [False, True, False, True, True, False, True] + [False] * 9
self.assertEqual(actual, self.control.getDiagnosticRegister())
for i in range(16):
self.control.setDiagnostic({i:False});
def testModbusControlBlockInvalidDiagnostic(self):
''' Tests querying invalid MCB counters methods '''
self.assertEqual(None, self.control.getDiagnostic(-1))
self.assertEqual(None, self.control.getDiagnostic(17))
self.assertEqual(None, self.control.getDiagnostic(None))
self.assertEqual(None, self.control.getDiagnostic([1,2,3]))
def testAddRemoveSingleClients(self):
''' Test adding and removing a host '''
self.assertFalse(self.access.check("192.168.1.1"))
self.access.add("192.168.1.1")
self.assertTrue(self.access.check("192.168.1.1"))
self.access.add("192.168.1.1")
self.access.remove("192.168.1.1")
self.assertFalse(self.access.check("192.168.1.1"))
def testAddRemoveMultipleClients(self):
''' Test adding and removing a host '''
clients = ["192.168.1.1", "192.168.1.2", "192.168.1.3"]
self.access.add(clients)
for host in clients:
self.assertTrue(self.access.check(host))
self.access.remove(clients)
def testNetworkAccessListIterator(self):
''' Test adding and removing a host '''
clients = ["127.0.0.1", "192.168.1.1", "192.168.1.2", "192.168.1.3"]
self.access.add(clients)
for host in self.access:
self.assertTrue(host in clients)
for host in clients:
self.assertTrue(host in self.access)
def testClearingControlEvents(self):
''' Test adding and clearing modbus events '''
self.assertEqual(self.control.Events, [])
event = ModbusEvent()
self.control.addEvent(event)
self.assertEqual(self.control.Events, [event])
self.assertEqual(self.control.Counter.Event, 1)
self.control.clearEvents()
self.assertEqual(self.control.Events, [])
self.assertEqual(self.control.Counter.Event, 1)
def testRetrievingControlEvents(self):
''' Test adding and removing a host '''
self.assertEqual(self.control.Events, [])
event = RemoteReceiveEvent()
self.control.addEvent(event)
self.assertEqual(self.control.Events, [event])
packet = self.control.getEvents()
self.assertEqual(packet, b'\x40')
def testModbusPlusStatistics(self):
''' Test device identification reading '''
default = [0x0000] * 55
statistics = ModbusPlusStatistics()
self.assertEqual(default, statistics.encode())
statistics.reset()
self.assertEqual(default, statistics.encode())
self.assertEqual(default, self.control.Plus.encode())
def testModbusPlusStatisticsHelpers(self):
''' Test modbus plus statistics helper methods '''
statistics = ModbusPlusStatistics()
summary = [
[0],[0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0],[0],
[0,0,0,0,0,0,0,0],[0],[0],[0],[0],[0,0],[0],[0],[0],[0],
[0],[0],[0],[0,0],[0],[0],[0],[0],[0,0,0,0,0,0,0,0],[0],
[0,0,0,0,0,0,0,0],[0,0],[0],[0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0],[0],[0],[0,0],[0],[0],[0],[0],[0,0],
[0],[0],[0],[0],[0],[0,0],[0],[0,0,0,0,0,0,0,0]]
stats_summary = [x for x in statistics.summary()]
self.assertEqual(sorted(summary), sorted(stats_summary))
self.assertEqual(0x00, sum(sum(value[1]) for value in statistics))
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_diag_messages.py 0000664 0000000 0000000 00000017472 13355134677 0020570 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.exceptions import *
from pymodbus.constants import ModbusPlusOperation
from pymodbus.diag_message import *
from pymodbus.diag_message import DiagnosticStatusRequest
from pymodbus.diag_message import DiagnosticStatusResponse
from pymodbus.diag_message import DiagnosticStatusSimpleRequest
from pymodbus.diag_message import DiagnosticStatusSimpleResponse
class SimpleDataStoreTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.diag_message module
'''
def setUp(self):
self.requests = [
#(DiagnosticStatusRequest, b'\x00\x00\x00\x00'),
#(DiagnosticStatusSimpleRequest, b'\x00\x00\x00\x00'),
(RestartCommunicationsOptionRequest, b'\x00\x01\x00\x00', b'\x00\x01\xff\x00'),
(ReturnDiagnosticRegisterRequest, b'\x00\x02\x00\x00', b'\x00\x02\x00\x00'),
(ChangeAsciiInputDelimiterRequest, b'\x00\x03\x00\x00', b'\x00\x03\x00\x00'),
(ForceListenOnlyModeRequest, b'\x00\x04\x00\x00', b'\x00\x04'),
(ReturnQueryDataRequest, b'\x00\x00\x00\x00', b'\x00\x00\x00\x00'),
(ClearCountersRequest, b'\x00\x0a\x00\x00', b'\x00\x0a\x00\x00'),
(ReturnBusMessageCountRequest, b'\x00\x0b\x00\x00', b'\x00\x0b\x00\x00'),
(ReturnBusCommunicationErrorCountRequest, b'\x00\x0c\x00\x00', b'\x00\x0c\x00\x00'),
(ReturnBusExceptionErrorCountRequest, b'\x00\x0d\x00\x00', b'\x00\x0d\x00\x00'),
(ReturnSlaveMessageCountRequest, b'\x00\x0e\x00\x00', b'\x00\x0e\x00\x00'),
(ReturnSlaveNoResponseCountRequest, b'\x00\x0f\x00\x00', b'\x00\x0f\x00\x00'),
(ReturnSlaveNAKCountRequest, b'\x00\x10\x00\x00', b'\x00\x10\x00\x00'),
(ReturnSlaveBusyCountRequest, b'\x00\x11\x00\x00', b'\x00\x11\x00\x00'),
(ReturnSlaveBusCharacterOverrunCountRequest, b'\x00\x12\x00\x00', b'\x00\x12\x00\x00'),
(ReturnIopOverrunCountRequest, b'\x00\x13\x00\x00', b'\x00\x13\x00\x00'),
(ClearOverrunCountRequest, b'\x00\x14\x00\x00', b'\x00\x14\x00\x00'),
(GetClearModbusPlusRequest, b'\x00\x15\x00\x00', b'\x00\x15\x00\x00' + b'\x00\x00' * 55),
]
self.responses = [
#(DiagnosticStatusResponse, b'\x00\x00\x00\x00'),
#(DiagnosticStatusSimpleResponse, b'\x00\x00\x00\x00'),
(ReturnQueryDataResponse, b'\x00\x00\x00\x00'),
(RestartCommunicationsOptionResponse, b'\x00\x01\x00\x00'),
(ReturnDiagnosticRegisterResponse, b'\x00\x02\x00\x00'),
(ChangeAsciiInputDelimiterResponse, b'\x00\x03\x00\x00'),
(ForceListenOnlyModeResponse, b'\x00\x04'),
(ReturnQueryDataResponse, b'\x00\x00\x00\x00'),
(ClearCountersResponse, b'\x00\x0a\x00\x00'),
(ReturnBusMessageCountResponse, b'\x00\x0b\x00\x00'),
(ReturnBusCommunicationErrorCountResponse, b'\x00\x0c\x00\x00'),
(ReturnBusExceptionErrorCountResponse, b'\x00\x0d\x00\x00'),
(ReturnSlaveMessageCountResponse, b'\x00\x0e\x00\x00'),
(ReturnSlaveNoReponseCountResponse, b'\x00\x0f\x00\x00'),
(ReturnSlaveNAKCountResponse, b'\x00\x10\x00\x00'),
(ReturnSlaveBusyCountResponse, b'\x00\x11\x00\x00'),
(ReturnSlaveBusCharacterOverrunCountResponse, b'\x00\x12\x00\x00'),
(ReturnIopOverrunCountResponse, b'\x00\x13\x00\x00'),
(ClearOverrunCountResponse, b'\x00\x14\x00\x00'),
(GetClearModbusPlusResponse, b'\x00\x15\x00\x04' + b'\x00\x00' * 55),
]
def tearDown(self):
''' Cleans up the test environment '''
del self.requests
del self.responses
def testDiagnosticRequestsDecode(self):
''' Testing diagnostic request messages encoding '''
for msg,enc,exe in self.requests:
handle = DiagnosticStatusRequest()
handle.decode(enc)
self.assertEqual(handle.sub_function_code, msg.sub_function_code)
def testDiagnosticSimpleRequests(self):
''' Testing diagnostic request messages encoding '''
request = DiagnosticStatusSimpleRequest(b'\x12\x34')
request.sub_function_code = 0x1234
self.assertRaises(NotImplementedException, lambda: request.execute())
self.assertEqual(request.encode(), b'\x12\x34\x12\x34')
response = DiagnosticStatusSimpleResponse(None)
def testDiagnosticResponseDecode(self):
''' Testing diagnostic request messages encoding '''
for msg,enc,exe in self.requests:
handle = DiagnosticStatusResponse()
handle.decode(enc)
self.assertEqual(handle.sub_function_code, msg.sub_function_code)
def testDiagnosticRequestsEncode(self):
''' Testing diagnostic request messages encoding '''
for msg,enc,exe in self.requests:
self.assertEqual(msg().encode(), enc)
#def testDiagnosticResponse(self):
# ''' Testing diagnostic request messages '''
# for msg,enc in self.responses:
# self.assertEqual(msg().encode(), enc)
def testDiagnosticExecute(self):
''' Testing diagnostic message execution '''
for message, encoded, executed in self.requests:
encoded = message().execute().encode()
self.assertEqual(encoded, executed)
def testReturnQueryDataRequest(self):
''' Testing diagnostic message execution '''
message = ReturnQueryDataRequest([0x0000]*2)
self.assertEqual(message.encode(), b'\x00\x00\x00\x00\x00\x00');
message = ReturnQueryDataRequest(0x0000)
self.assertEqual(message.encode(), b'\x00\x00\x00\x00');
def testReturnQueryDataResponse(self):
''' Testing diagnostic message execution '''
message = ReturnQueryDataResponse([0x0000]*2)
self.assertEqual(message.encode(), b'\x00\x00\x00\x00\x00\x00');
message = ReturnQueryDataResponse(0x0000)
self.assertEqual(message.encode(), b'\x00\x00\x00\x00');
def testRestartCommunicationsOption(self):
''' Testing diagnostic message execution '''
request = RestartCommunicationsOptionRequest(True);
self.assertEqual(request.encode(), b'\x00\x01\xff\x00')
request = RestartCommunicationsOptionRequest(False);
self.assertEqual(request.encode(), b'\x00\x01\x00\x00')
response = RestartCommunicationsOptionResponse(True);
self.assertEqual(response.encode(), b'\x00\x01\xff\x00')
response = RestartCommunicationsOptionResponse(False);
self.assertEqual(response.encode(), b'\x00\x01\x00\x00')
def testGetClearModbusPlusRequestExecute(self):
''' Testing diagnostic message execution '''
request = GetClearModbusPlusRequest(data=ModbusPlusOperation.ClearStatistics);
response = request.execute()
self.assertEqual(response.message, ModbusPlusOperation.ClearStatistics)
request = GetClearModbusPlusRequest(data=ModbusPlusOperation.GetStatistics);
response = request.execute()
resp = [ModbusPlusOperation.GetStatistics]
self.assertEqual(response.message, resp+[0x00] * 55)
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_events.py 0000664 0000000 0000000 00000004776 13355134677 0017304 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.events import *
from pymodbus.exceptions import NotImplementedException
from pymodbus.exceptions import ParameterException
class ModbusEventsTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.device module
'''
def setUp(self):
''' Sets up the test environment '''
pass
def tearDown(self):
''' Cleans up the test environment '''
pass
def testModbusEventBaseClass(self):
event = ModbusEvent()
self.assertRaises(NotImplementedException, event.encode)
self.assertRaises(NotImplementedException, lambda: event.decode(None))
def testRemoteReceiveEvent(self):
event = RemoteReceiveEvent()
event.decode(b'\x70')
self.assertTrue(event.overrun)
self.assertTrue(event.listen)
self.assertTrue(event.broadcast)
def testRemoteSentEvent(self):
event = RemoteSendEvent()
result = event.encode()
self.assertEqual(result, b'\x40')
event.decode(b'\x7f')
self.assertTrue(event.read)
self.assertTrue(event.slave_abort)
self.assertTrue(event.slave_busy)
self.assertTrue(event.slave_nak)
self.assertTrue(event.write_timeout)
self.assertTrue(event.listen)
def testRemoteSentEventEncode(self):
arguments = {
'read' : True,
'slave_abort' : True,
'slave_busy' : True,
'slave_nak' : True,
'write_timeout' : True,
'listen' : True,
}
event = RemoteSendEvent(**arguments)
result = event.encode()
self.assertEqual(result, b'\x7f')
def testEnteredListenModeEvent(self):
event = EnteredListenModeEvent()
result = event.encode()
self.assertEqual(result, b'\x04')
event.decode(b'\x04')
self.assertEqual(event.value, 0x04)
self.assertRaises(ParameterException, lambda: event.decode(b'\x00'))
def testCommunicationRestartEvent(self):
event = CommunicationRestartEvent()
result = event.encode()
self.assertEqual(result, b'\x00')
event.decode(b'\x00')
self.assertEqual(event.value, 0x00)
self.assertRaises(ParameterException, lambda: event.decode(b'\x04'))
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_exceptions.py 0000664 0000000 0000000 00000002253 13355134677 0020145 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.exceptions import *
class SimpleExceptionsTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.exceptions module
'''
def setUp(self):
''' Initializes the test environment '''
self.exceptions = [
ModbusException("bad base"),
ModbusIOException("bad register"),
ParameterException("bad paramater"),
NotImplementedException("bad function"),
ConnectionException("bad connection"),
]
def tearDown(self):
''' Cleans up the test environment '''
pass
def testExceptions(self):
''' Test all module exceptions '''
for ex in self.exceptions:
try:
raise ex
except ModbusException as ex:
self.assertTrue("Modbus Error:" in str(ex))
pass
else: self.fail("Excepted a ModbusExceptions")
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_factory.py 0000664 0000000 0000000 00000021215 13355134677 0017432 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.factory import ServerDecoder, ClientDecoder
from pymodbus.exceptions import ModbusException
def _raise_exception(_):
raise ModbusException('something')
class SimpleFactoryTest(unittest.TestCase):
'''
This is the unittest for the pymod.exceptions module
'''
def setUp(self):
''' Initializes the test environment '''
self.client = ClientDecoder()
self.server = ServerDecoder()
self.request = (
(0x01, b'\x01\x00\x01\x00\x01'), # read coils
(0x02, b'\x02\x00\x01\x00\x01'), # read discrete inputs
(0x03, b'\x03\x00\x01\x00\x01'), # read holding registers
(0x04, b'\x04\x00\x01\x00\x01'), # read input registers
(0x05, b'\x05\x00\x01\x00\x01'), # write single coil
(0x06, b'\x06\x00\x01\x00\x01'), # write single register
(0x07, b'\x07'), # read exception status
(0x08, b'\x08\x00\x00\x00\x00'), # read diagnostic
(0x0b, b'\x0b'), # get comm event counters
(0x0c, b'\x0c'), # get comm event log
(0x0f, b'\x0f\x00\x01\x00\x08\x01\x00\xff'), # write multiple coils
(0x10, b'\x10\x00\x01\x00\x02\x04\0xff\xff'), # write multiple registers
(0x11, b'\x11'), # report slave id
(0x14, b'\x14\x0e\x06\x00\x04\x00\x01\x00\x02' \
b'\x06\x00\x03\x00\x09\x00\x02'), # read file record
(0x15, b'\x15\x0d\x06\x00\x04\x00\x07\x00\x03' \
b'\x06\xaf\x04\xbe\x10\x0d'), # write file record
(0x16, b'\x16\x00\x01\x00\xff\xff\x00'), # mask write register
(0x17, b'\x17\x00\x01\x00\x01\x00\x01\x00\x01\x02\x12\x34'),# read/write multiple registers
(0x18, b'\x18\x00\x01'), # read fifo queue
(0x2b, b'\x2b\x0e\x01\x00'), # read device identification
)
self.response = (
(0x01, b'\x01\x01\x01'), # read coils
(0x02, b'\x02\x01\x01'), # read discrete inputs
(0x03, b'\x03\x02\x01\x01'), # read holding registers
(0x04, b'\x04\x02\x01\x01'), # read input registers
(0x05, b'\x05\x00\x01\x00\x01'), # write single coil
(0x06, b'\x06\x00\x01\x00\x01'), # write single register
(0x07, b'\x07\x00'), # read exception status
(0x08, b'\x08\x00\x00\x00\x00'), # read diagnostic
(0x0b, b'\x0b\x00\x00\x00\x00'), # get comm event counters
(0x0c, b'\x0c\x08\x00\x00\x01\x08\x01\x21\x20\x00'), # get comm event log
(0x0f, b'\x0f\x00\x01\x00\x08'), # write multiple coils
(0x10, b'\x10\x00\x01\x00\x02'), # write multiple registers
(0x11, b'\x11\x03\x05\x01\x54'), # report slave id (device specific)
(0x14, b'\x14\x0c\x05\x06\x0d\xfe\x00\x20\x05' \
b'\x06\x33\xcd\x00\x40'), # read file record
(0x15, b'\x15\x0d\x06\x00\x04\x00\x07\x00\x03' \
b'\x06\xaf\x04\xbe\x10\x0d'), # write file record
(0x16, b'\x16\x00\x01\x00\xff\xff\x00'), # mask write register
(0x17, b'\x17\x02\x12\x34'), # read/write multiple registers
(0x18, b'\x18\x00\x01\x00\x01\x00\x00'), # read fifo queue
(0x2b, b'\x2b\x0e\x01\x01\x00\x00\x01\x00\x01\x77'), # read device identification
)
self.exception = (
(0x81, b'\x81\x01\xd0\x50'), # illegal function exception
(0x82, b'\x82\x02\x90\xa1'), # illegal data address exception
(0x83, b'\x83\x03\x50\xf1'), # illegal data value exception
(0x84, b'\x84\x04\x13\x03'), # skave device failure exception
(0x85, b'\x85\x05\xd3\x53'), # acknowledge exception
(0x86, b'\x86\x06\x93\xa2'), # slave device busy exception
(0x87, b'\x87\x08\x53\xf2'), # memory parity exception
(0x88, b'\x88\x0a\x16\x06'), # gateway path unavailable exception
(0x89, b'\x89\x0b\xd6\x56'), # gateway target failed exception
)
self.bad = (
(0x80, b'\x80\x00\x00\x00'), # Unknown Function
(0x81, b'\x81\x00\x00\x00'), # error message
)
def tearDown(self):
''' Cleans up the test environment '''
del self.bad
del self.request
del self.response
def testExceptionLookup(self):
''' Test that we can look up exception messages '''
for func, _ in self.exception:
response = self.client.lookupPduClass(func)
self.assertNotEqual(response, None)
for func, _ in self.exception:
response = self.server.lookupPduClass(func)
self.assertNotEqual(response, None)
def testResponseLookup(self):
''' Test a working response factory lookup '''
for func, _ in self.response:
response = self.client.lookupPduClass(func)
self.assertNotEqual(response, None)
def testRequestLookup(self):
''' Test a working request factory lookup '''
for func, _ in self.request:
request = self.client.lookupPduClass(func)
self.assertNotEqual(request, None)
def testResponseWorking(self):
''' Test a working response factory decoders '''
for func, msg in self.response:
try:
self.client.decode(msg)
except ModbusException:
self.fail("Failed to Decode Response Message", func)
def testResponseErrors(self):
''' Test a response factory decoder exceptions '''
self.assertRaises(ModbusException, self.client._helper, self.bad[0][1])
self.assertEqual(self.client.decode(self.bad[1][1]).function_code, self.bad[1][0],
"Failed to decode error PDU")
def testRequestsWorking(self):
''' Test a working request factory decoders '''
for func, msg in self.request:
try:
self.server.decode(msg)
except ModbusException:
self.fail("Failed to Decode Request Message", func)
def testClientFactoryFails(self):
''' Tests that a client factory will fail to decode a bad message '''
self.client._helper = _raise_exception
actual = self.client.decode(None)
self.assertEqual(actual, None)
def testServerFactoryFails(self):
''' Tests that a server factory will fail to decode a bad message '''
self.server._helper = _raise_exception
actual = self.server.decode(None)
self.assertEqual(actual, None)
#---------------------------------------------------------------------------#
# I don't actually know what is supposed to be returned here, I assume that
# since the high bit is set, it will simply echo the resulting message
#---------------------------------------------------------------------------#
def testRequestErrors(self):
''' Test a request factory decoder exceptions '''
for func, msg in self.bad:
result = self.server.decode(msg)
self.assertEqual(result.ErrorCode, 1,
"Failed to decode invalid requests")
self.assertEqual(result.execute(None).function_code, func,
"Failed to create correct response message")
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_file_message.py 0000664 0000000 0000000 00000025263 13355134677 0020415 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
'''
Bit Message Test Fixture
--------------------------------
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.pdu import ModbusExceptions
from .modbus_mocks import MockContext
#---------------------------------------------------------------------------#
# Fixture
#---------------------------------------------------------------------------#
class ModbusBitMessageTests(unittest.TestCase):
#-----------------------------------------------------------------------#
# Setup/TearDown
#-----------------------------------------------------------------------#
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):
''' Test basic bit message encoding/decoding '''
handle = ReadFifoQueueRequest(0x1234)
result = handle.encode()
self.assertEqual(result, b'\x12\x34')
def testReadFifoQueueRequestDecode(self):
''' Test basic bit message encoding/decoding '''
handle = ReadFifoQueueRequest(0x0000)
handle.decode(b'\x12\x34')
self.assertEqual(handle.address, 0x1234)
def testReadFifoQueueRequest(self):
''' Test basic bit message encoding/decoding '''
context = MockContext()
handle = ReadFifoQueueRequest(0x1234)
result = handle.execute(context)
self.assertTrue(isinstance(result, ReadFifoQueueResponse))
handle.address = -1
result = handle.execute(context)
self.assertEqual(ModbusExceptions.IllegalValue,
result.exception_code)
handle.values = [0x00]*33
result = handle.execute(context)
self.assertEqual(ModbusExceptions.IllegalValue,
result.exception_code)
def testReadFifoQueueRequestError(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):
''' 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):
''' 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):
''' 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)
self.assertEqual(result, 14)
#-----------------------------------------------------------------------#
# File Record
#-----------------------------------------------------------------------#
def testFileRecordLength(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):
''' 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')
record3 = FileRecord(file_number=0x02, record_number=0x03, record_data=b'\x00\x01\x02\x04')
record4 = FileRecord(file_number=0x01, record_number=0x02, record_data=b'\x00\x01\x02\x04')
self.assertTrue(record1 == record4)
self.assertTrue(record1 != record2)
self.assertNotEqual(record1, record2)
self.assertNotEqual(record1, record3)
self.assertNotEqual(record2, record3)
self.assertEqual(record1, record4)
self.assertEqual(str(record1), "FileRecord(file=1, record=2, length=2)")
self.assertEqual(str(record2), "FileRecord(file=1, record=2, length=2)")
self.assertEqual(str(record3), "FileRecord(file=2, record=3, length=2)")
#-----------------------------------------------------------------------#
# Read File Record Request
#-----------------------------------------------------------------------#
def testReadFileRecordRequestEncode(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):
''' 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):
''' 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):
''' Test basic bit message encoding/decoding '''
handle = ReadFileRecordRequest()
result = handle.execute(None)
self.assertTrue(isinstance(result, ReadFileRecordResponse))
#-----------------------------------------------------------------------#
# Read File Record Response
#-----------------------------------------------------------------------#
def testReadFileRecordResponseEncode(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):
''' Test basic bit message encoding/decoding '''
record = FileRecord(file_number=0x00, record_number=0x00,
record_data=b'\x0d\xfe\x00\x20')
request = b'\x0c\x05\x06\x0d\xfe\x00\x20\x05\x05\x06\x33\xcd\x00\x40'
handle = ReadFileRecordResponse()
handle.decode(request)
self.assertEqual(handle.records[0], record)
def testReadFileRecordResponseRtuFrameSize(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()
size = handle.calculateRtuFrameSize(request)
self.assertEqual(size, 0x0c + 5)
#-----------------------------------------------------------------------#
# Write File Record Request
#-----------------------------------------------------------------------#
def testWriteFileRecordRequestEncode(self):
''' Test basic bit message encoding/decoding '''
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):
''' Test basic bit message encoding/decoding '''
record = FileRecord(file_number=0x04, record_number=0x07,
record_data=b'\x06\xaf\x04\xbe\x10\x0d')
request = b'\x0d\x06\x00\x04\x00\x07\x00\x03\x06\xaf\x04\xbe\x10\x0d'
handle = WriteFileRecordRequest()
handle.decode(request)
self.assertEqual(handle.records[0], record)
def testWriteFileRecordRequestRtuFrameSize(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):
''' Test basic bit message encoding/decoding '''
handle = WriteFileRecordRequest()
result = handle.execute(None)
self.assertTrue(isinstance(result, WriteFileRecordResponse))
#-----------------------------------------------------------------------#
# Write File Record Response
#-----------------------------------------------------------------------#
def testWriteFileRecordResponseEncode(self):
''' Test basic bit message encoding/decoding '''
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):
''' Test basic bit message encoding/decoding '''
record = FileRecord(file_number=0x04, record_number=0x07,
record_data=b'\x06\xaf\x04\xbe\x10\x0d')
request = b'\x0d\x06\x00\x04\x00\x07\x00\x03\x06\xaf\x04\xbe\x10\x0d'
handle = WriteFileRecordResponse()
handle.decode(request)
self.assertEqual(handle.records[0], record)
def testWriteFileRecordResponseRtuFrameSize(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()
size = handle.calculateRtuFrameSize(request)
self.assertEqual(size, 0x0d + 5)
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_fixes.py 0000664 0000000 0000000 00000001520 13355134677 0017076 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
class ModbusFixesTest(unittest.TestCase):
'''
This is the unittest for the pymodbus._version code
'''
def testTrueFalseDefined(self):
''' Test that True and False are defined on all versions'''
try:
True,False
except NameError:
import pymodbus
self.assertEqual(True, 1)
self.assertEqual(False, 1)
def testNullLoggerAttached(self):
''' Test that the null logger is attached'''
import logging
logger = logging.getLogger('pymodbus')
self.assertEqual(len(logger.handlers), 1)
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_framers.py 0000664 0000000 0000000 00000012033 13355134677 0017420 0 ustar 00root root 0000000 0000000 import pytest
from pymodbus.factory import ClientDecoder
from pymodbus.framer.rtu_framer import ModbusRtuFramer
from pymodbus.framer.ascii_framer import ModbusAsciiFramer
from pymodbus.framer.binary_framer import ModbusBinaryFramer
from pymodbus.utilities import ModbusTransactionState
from pymodbus.bit_read_message import ReadCoilsRequest
from pymodbus.exceptions import ModbusIOException
from pymodbus.compat import IS_PYTHON3
if IS_PYTHON3:
from unittest.mock import Mock
else: # Python 2
from mock import Mock
@pytest.fixture
def rtu_framer():
return ModbusRtuFramer(ClientDecoder())
@pytest.fixture
def ascii_framer():
return ModbusAsciiFramer(ClientDecoder())
@pytest.fixture
def binary_framer():
return ModbusBinaryFramer(ClientDecoder())
@pytest.mark.parametrize("framer", [ModbusRtuFramer,
ModbusAsciiFramer,
ModbusBinaryFramer,
])
def test_framer_initialization(framer):
decoder = ClientDecoder()
framer = framer(decoder)
assert framer.client == None
assert framer._buffer == b''
assert framer.decoder == decoder
if isinstance(framer, ModbusAsciiFramer):
assert framer._header == {'lrc': '0000', 'len': 0, 'uid': 0x00}
assert framer._hsize == 0x02
assert framer._start == b':'
assert framer._end == b"\r\n"
elif isinstance(framer, ModbusRtuFramer):
assert framer._header == {'uid': 0x00, 'len': 0, 'crc': '0000'}
assert framer._hsize == 0x01
assert framer._end == b'\x0d\x0a'
assert framer._min_frame_size == 4
else:
assert framer._header == {'crc': 0x0000, 'len': 0, 'uid': 0x00}
assert framer._hsize == 0x01
assert framer._start == b'\x7b'
assert framer._end == b'\x7d'
assert framer._repeat == [b'}'[0], b'{'[0]]
@pytest.mark.parametrize("data", [(b'', {}),
(b'abcd', {'fcode': 98, 'unit': 97})])
def test_decode_data(rtu_framer, data):
data, expected = data
decoded = rtu_framer.decode_data(data)
assert decoded == expected
@pytest.mark.parametrize("data", [(b'', False),
(b'\x02\x01\x01\x00Q\xcc', True)])
def test_check_frame(rtu_framer, data):
data, expected = data
rtu_framer._buffer = data
assert expected == rtu_framer.checkFrame()
@pytest.mark.parametrize("data", [b'', b'abcd'])
def test_advance_framer(rtu_framer, data):
rtu_framer._buffer = data
rtu_framer.advanceFrame()
assert rtu_framer._header == {}
assert rtu_framer._buffer == data
@pytest.mark.parametrize("data", [b'', b'abcd'])
def test_reset_framer(rtu_framer, data):
rtu_framer._buffer = data
rtu_framer.resetFrame()
assert rtu_framer._header == {}
assert rtu_framer._buffer == b''
@pytest.mark.parametrize("data", [(b'', False), (b'abcd', True)])
def test_is_frame_ready(rtu_framer, data):
data, expected = data
rtu_framer._buffer = data
rtu_framer.advanceFrame()
assert rtu_framer.isFrameReady() == expected
def test_populate_header(rtu_framer):
rtu_framer.populateHeader(b'abcd')
assert rtu_framer._header == {'crc': b'd', 'uid': 97, 'len': 5}
def test_add_to_frame(rtu_framer):
assert rtu_framer._buffer == b''
rtu_framer.addToFrame(b'abcd')
assert rtu_framer._buffer == b'abcd'
def test_get_frame(rtu_framer):
rtu_framer.addToFrame(b'\x02\x01\x01\x00Q\xcc')
rtu_framer.populateHeader(b'\x02\x01\x01\x00Q\xcc')
assert rtu_framer.getFrame() == b'\x01\x01\x00'
def test_populate_result(rtu_framer):
rtu_framer._header['uid'] = 255
result = Mock()
rtu_framer.populateResult(result)
assert result.unit_id == 255
def test_process_incoming_packet(rtu_framer):
def cb(res):
return res
def test_build_packet(rtu_framer):
message = ReadCoilsRequest(1, 10)
assert rtu_framer.buildPacket(message) == b'\x00\x01\x00\x01\x00\n\xec\x1c'
def test_send_packet(rtu_framer):
message = b'\x00\x01\x00\x01\x00\n\xec\x1c'
client = Mock()
client.state = ModbusTransactionState.TRANSACTION_COMPLETE
client.silent_interval = 1
client.last_frame_end = 1
client.timeout = 0.25
client.idle_time.return_value = 1
client.send.return_value = len(message)
rtu_framer.client = client
assert rtu_framer.sendPacket(message) == len(message)
client.state = ModbusTransactionState.PROCESSING_REPLY
assert rtu_framer.sendPacket(message) == len(message)
def test_recv_packet(rtu_framer):
message = b'\x00\x01\x00\x01\x00\n\xec\x1c'
client = Mock()
client.recv.return_value = message
rtu_framer.client = client
assert rtu_framer.recvPacket(len(message)) == message
def test_process(rtu_framer):
def cb(res):
return res
rtu_framer._buffer = b'\x00\x01\x00\x01\x00\n\xec\x1c'
with pytest.raises(ModbusIOException):
rtu_framer._process(cb)
def test_get_raw_frame(rtu_framer):
rtu_framer._buffer = b'\x00\x01\x00\x01\x00\n\xec\x1c'
assert rtu_framer.getRawFrame() == rtu_framer._buffer pymodbus-2.1.0/test/test_interfaces.py 0000664 0000000 0000000 00000005250 13355134677 0020107 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.interfaces import *
from pymodbus.exceptions import NotImplementedException
class _SingleInstance(Singleton):
pass
class ModbusInterfaceTestsTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.interfaces module
'''
def setUp(self):
''' Initializes the test environment '''
pass
def tearDown(self):
''' Cleans up the test environment '''
pass
def testSingletonInterface(self):
''' Test that the singleton interface works '''
first = _SingleInstance()
second = _SingleInstance()
self.assertEqual(first, second)
def testModbusDecoderInterface(self):
''' Test that the base class isn't implemented '''
x = None
instance = IModbusDecoder()
self.assertRaises(NotImplementedException, lambda: instance.decode(x))
self.assertRaises(NotImplementedException, lambda: instance.lookupPduClass(x))
def testModbusFramerInterface(self):
''' Test that the base class isn't implemented '''
x = None
instance = IModbusFramer()
self.assertRaises(NotImplementedException, instance.checkFrame)
self.assertRaises(NotImplementedException, instance.advanceFrame)
self.assertRaises(NotImplementedException, instance.isFrameReady)
self.assertRaises(NotImplementedException, instance.getFrame)
self.assertRaises(NotImplementedException, lambda: instance.addToFrame(x))
self.assertRaises(NotImplementedException, lambda: instance.populateResult(x))
self.assertRaises(NotImplementedException, lambda: instance.processIncomingPacket(x,x))
self.assertRaises(NotImplementedException, lambda: instance.buildPacket(x))
def testModbusSlaveContextInterface(self):
''' Test that the base class isn't implemented '''
x = None
instance = IModbusSlaveContext()
self.assertRaises(NotImplementedException, instance.reset)
self.assertRaises(NotImplementedException, lambda: instance.validate(x,x,x))
self.assertRaises(NotImplementedException, lambda: instance.getValues(x,x,x))
self.assertRaises(NotImplementedException, lambda: instance.setValues(x,x,x))
def testModbusPayloadBuilderInterface(self):
''' Test that the base class isn't implemented '''
x = None
instance = IPayloadBuilder()
self.assertRaises(NotImplementedException, lambda: instance.build())
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_mei_messages.py 0000664 0000000 0000000 00000015306 13355134677 0020430 0 ustar 00root root 0000000 0000000 '''
MEI Message Test Fixture
--------------------------------
This fixture tests the functionality of all the
mei based request/response messages:
'''
import unittest
from pymodbus.mei_message import *
from pymodbus.constants import DeviceInformation, MoreData
from pymodbus.pdu import ModbusExceptions
from pymodbus.device import ModbusControlBlock
#---------------------------------------------------------------------------#
# Fixture
#---------------------------------------------------------------------------#
class ModbusMeiMessageTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.mei_message module
'''
#-----------------------------------------------------------------------#
# Read Device Information
#-----------------------------------------------------------------------#
def testReadDeviceInformationRequestEncode(self):
''' Test basic bit message encoding/decoding '''
params = {'read_code':DeviceInformation.Basic, 'object_id':0x00 }
handle = ReadDeviceInformationRequest(**params)
result = handle.encode()
self.assertEqual(result, b'\x0e\x01\x00')
self.assertEqual("ReadDeviceInformationRequest(1,0)", str(handle))
def testReadDeviceInformationRequestDecode(self):
''' Test basic bit message encoding/decoding '''
handle = ReadDeviceInformationRequest()
handle.decode(b'\x0e\x01\x00')
self.assertEqual(handle.read_code, DeviceInformation.Basic)
self.assertEqual(handle.object_id, 0x00)
def testReadDeviceInformationRequest(self):
''' Test basic bit message encoding/decoding '''
context = None
control = ModbusControlBlock()
control.Identity.VendorName = "Company"
control.Identity.ProductCode = "Product"
control.Identity.MajorMinorRevision = "v2.1.12"
control.Identity.update({0x81: ['Test', 'Repeated']})
handle = ReadDeviceInformationRequest()
result = handle.execute(context)
self.assertTrue(isinstance(result, ReadDeviceInformationResponse))
self.assertEqual(result.information[0x00], "Company")
self.assertEqual(result.information[0x01], "Product")
self.assertEqual(result.information[0x02], "v2.1.12")
with self.assertRaises(KeyError):
_ = result.information[0x81]
handle = ReadDeviceInformationRequest(read_code=DeviceInformation.Extended,
object_id=0x80)
result = handle.execute(context)
self.assertEqual(result.information[0x81], ['Test', 'Repeated'])
def testReadDeviceInformationRequestError(self):
''' Test basic bit message encoding/decoding '''
handle = ReadDeviceInformationRequest()
handle.read_code = -1
self.assertEqual(handle.execute(None).function_code, 0xab)
handle.read_code = 0x05
self.assertEqual(handle.execute(None).function_code, 0xab)
handle.object_id = -1
self.assertEqual(handle.execute(None).function_code, 0xab)
handle.object_id = 0x100
self.assertEqual(handle.execute(None).function_code, 0xab)
def testReadDeviceInformationResponseEncode(self):
''' Test that the read fifo queue response can encode '''
message = b'\x0e\x01\x83\x00\x00\x03'
message += b'\x00\x07Company\x01\x07Product\x02\x07v2.1.12'
dataset = {
0x00: 'Company',
0x01: 'Product',
0x02: 'v2.1.12',
}
handle = ReadDeviceInformationResponse(
read_code=DeviceInformation.Basic, information=dataset)
result = handle.encode()
self.assertEqual(result, message)
self.assertEqual("ReadDeviceInformationResponse(1)", str(handle))
dataset = {
0x00: 'Company',
0x01: 'Product',
0x02: 'v2.1.12',
0x81: ['Test', 'Repeated']
}
message = b'\x0e\x03\x83\x00\x00\x05'
message += b'\x00\x07Company\x01\x07Product\x02\x07v2.1.12'
message += b'\x81\x04Test\x81\x08Repeated'
handle = ReadDeviceInformationResponse(
read_code=DeviceInformation.Extended, information=dataset)
result = handle.encode()
self.assertEqual(result, message)
def testReadDeviceInformationResponseEncodeLong(self):
''' Test that the read fifo queue response can encode '''
longstring = "Lorem ipsum dolor sit amet, consectetur adipiscing " \
"elit. Vivamus rhoncus massa turpis, sit amet ultrices" \
" orci semper ut. Aliquam tristique sapien in lacus " \
"pharetra, in convallis nunc consectetur. Nunc velit " \
"elit, vehicula tempus tempus sed. "
message = b'\x0e\x01\x83\xFF\x80\x03'
message += b'\x00\x07Company\x01\x07Product\x02\x07v2.1.12'
dataset = {
0x00: 'Company',
0x01: 'Product',
0x02: 'v2.1.12',
0x80: longstring
}
handle = ReadDeviceInformationResponse(
read_code=DeviceInformation.Basic, information=dataset)
result = handle.encode()
self.assertEqual(result, message)
self.assertEqual("ReadDeviceInformationResponse(1)", str(handle))
def testReadDeviceInformationResponseDecode(self):
''' Test that the read device information response can decode '''
message = b'\x0e\x01\x01\x00\x00\x05'
message += b'\x00\x07Company\x01\x07Product\x02\x07v2.1.12'
message += b'\x81\x04Test\x81\x08Repeated\x81\x07Another'
handle = ReadDeviceInformationResponse(read_code=0x00, information=[])
handle.decode(message)
self.assertEqual(handle.read_code, DeviceInformation.Basic)
self.assertEqual(handle.conformity, 0x01)
self.assertEqual(handle.information[0x00], b'Company')
self.assertEqual(handle.information[0x01], b'Product')
self.assertEqual(handle.information[0x02], b'v2.1.12')
self.assertEqual(handle.information[0x81], [b'Test', b'Repeated', b'Another'])
def testRtuFrameSize(self):
''' Test that the read device information response can decode '''
message = b'\x04\x2B\x0E\x01\x81\x00\x01\x01\x00\x06\x66\x6F\x6F\x62\x61\x72\xD7\x3B'
result = ReadDeviceInformationResponse.calculateRtuFrameSize(message)
self.assertEqual(result, 18)
message = b'\x00\x2B\x0E\x02\x00\x4D\x47'
result = ReadDeviceInformationRequest.calculateRtuFrameSize(message)
self.assertEqual(result, 7)
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_other_messages.py 0000664 0000000 0000000 00000007673 13355134677 0021007 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.other_message import *
class ModbusOtherMessageTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.other_message module
'''
def setUp(self):
self.requests = [
ReadExceptionStatusRequest,
GetCommEventCounterRequest,
GetCommEventLogRequest,
ReportSlaveIdRequest,
]
self.responses = [
lambda: ReadExceptionStatusResponse(0x12),
lambda: GetCommEventCounterResponse(0x12),
GetCommEventLogResponse,
lambda: ReportSlaveIdResponse(0x12),
]
def tearDown(self):
''' Cleans up the test environment '''
del self.requests
del self.responses
def testOtherMessagesToString(self):
for message in self.requests:
self.assertNotEqual(str(message()), None)
for message in self.responses:
self.assertNotEqual(str(message()), None)
def testReadExceptionStatus(self):
request = ReadExceptionStatusRequest()
request.decode(b'\x12')
self.assertEqual(request.encode(), b'')
self.assertEqual(request.execute().function_code, 0x07)
response = ReadExceptionStatusResponse(0x12)
self.assertEqual(response.encode(), b'\x12')
response.decode(b'\x12')
self.assertEqual(response.status, 0x12)
def testGetCommEventCounter(self):
request = GetCommEventCounterRequest()
request.decode(b'\x12')
self.assertEqual(request.encode(), b'')
self.assertEqual(request.execute().function_code, 0x0b)
response = GetCommEventCounterResponse(0x12)
self.assertEqual(response.encode(), b'\x00\x00\x00\x12')
response.decode(b'\x00\x00\x00\x12')
self.assertEqual(response.status, True)
self.assertEqual(response.count, 0x12)
response.status = False
self.assertEqual(response.encode(), b'\xFF\xFF\x00\x12')
def testGetCommEventLog(self):
request = GetCommEventLogRequest()
request.decode(b'\x12')
self.assertEqual(request.encode(), b'')
self.assertEqual(request.execute().function_code, 0x0c)
response = GetCommEventLogResponse()
self.assertEqual(response.encode(), b'\x06\x00\x00\x00\x00\x00\x00')
response.decode(b'\x06\x00\x00\x00\x12\x00\x12')
self.assertEqual(response.status, True)
self.assertEqual(response.message_count, 0x12)
self.assertEqual(response.event_count, 0x12)
self.assertEqual(response.events, [])
response.status = False
self.assertEqual(response.encode(), b'\x06\xff\xff\x00\x12\x00\x12')
def testGetCommEventLogWithEvents(self):
response = GetCommEventLogResponse(events=[0x12,0x34,0x56])
self.assertEqual(response.encode(), b'\x09\x00\x00\x00\x00\x00\x00\x12\x34\x56')
response.decode(b'\x09\x00\x00\x00\x12\x00\x12\x12\x34\x56')
self.assertEqual(response.status, True)
self.assertEqual(response.message_count, 0x12)
self.assertEqual(response.event_count, 0x12)
self.assertEqual(response.events, [0x12,0x34,0x56])
def testReportSlaveId(self):
request = ReportSlaveIdRequest()
request.decode(b'\x12')
self.assertEqual(request.encode(), b'')
self.assertEqual(request.execute().function_code, 0x11)
response = ReportSlaveIdResponse(request.execute().identifier, True)
self.assertEqual(response.encode(), b'\tPymodbus\xff')
response.decode(b'\x03\x12\x00')
self.assertEqual(response.status, False)
self.assertEqual(response.identifier, b'\x12\x00')
response.status = False
self.assertEqual(response.encode(), b'\x03\x12\x00\x00')
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_payload.py 0000664 0000000 0000000 00000022111 13355134677 0017410 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
"""
Payload Utilities Test Fixture
--------------------------------
This fixture tests the functionality of the payload
utilities.
* PayloadBuilder
* PayloadDecoder
"""
import unittest
from pymodbus.exceptions import ParameterException
from pymodbus.constants import Endian
from pymodbus.payload import BinaryPayloadBuilder, BinaryPayloadDecoder
#---------------------------------------------------------------------------#
# Fixture
#---------------------------------------------------------------------------#
class ModbusPayloadUtilityTests(unittest.TestCase):
# ----------------------------------------------------------------------- #
# Setup/TearDown
# ----------------------------------------------------------------------- #
def setUp(self):
"""
Initializes the test environment and builds request/result
encoding pairs
"""
self.little_endian_payload = \
b'\x01\x02\x00\x03\x00\x00\x00\x04\x00\x00\x00\x00' \
b'\x00\x00\x00\xff\xfe\xff\xfd\xff\xff\xff\xfc\xff' \
b'\xff\xff\xff\xff\xff\xff\x00\x00\xa0\x3f\x00\x00' \
b'\x00\x00\x00\x00\x19\x40\x01\x00\x74\x65\x73\x74' \
b'\x11'
self.big_endian_payload = \
b'\x01\x00\x02\x00\x00\x00\x03\x00\x00\x00\x00\x00' \
b'\x00\x00\x04\xff\xff\xfe\xff\xff\xff\xfd\xff\xff' \
b'\xff\xff\xff\xff\xff\xfc\x3f\xa0\x00\x00\x40\x19' \
b'\x00\x00\x00\x00\x00\x00\x00\x01\x74\x65\x73\x74' \
b'\x11'
self.bitstring = [True, False, False, False, True, False, False, False]
def tearDown(self):
""" Cleans up the test environment """
pass
# ----------------------------------------------------------------------- #
# Payload Builder Tests
# ----------------------------------------------------------------------- #
def testLittleEndianPayloadBuilder(self):
""" Test basic bit message encoding/decoding """
builder = BinaryPayloadBuilder(byteorder=Endian.Little,
wordorder=Endian.Little)
builder.add_8bit_uint(1)
builder.add_16bit_uint(2)
builder.add_32bit_uint(3)
builder.add_64bit_uint(4)
builder.add_8bit_int(-1)
builder.add_16bit_int(-2)
builder.add_32bit_int(-3)
builder.add_64bit_int(-4)
builder.add_32bit_float(1.25)
builder.add_64bit_float(6.25)
builder.add_16bit_uint(1) # placeholder
builder.add_string(b'test')
builder.add_bits(self.bitstring)
self.assertEqual(self.little_endian_payload, builder.to_string())
def testBigEndianPayloadBuilder(self):
""" Test basic bit message encoding/decoding """
builder = BinaryPayloadBuilder(byteorder=Endian.Big)
builder.add_8bit_uint(1)
builder.add_16bit_uint(2)
builder.add_32bit_uint(3)
builder.add_64bit_uint(4)
builder.add_8bit_int(-1)
builder.add_16bit_int(-2)
builder.add_32bit_int(-3)
builder.add_64bit_int(-4)
builder.add_32bit_float(1.25)
builder.add_64bit_float(6.25)
builder.add_16bit_uint(1) # placeholder
builder.add_string('test')
builder.add_bits(self.bitstring)
self.assertEqual(self.big_endian_payload, builder.to_string())
def testPayloadBuilderReset(self):
""" Test basic bit message encoding/decoding """
builder = BinaryPayloadBuilder()
builder.add_8bit_uint(0x12)
builder.add_8bit_uint(0x34)
builder.add_8bit_uint(0x56)
builder.add_8bit_uint(0x78)
self.assertEqual(b'\x12\x34\x56\x78', builder.to_string())
self.assertEqual([b'\x12\x34', b'\x56\x78'], builder.build())
builder.reset()
self.assertEqual(b'', builder.to_string())
self.assertEqual([], builder.build())
def testPayloadBuilderWithRawPayload(self):
""" Test basic bit message encoding/decoding """
_coils1 = [False, True, True, True, True, False, False, False, False,
True, False, True, False, True, True, False]
_coils2 = [False, True, False, True, False, True, True, False,
False, True, True, True, True, False, False, False]
builder = BinaryPayloadBuilder([b'\x12', b'\x34', b'\x56', b'\x78'],
repack=True)
self.assertEqual(b'\x12\x34\x56\x78', builder.to_string())
self.assertEqual([13330, 30806], builder.to_registers())
self.assertEqual(_coils1, builder.to_coils())
builder = BinaryPayloadBuilder([b'\x12', b'\x34', b'\x56', b'\x78'],
byteorder=Endian.Big)
self.assertEqual(b'\x12\x34\x56\x78', builder.to_string())
self.assertEqual([4660, 22136], builder.to_registers())
self.assertEqual('\x12\x34\x56\x78', str(builder))
self.assertEqual(_coils2, builder.to_coils())
# ----------------------------------------------------------------------- #
# Payload Decoder Tests
# ----------------------------------------------------------------------- #
def testLittleEndianPayloadDecoder(self):
""" Test basic bit message encoding/decoding """
decoder = BinaryPayloadDecoder(self.little_endian_payload,
byteorder=Endian.Little,
wordorder=Endian.Little)
self.assertEqual(1, decoder.decode_8bit_uint())
self.assertEqual(2, decoder.decode_16bit_uint())
self.assertEqual(3, decoder.decode_32bit_uint())
self.assertEqual(4, decoder.decode_64bit_uint())
self.assertEqual(-1, decoder.decode_8bit_int())
self.assertEqual(-2, decoder.decode_16bit_int())
self.assertEqual(-3, decoder.decode_32bit_int())
self.assertEqual(-4, decoder.decode_64bit_int())
self.assertEqual(1.25, decoder.decode_32bit_float())
self.assertEqual(6.25, decoder.decode_64bit_float())
self.assertEqual(None, decoder.skip_bytes(2))
self.assertEqual('test', decoder.decode_string(4).decode())
self.assertEqual(self.bitstring, decoder.decode_bits())
def testBigEndianPayloadDecoder(self):
""" Test basic bit message encoding/decoding """
decoder = BinaryPayloadDecoder(self.big_endian_payload,
byteorder=Endian.Big)
self.assertEqual(1, decoder.decode_8bit_uint())
self.assertEqual(2, decoder.decode_16bit_uint())
self.assertEqual(3, decoder.decode_32bit_uint())
self.assertEqual(4, decoder.decode_64bit_uint())
self.assertEqual(-1, decoder.decode_8bit_int())
self.assertEqual(-2, decoder.decode_16bit_int())
self.assertEqual(-3, decoder.decode_32bit_int())
self.assertEqual(-4, decoder.decode_64bit_int())
self.assertEqual(1.25, decoder.decode_32bit_float())
self.assertEqual(6.25, decoder.decode_64bit_float())
self.assertEqual(None, decoder.skip_bytes(2))
self.assertEqual(b'test', decoder.decode_string(4))
self.assertEqual(self.bitstring, decoder.decode_bits())
def testPayloadDecoderReset(self):
""" Test the payload decoder reset functionality """
decoder = BinaryPayloadDecoder(b'\x12\x34')
self.assertEqual(0x12, decoder.decode_8bit_uint())
self.assertEqual(0x34, decoder.decode_8bit_uint())
decoder.reset()
self.assertEqual(0x3412, decoder.decode_16bit_uint())
def testPayloadDecoderRegisterFactory(self):
""" Test the payload decoder reset functionality """
payload = [1, 2, 3, 4]
decoder = BinaryPayloadDecoder.fromRegisters(payload, byteorder=Endian.Little)
encoded = b'\x00\x01\x00\x02\x00\x03\x00\x04'
self.assertEqual(encoded, decoder.decode_string(8))
decoder = BinaryPayloadDecoder.fromRegisters(payload, byteorder=Endian.Big)
encoded = b'\x00\x01\x00\x02\x00\x03\x00\x04'
self.assertEqual(encoded, decoder.decode_string(8))
self.assertRaises(ParameterException,
lambda: BinaryPayloadDecoder.fromRegisters('abcd'))
def testPayloadDecoderCoilFactory(self):
""" Test the payload decoder reset functionality """
payload = [1,0,0,0, 1,0,0,0, 0,0,0,1, 0,0,0,1]
decoder = BinaryPayloadDecoder.fromCoils(payload, byteorder=Endian.Little)
encoded = b'\x11\x88'
self.assertEqual(encoded, decoder.decode_string(2))
decoder = BinaryPayloadDecoder.fromCoils(payload, byteorder=Endian.Big)
encoded = b'\x11\x88'
self.assertEqual(encoded, decoder.decode_string(2))
self.assertRaises(ParameterException,
lambda: BinaryPayloadDecoder.fromCoils('abcd'))
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_pdu.py 0000664 0000000 0000000 00000006006 13355134677 0016554 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.pdu import *
from pymodbus.exceptions import *
from pymodbus.compat import iteritems
class SimplePduTest(unittest.TestCase):
'''
This is the unittest for the pymod.pdu module
'''
def setUp(self):
''' Initializes the test environment '''
self.badRequests = (
# ModbusPDU(),
ModbusRequest(),
ModbusResponse(),
)
self.illegal = IllegalFunctionRequest(1)
self.exception = ExceptionResponse(1,1)
def tearDown(self):
''' Cleans up the test environment '''
del self.badRequests
del self.illegal
del self.exception
def testNotImpelmented(self):
''' Test a base classes for not implemented funtions '''
for r in self.badRequests:
self.assertRaises(NotImplementedException, r.encode)
for r in self.badRequests:
self.assertRaises(NotImplementedException, r.decode, None)
def testErrorMethods(self):
''' Test all error methods '''
self.illegal.decode("12345")
self.illegal.execute(None)
result = self.exception.encode()
self.exception.decode(result)
self.assertEqual(result, b'\x01')
self.assertEqual(self.exception.exception_code, 1)
def testRequestExceptionFactory(self):
''' Test all error methods '''
request = ModbusRequest()
request.function_code = 1
errors = dict((ModbusExceptions.decode(c), c) for c in range(1,20))
for error, code in iteritems(errors):
result = request.doException(code)
self.assertEqual(str(result), "Exception Response(129, 1, %s)" % error)
def testCalculateRtuFrameSize(self):
''' Test the calculation of Modbus/RTU frame sizes '''
self.assertRaises(NotImplementedException,
ModbusRequest.calculateRtuFrameSize, b'')
ModbusRequest._rtu_frame_size = 5
self.assertEqual(ModbusRequest.calculateRtuFrameSize(b''), 5)
del ModbusRequest._rtu_frame_size
ModbusRequest._rtu_byte_count_pos = 2
self.assertEqual(ModbusRequest.calculateRtuFrameSize(
b'\x11\x01\x05\xcd\x6b\xb2\x0e\x1b\x45\xe6'), 0x05 + 5)
del ModbusRequest._rtu_byte_count_pos
self.assertRaises(NotImplementedException,
ModbusResponse.calculateRtuFrameSize, b'')
ModbusResponse._rtu_frame_size = 12
self.assertEqual(ModbusResponse.calculateRtuFrameSize(b''), 12)
del ModbusResponse._rtu_frame_size
ModbusResponse._rtu_byte_count_pos = 2
self.assertEqual(ModbusResponse.calculateRtuFrameSize(
b'\x11\x01\x05\xcd\x6b\xb2\x0e\x1b\x45\xe6'), 0x05 + 5)
del ModbusResponse._rtu_byte_count_pos
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_ptwisted.py 0000664 0000000 0000000 00000001476 13355134677 0017635 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
#---------------------------------------------------------------------------#
# Fixture
#---------------------------------------------------------------------------#
class TwistedInternalCodeTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.internal.ptwisted code
'''
#-----------------------------------------------------------------------#
# Setup/TearDown
#-----------------------------------------------------------------------#
def testInstallConch(self):
''' Test that we can install the conch backend '''
pass
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_register_read_messages.py 0000664 0000000 0000000 00000016153 13355134677 0022476 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.register_read_message import *
from pymodbus.register_read_message import ReadRegistersRequestBase
from pymodbus.register_read_message import ReadRegistersResponseBase
from pymodbus.exceptions import *
from pymodbus.pdu import ModbusExceptions
from pymodbus.compat import iteritems, iterkeys, get_next
from .modbus_mocks import MockContext, FakeList
#---------------------------------------------------------------------------#
# Fixture
#---------------------------------------------------------------------------#
class ReadRegisterMessagesTest(unittest.TestCase):
'''
Register Message Test Fixture
--------------------------------
This fixture tests the functionality of all the
register based request/response messages:
* Read/Write Input Registers
* Read Holding Registers
'''
def setUp(self):
'''
Initializes the test environment and builds request/result
encoding pairs
'''
arguments = {
'read_address': 1, 'read_count': 5,
'write_address': 1, 'write_registers': [0x00]*5,
}
self.value = 0xabcd
self.values = [0xa, 0xb, 0xc]
self.request_read = {
ReadRegistersRequestBase(1, 5) :b'\x00\x01\x00\x05',
ReadHoldingRegistersRequest(1, 5) :b'\x00\x01\x00\x05',
ReadInputRegistersRequest(1,5) :b'\x00\x01\x00\x05',
ReadWriteMultipleRegistersRequest(**arguments) :b'\x00\x01\x00\x05\x00\x01\x00'
b'\x05\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00',
}
self.response_read = {
ReadRegistersResponseBase(self.values) :b'\x06\x00\x0a\x00\x0b\x00\x0c',
ReadHoldingRegistersResponse(self.values) :b'\x06\x00\x0a\x00\x0b\x00\x0c',
ReadInputRegistersResponse(self.values) :b'\x06\x00\x0a\x00\x0b\x00\x0c',
ReadWriteMultipleRegistersResponse(self.values) :b'\x06\x00\x0a\x00\x0b\x00\x0c',
}
def tearDown(self):
''' Cleans up the test environment '''
del self.request_read
del self.response_read
def testReadRegisterResponseBase(self):
response = ReadRegistersResponseBase(list(range(10)))
for index in range(10):
self.assertEqual(response.getRegister(index), index)
def testRegisterReadRequests(self):
for request, response in iteritems(self.request_read):
self.assertEqual(request.encode(), response)
def testRegisterReadResponses(self):
for request, response in iteritems(self.response_read):
self.assertEqual(request.encode(), response)
def testRegisterReadResponseDecode(self):
registers = [
[0x0a,0x0b,0x0c],
[0x0a,0x0b,0x0c],
[0x0a,0x0b,0x0c],
[0x0a,0x0b,0x0c, 0x0a,0x0b,0x0c],
]
values = sorted(self.response_read.items(), key=lambda x: str(x))
for packet, register in zip(values, registers):
request, response = packet
request.decode(response)
self.assertEqual(request.registers, register)
def testRegisterReadRequestsCountErrors(self):
'''
This tests that the register request messages
will break on counts that are out of range
'''
mock = FakeList(0x800)
requests = [
ReadHoldingRegistersRequest(1, 0x800),
ReadInputRegistersRequest(1,0x800),
ReadWriteMultipleRegistersRequest(read_address=1,
read_count=0x800, write_address=1, write_registers=5),
ReadWriteMultipleRegistersRequest(read_address=1,
read_count=5, write_address=1, write_registers=mock),
]
for request in requests:
result = request.execute(None)
self.assertEqual(ModbusExceptions.IllegalValue,
result.exception_code)
def testRegisterReadRequestsValidateErrors(self):
'''
This tests that the register request messages
will break on counts that are out of range
'''
context = MockContext()
requests = [
ReadHoldingRegistersRequest(-1, 5),
ReadInputRegistersRequest(-1,5),
#ReadWriteMultipleRegistersRequest(-1,5,1,5),
#ReadWriteMultipleRegistersRequest(1,5,-1,5),
]
for request in requests:
result = request.execute(context)
self.assertEqual(ModbusExceptions.IllegalAddress,
result.exception_code)
def testRegisterReadRequestsExecute(self):
'''
This tests that the register request messages
will break on counts that are out of range
'''
context = MockContext(True)
requests = [
ReadHoldingRegistersRequest(-1, 5),
ReadInputRegistersRequest(-1,5),
]
for request in requests:
response = request.execute(context)
self.assertEqual(request.function_code, response.function_code)
def testReadWriteMultipleRegistersRequest(self):
context = MockContext(True)
request = ReadWriteMultipleRegistersRequest(read_address=1,
read_count=10, write_address=1, write_registers=[0x00])
response = request.execute(context)
self.assertEqual(request.function_code, response.function_code)
def testReadWriteMultipleRegistersValidate(self):
context = MockContext()
context.validate = lambda f,a,c: a == 1
request = ReadWriteMultipleRegistersRequest(read_address=1,
read_count=10, write_address=2, write_registers=[0x00])
response = request.execute(context)
self.assertEqual(response.exception_code, ModbusExceptions.IllegalAddress)
context.validate = lambda f,a,c: a == 2
response = request.execute(context)
self.assertEqual(response.exception_code, ModbusExceptions.IllegalAddress)
request.write_byte_count = 0x100
response = request.execute(context)
self.assertEqual(response.exception_code, ModbusExceptions.IllegalValue)
def testReadWriteMultipleRegistersRequestDecode(self):
request, response = get_next((k,v) for k,v in self.request_read.items()
if getattr(k, 'function_code', 0) == 23)
request.decode(response)
self.assertEqual(request.read_address, 0x01)
self.assertEqual(request.write_address, 0x01)
self.assertEqual(request.read_count, 0x05)
self.assertEqual(request.write_count, 0x05)
self.assertEqual(request.write_byte_count, 0x0a)
self.assertEqual(request.write_registers, [0x00]*5)
def testSerializingToString(self):
for request in iterkeys(self.request_read):
self.assertTrue(str(request) != None)
for request in iterkeys(self.response_read):
self.assertTrue(str(request) != None)
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_register_write_messages.py 0000664 0000000 0000000 00000015706 13355134677 0022720 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.register_write_message import *
from pymodbus.exceptions import ParameterException
from pymodbus.pdu import ModbusExceptions
from pymodbus.compat import iteritems, iterkeys
from pymodbus.payload import BinaryPayloadBuilder
from pymodbus.payload import Endian
from .modbus_mocks import MockContext
#---------------------------------------------------------------------------#
# Fixture
#---------------------------------------------------------------------------#
class WriteRegisterMessagesTest(unittest.TestCase):
'''
Register Message Test Fixture
--------------------------------
This fixture tests the functionality of all the
register based request/response messages:
* Read/Write Input Registers
* Read Holding Registers
'''
def setUp(self):
'''
Initializes the test environment and builds request/result
encoding pairs
'''
self.value = 0xabcd
self.values = [0xa, 0xb, 0xc]
builder = BinaryPayloadBuilder(byteorder=Endian.Big)
builder.add_16bit_uint(0x1234)
self.payload = builder.build()
self.write = {
WriteSingleRegisterRequest(1, self.value) : b'\x00\x01\xab\xcd',
WriteSingleRegisterResponse(1, self.value) : b'\x00\x01\xab\xcd',
WriteMultipleRegistersRequest(1, self.values) : b'\x00\x01\x00\x03\x06\x00\n\x00\x0b\x00\x0c',
WriteMultipleRegistersResponse(1, 5) : b'\x00\x01\x00\x05',
WriteSingleRegisterRequest(1, self.payload[0], skip_encode=True): b'\x00\x01\x12\x34',
WriteMultipleRegistersRequest(1, self.payload, skip_encode=True): b'\x00\x01\x00\x01\x02\x12\x34',
}
def tearDown(self):
''' Cleans up the test environment '''
del self.write
def testRegisterWriteRequestsEncode(self):
for request, response in iteritems(self.write):
self.assertEqual(request.encode(), response)
def testRegisterWriteRequestsDecode(self):
addresses = [1,1,1,1]
values = sorted(self.write.items(), key=lambda x: str(x))
for packet, address in zip(values, addresses):
request, response = packet
request.decode(response)
self.assertEqual(request.address, address)
def testInvalidWriteMultipleRegistersRequest(self):
request = WriteMultipleRegistersRequest(0, None)
self.assertEqual(request.values, [])
def testSerializingToString(self):
for request in iterkeys(self.write):
self.assertTrue(str(request) != None)
def testWriteSingleRegisterRequest(self):
context = MockContext()
request = WriteSingleRegisterRequest(0x00, 0xf0000)
result = request.execute(context)
self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)
request.value = 0x00ff
result = request.execute(context)
self.assertEqual(result.exception_code, ModbusExceptions.IllegalAddress)
context.valid = True
result = request.execute(context)
self.assertEqual(result.function_code, request.function_code)
def testWriteMultipleRegisterRequest(self):
context = MockContext()
request = WriteMultipleRegistersRequest(0x00, [0x00]*10)
result = request.execute(context)
self.assertEqual(result.exception_code, ModbusExceptions.IllegalAddress)
request.count = 0x05 # bytecode != code * 2
result = request.execute(context)
self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)
request.count = 0x800 # outside of range
result = request.execute(context)
self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)
context.valid = True
request = WriteMultipleRegistersRequest(0x00, [0x00]*10)
result = request.execute(context)
self.assertEqual(result.function_code, request.function_code)
# -----------------------------------------------------------------------#
# Mask Write Register Request
# -----------------------------------------------------------------------#
def testMaskWriteRegisterRequestEncode(self):
''' Test basic bit message encoding/decoding '''
handle = MaskWriteRegisterRequest(0x0000, 0x0101, 0x1010)
result = handle.encode()
self.assertEqual(result, b'\x00\x00\x01\x01\x10\x10')
def testMaskWriteRegisterRequestDecode(self):
''' Test basic bit message encoding/decoding '''
request = b'\x00\x04\x00\xf2\x00\x25'
handle = MaskWriteRegisterRequest()
handle.decode(request)
self.assertEqual(handle.address, 0x0004)
self.assertEqual(handle.and_mask, 0x00f2)
self.assertEqual(handle.or_mask, 0x0025)
def testMaskWriteRegisterRequestExecute(self):
''' Test write register request valid execution '''
context = MockContext(valid=True, default=0x0000)
handle = MaskWriteRegisterRequest(0x0000, 0x0101, 0x1010)
result = handle.execute(context)
self.assertTrue(isinstance(result, MaskWriteRegisterResponse))
def testMaskWriteRegisterRequestInvalidExecute(self):
''' Test write register request execute with invalid data '''
context = MockContext(valid=False, default=0x0000)
handle = MaskWriteRegisterRequest(0x0000, -1, 0x1010)
result = handle.execute(context)
self.assertEqual(ModbusExceptions.IllegalValue,
result.exception_code)
handle = MaskWriteRegisterRequest(0x0000, 0x0101, -1)
result = handle.execute(context)
self.assertEqual(ModbusExceptions.IllegalValue,
result.exception_code)
handle = MaskWriteRegisterRequest(0x0000, 0x0101, 0x1010)
result = handle.execute(context)
self.assertEqual(ModbusExceptions.IllegalAddress,
result.exception_code)
# -----------------------------------------------------------------------#
# Mask Write Register Response
# -----------------------------------------------------------------------#
def testMaskWriteRegisterResponseEncode(self):
''' Test basic bit message encoding/decoding '''
handle = MaskWriteRegisterResponse(0x0000, 0x0101, 0x1010)
result = handle.encode()
self.assertEqual(result, b'\x00\x00\x01\x01\x10\x10')
def testMaskWriteRegisterResponseDecode(self):
''' Test basic bit message encoding/decoding '''
request = b'\x00\x04\x00\xf2\x00\x25'
handle = MaskWriteRegisterResponse()
handle.decode(request)
self.assertEqual(handle.address, 0x0004)
self.assertEqual(handle.and_mask, 0x00f2)
self.assertEqual(handle.or_mask, 0x0025)
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_remote_datastore.py 0000664 0000000 0000000 00000005042 13355134677 0021324 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.exceptions import NotImplementedException
from pymodbus.datastore.remote import RemoteSlaveContext
from pymodbus.bit_read_message import *
from pymodbus.bit_write_message import *
from pymodbus.register_read_message import *
from pymodbus.pdu import ExceptionResponse
from .modbus_mocks import mock
class RemoteModbusDataStoreTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.datastore.remote module
'''
def testRemoteSlaveContext(self):
''' Test a modbus remote slave context '''
context = RemoteSlaveContext(None)
self.assertNotEqual(str(context), None)
self.assertRaises(NotImplementedException, lambda: context.reset())
def testRemoteSlaveSetValues(self):
''' Test setting values against a remote slave context '''
client = mock()
client.write_coils = lambda a,b: WriteMultipleCoilsResponse()
context = RemoteSlaveContext(client)
result = context.setValues(1, 0, [1])
self.assertTrue(True)
def testRemoteSlaveGetValues(self):
''' Test getting values from a remote slave context '''
client = mock()
client.read_coils = lambda a,b: ReadCoilsResponse([1]*10)
client.read_input_registers = lambda a,b: ReadInputRegistersResponse([10]*10)
client.read_holding_registers = lambda a,b: ExceptionResponse(0x15)
context = RemoteSlaveContext(client)
result = context.getValues(1, 0, 10)
self.assertEqual(result, [1]*10)
result = context.getValues(4, 0, 10)
self.assertEqual(result, [10]*10)
result = context.getValues(3, 0, 10)
self.assertNotEqual(result, [10]*10)
def testRemoteSlaveValidateValues(self):
''' Test validating against a remote slave context '''
client = mock()
client.read_coils = lambda a,b: ReadCoilsResponse([1]*10)
client.read_input_registers = lambda a,b: ReadInputRegistersResponse([10]*10)
client.read_holding_registers = lambda a,b: ExceptionResponse(0x15)
context = RemoteSlaveContext(client)
result = context.validate(1, 0, 10)
self.assertTrue(result)
result = context.validate(4, 0, 10)
self.assertTrue(result)
result = context.validate(3, 0, 10)
self.assertFalse(result)
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_server_async.py 0000664 0000000 0000000 00000026626 13355134677 0020501 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
from pymodbus.compat import IS_PYTHON3
import unittest
if IS_PYTHON3: # Python 3
from unittest.mock import patch, Mock, MagicMock
else: # Python 2
from mock import patch, Mock, MagicMock
from pymodbus.device import ModbusDeviceIdentification
from pymodbus.server.async import ModbusTcpProtocol, ModbusUdpProtocol
from pymodbus.server.async import ModbusServerFactory
from pymodbus.server.async import (
StartTcpServer, StartUdpServer, StartSerialServer, StopServer,
_is_main_thread
)
from pymodbus.compat import byte2int
from pymodbus.transaction import ModbusSocketFramer
from pymodbus.exceptions import NoSuchSlaveException, ModbusIOException
import sys
#---------------------------------------------------------------------------#
# Fixture
#---------------------------------------------------------------------------#
import platform
from distutils.version import LooseVersion
IS_DARWIN = platform.system().lower() == "darwin"
OSX_SIERRA = LooseVersion("10.12")
if IS_DARWIN:
IS_HIGH_SIERRA_OR_ABOVE = LooseVersion(platform.mac_ver()[0])
SERIAL_PORT = '/dev/ptyp0' if not IS_HIGH_SIERRA_OR_ABOVE else '/dev/ttyp0'
else:
IS_HIGH_SIERRA_OR_ABOVE = False
SERIAL_PORT = "/dev/ptmx"
class AsynchronousServerTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.server.async module
'''
#-----------------------------------------------------------------------#
# Setup/TearDown
#-----------------------------------------------------------------------#
def setUp(self):
'''
Initializes the test environment
'''
values = dict((i, '') for i in range(10))
identity = ModbusDeviceIdentification(info=values)
def tearDown(self):
''' Cleans up the test environment '''
pass
#-----------------------------------------------------------------------#
# Test ModbusTcpProtocol
#-----------------------------------------------------------------------#
def testTcpServerStartup(self):
''' Test that the modbus tcp async server starts correctly '''
with patch('twisted.internet.reactor') as mock_reactor:
if IS_PYTHON3:
console = False
call_count = 1
else:
console = True
call_count = 2
StartTcpServer(context=None, console=console)
self.assertEqual(mock_reactor.listenTCP.call_count, call_count)
self.assertEqual(mock_reactor.run.call_count, 1)
def testConnectionMade(self):
protocol = ModbusTcpProtocol()
protocol.transport = MagicMock()
protocol.factory = MagicMock()
protocol.factory.framer = ModbusSocketFramer
protocol.connectionMade()
self.assertIsInstance(protocol.framer, ModbusSocketFramer)
def testConnectionLost(self):
protocol = ModbusTcpProtocol()
protocol.connectionLost("What ever reason")
def testDataReceived(self):
protocol = ModbusTcpProtocol()
# mock_data = "Hellow world!"
mock_data = b"\x00\x01\x12\x34\x00\x04\xff\x02\x12\x34"
protocol.factory = MagicMock()
protocol.factory.control.ListenOnly = False
protocol.factory.store.slaves = MagicMock()
protocol.factory.store.single = True
protocol.factory.store.slaves.return_value = [byte2int(mock_data[6])]
protocol.framer = protocol._execute = MagicMock()
protocol.dataReceived(mock_data)
self.assertTrue(protocol.framer.processIncomingPacket.called)
# test datareceived returns None
protocol.factory.control.ListenOnly = False
self.assertEqual(protocol.dataReceived(mock_data), None)
def testTcpExecuteSuccess(self):
protocol = ModbusTcpProtocol()
protocol.store = MagicMock()
request = MagicMock()
protocol._send = MagicMock()
# tst if _send being called
protocol._execute(request)
self.assertTrue(protocol._send.called)
def testTcpExecuteFailure(self):
protocol = ModbusTcpProtocol()
protocol.factory = MagicMock()
protocol.factory.store = MagicMock()
protocol.store = MagicMock()
protocol.factory.ignore_missing_slaves = False
request = MagicMock()
protocol._send = MagicMock()
# CASE-1: test NoSuchSlaveException exceptions
request.execute.side_effect = NoSuchSlaveException()
self.assertRaises(
NoSuchSlaveException, protocol._execute(request)
)
self.assertTrue(request.doException.called)
# CASE-2: NoSuchSlaveException with ignore_missing_slaves = true
protocol.ignore_missing_slaves = True
request.execute.side_effect = NoSuchSlaveException()
self.assertEqual(protocol._execute(request), None)
# test other exceptions
request.execute.side_effect = ModbusIOException()
self.assertRaises(
ModbusIOException, protocol._execute(request)
)
self.assertTrue(protocol._send.called)
def testSendTcp(self):
class MockMsg(object):
def __init__(self, msg, resp=False):
self.should_respond = resp
self.msg = msg
mock_msg = b"\x00\x01\x12\x34\x00\x04\xff\x02\x12\x34"
protocol = ModbusTcpProtocol()
mock_data = MockMsg(resp=True, msg=mock_msg)
protocol.control = MagicMock()
protocol.framer = MagicMock()
protocol.factory = MagicMock()
protocol.framer.buildPacket = MagicMock(return_value=mock_msg)
protocol.transport= MagicMock()
protocol._send(mock_data)
self.assertTrue(protocol.framer.buildPacket.called)
self.assertTrue(protocol.transport.write.called)
mock_data =MockMsg(resp=False, msg="helloworld")
self.assertEqual(protocol._send(mock_data), None)
#-----------------------------------------------------------------------#
# Test ModbusServerFactory
#-----------------------------------------------------------------------#
def testModbusServerFactory(self):
''' Test the base class for all the clients '''
factory = ModbusServerFactory(store=None)
self.assertEqual(factory.control.Identity.VendorName, '')
identity = ModbusDeviceIdentification(info={0x00: 'VendorName'})
factory = ModbusServerFactory(store=None, identity=identity)
self.assertEqual(factory.control.Identity.VendorName, 'VendorName')
#-----------------------------------------------------------------------#
# Test ModbusUdpProtocol
#-----------------------------------------------------------------------#
def testUdpServerInitialize(self):
protocol = ModbusUdpProtocol(store=None)
self.assertEqual(protocol.control.Identity.VendorName, '')
identity = ModbusDeviceIdentification(info={0x00: 'VendorName'})
protocol = ModbusUdpProtocol(store=None, identity=identity)
self.assertEqual(protocol.control.Identity.VendorName, 'VendorName')
def testUdpServerStartup(self):
''' Test that the modbus udp async server starts correctly '''
with patch('twisted.internet.reactor') as mock_reactor:
StartUdpServer(context=None)
self.assertEqual(mock_reactor.listenUDP.call_count, 1)
self.assertEqual(mock_reactor.run.call_count, 1)
@patch("twisted.internet.serialport.SerialPort")
def testSerialServerStartup(self, mock_sp):
''' Test that the modbus serial async server starts correctly '''
with patch('twisted.internet.reactor') as mock_reactor:
StartSerialServer(context=None, port=SERIAL_PORT)
self.assertEqual(mock_reactor.run.call_count, 1)
@patch("twisted.internet.serialport.SerialPort")
def testStopServerFromMainThread(self, mock_sp):
"""
Stop async server
:return:
"""
with patch('twisted.internet.reactor') as mock_reactor:
StartSerialServer(context=None, port=SERIAL_PORT)
self.assertEqual(mock_reactor.run.call_count, 1)
StopServer()
self.assertEqual(mock_reactor.stop.call_count, 1)
@patch("twisted.internet.serialport.SerialPort")
def testStopServerFromThread(self, mock_sp):
"""
Stop async server from child thread
:return:
"""
from threading import Thread
import time
with patch('twisted.internet.reactor') as mock_reactor:
StartSerialServer(context=None, port=SERIAL_PORT)
self.assertEqual(mock_reactor.run.call_count, 1)
t = Thread(target=StopServer)
t.start()
time.sleep(2)
self.assertEqual(mock_reactor.callFromThread.call_count, 1)
def testDatagramReceived(self):
mock_data = b"\x00\x01\x12\x34\x00\x04\xff\x02\x12\x34"
mock_addr = 0x01
protocol = ModbusUdpProtocol(store=None)
protocol.framer.processIncomingPacket = MagicMock()
protocol.control.ListenOnly = False
protocol._execute = MagicMock()
protocol.datagramReceived(mock_data, mock_addr)
self.assertTrue(protocol.framer.processIncomingPacket.called)
def testSendUdp(self):
protocol = ModbusUdpProtocol(store=None)
mock_data = b"\x00\x01\x12\x34\x00\x04\xff\x02\x12\x34"
mock_addr = 0x01
protocol.control = MagicMock()
protocol.framer = MagicMock()
protocol.framer.buildPacket = MagicMock(return_value=mock_data)
protocol.transport= MagicMock()
protocol._send(mock_data, mock_addr)
self.assertTrue(protocol.framer.buildPacket.called)
self.assertTrue(protocol.transport.write.called)
def testUdpExecuteSuccess(self):
protocol = ModbusUdpProtocol(store=None)
mock_addr = 0x01
protocol.store = MagicMock()
request = MagicMock()
protocol._send = MagicMock()
# tst if _send being called
protocol._execute(request, mock_addr)
self.assertTrue(protocol._send.called)
def testUdpExecuteFailure(self):
protocol = ModbusUdpProtocol(store=None)
mock_addr = 0x01
protocol.store = MagicMock()
request = MagicMock()
protocol._send = MagicMock()
# CASE-1: test NoSuchSlaveException exceptions
request.execute.side_effect = NoSuchSlaveException()
self.assertRaises(
NoSuchSlaveException, protocol._execute(request, mock_addr)
)
self.assertTrue(request.doException.called)
# CASE-2: NoSuchSlaveException with ignore_missing_slaves = true
protocol.ignore_missing_slaves = True
request.execute.side_effect = NoSuchSlaveException()
self.assertEqual(protocol._execute(request, mock_addr), None)
# test other exceptions
request.execute.side_effect = ModbusIOException()
self.assertRaises(
ModbusIOException, protocol._execute(request, mock_addr)
)
self.assertTrue(protocol._send.called)
def testStopServer(self):
from twisted.internet import reactor
reactor.stop = MagicMock()
StopServer()
self.assertTrue(reactor.stop.called)
def testIsMainThread(self):
import threading
self.assertTrue(_is_main_thread())
# --------------------------------------------------------------------------- #
# Main
# --------------------------------------------------------------------------- #
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_server_context.py 0000664 0000000 0000000 00000007026 13355134677 0021041 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.datastore import *
from pymodbus.exceptions import NoSuchSlaveException
from pymodbus.compat import iteritems
class ModbusServerSingleContextTest(unittest.TestCase):
''' This is the unittest for the pymodbus.datastore.ModbusServerContext
using a single slave context.
'''
def setUp(self):
''' Sets up the test environment '''
self.slave = ModbusSlaveContext()
self.context = ModbusServerContext(slaves=self.slave, single=True)
def tearDown(self):
''' Cleans up the test environment '''
del self.context
def testSingleContextGets(self):
''' Test getting on a single context '''
for id in range(0, 0xff):
self.assertEqual(self.slave, self.context[id])
def testSingleContextDeletes(self):
''' Test removing on multiple context '''
def _test():
del self.context[0x00]
self.assertRaises(NoSuchSlaveException, _test)
def testSingleContextIter(self):
''' Test iterating over a single context '''
expected = (0, self.slave)
for slave in self.context:
self.assertEqual(slave, expected)
def testSingleContextDefault(self):
''' Test that the single context default values work '''
self.context = ModbusServerContext()
slave = self.context[0x00]
self.assertEqual(slave, {})
def testSingleContextSet(self):
''' Test a setting a single slave context '''
slave = ModbusSlaveContext()
self.context[0x00] = slave
actual = self.context[0x00]
self.assertEqual(slave, actual)
class ModbusServerMultipleContextTest(unittest.TestCase):
''' This is the unittest for the pymodbus.datastore.ModbusServerContext
using multiple slave contexts.
'''
def setUp(self):
''' Sets up the test environment '''
self.slaves = dict((id, ModbusSlaveContext()) for id in range(10))
self.context = ModbusServerContext(slaves=self.slaves, single=False)
def tearDown(self):
''' Cleans up the test environment '''
del self.context
def testMultipleContextGets(self):
''' Test getting on multiple context '''
for id in range(0, 10):
self.assertEqual(self.slaves[id], self.context[id])
def testMultipleContextDeletes(self):
''' Test removing on multiple context '''
del self.context[0x00]
self.assertRaises(NoSuchSlaveException, lambda: self.context[0x00])
def testMultipleContextIter(self):
''' Test iterating over multiple context '''
for id, slave in self.context:
self.assertEqual(slave, self.slaves[id])
self.assertTrue(id in self.context)
def testMultipleContextDefault(self):
''' Test that the multiple context default values work '''
self.context = ModbusServerContext(single=False)
self.assertRaises(NoSuchSlaveException, lambda: self.context[0x00])
def testMultipleContextSet(self):
''' Test a setting multiple slave contexts '''
slaves = dict((id, ModbusSlaveContext()) for id in range(10))
for id, slave in iteritems(slaves):
self.context[id] = slave
for id, slave in iteritems(slaves):
actual = self.context[id]
self.assertEqual(slave, actual)
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_server_sync.py 0000664 0000000 0000000 00000040201 13355134677 0020321 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
from pymodbus.compat import IS_PYTHON3
import unittest
if IS_PYTHON3: # Python 3
from unittest.mock import patch, Mock
else: # Python 2
from mock import patch, Mock
import serial
import socket
from pymodbus.device import ModbusDeviceIdentification
from pymodbus.server.sync import ModbusBaseRequestHandler
from pymodbus.server.sync import ModbusSingleRequestHandler
from pymodbus.server.sync import ModbusConnectedRequestHandler
from pymodbus.server.sync import ModbusDisconnectedRequestHandler
from pymodbus.server.sync import ModbusTcpServer, ModbusUdpServer, ModbusSerialServer
from pymodbus.server.sync import StartTcpServer, StartUdpServer, StartSerialServer
from pymodbus.exceptions import NotImplementedException
from pymodbus.bit_read_message import ReadCoilsRequest, ReadCoilsResponse
from pymodbus.datastore import ModbusServerContext
from pymodbus.compat import socketserver
import platform
from distutils.version import LooseVersion
IS_DARWIN = platform.system().lower() == "darwin"
OSX_SIERRA = LooseVersion("10.12")
if IS_DARWIN:
IS_HIGH_SIERRA_OR_ABOVE = LooseVersion(platform.mac_ver()[0])
SERIAL_PORT = '/dev/ptyp0' if not IS_HIGH_SIERRA_OR_ABOVE else '/dev/ttyp0'
else:
IS_HIGH_SIERRA_OR_ABOVE = False
SERIAL_PORT = "/dev/ptmx"
#---------------------------------------------------------------------------#
# Mock Classes
#---------------------------------------------------------------------------#
class MockServer(object):
def __init__(self):
self.framer = lambda _, client=None: "framer"
self.decoder = "decoder"
self.threads = []
self.context = {}
#---------------------------------------------------------------------------#
# Fixture
#---------------------------------------------------------------------------#
class SynchronousServerTest(unittest.TestCase):
'''
This is the unittest for the pymodbus.server.sync module
'''
#-----------------------------------------------------------------------#
# Test Base Request Handler
#-----------------------------------------------------------------------#
def testBaseHandlerUndefinedMethods(self):
''' Test the base handler undefined methods'''
handler = socketserver.BaseRequestHandler(None, None, None)
handler.__class__ = ModbusBaseRequestHandler
self.assertRaises(NotImplementedException, lambda: handler.send(None))
self.assertRaises(NotImplementedException, lambda: handler.handle())
def testBaseHandlerMethods(self):
''' Test the base class for all the clients '''
request = ReadCoilsRequest(1, 1)
address = ('server', 12345)
server = MockServer()
with patch.object(ModbusBaseRequestHandler, 'handle') as mock_handle:
with patch.object(ModbusBaseRequestHandler, 'send') as mock_send:
mock_handle.return_value = True
mock_send.return_value = True
handler = ModbusBaseRequestHandler(request, address, server)
self.assertEqual(handler.running, True)
self.assertEqual(handler.framer, 'framer')
handler.execute(request)
self.assertEqual(mock_send.call_count, 1)
server.context[0x00] = object()
handler.execute(request)
self.assertEqual(mock_send.call_count, 2)
#-----------------------------------------------------------------------#
# Test Single Request Handler
#-----------------------------------------------------------------------#
def testModbusSingleRequestHandlerSend(self):
handler = socketserver.BaseRequestHandler(None, None, None)
handler.__class__ = ModbusSingleRequestHandler
handler.framer = Mock()
handler.framer.buildPacket.return_value = b"message"
handler.request = Mock()
request = ReadCoilsResponse([1])
handler.send(request)
self.assertEqual(handler.request.send.call_count, 1)
request.should_respond = False
handler.send(request)
self.assertEqual(handler.request.send.call_count, 1)
def testModbusSingleRequestHandlerHandle(self):
handler = socketserver.BaseRequestHandler(None, None, None)
handler.__class__ = ModbusSingleRequestHandler
handler.framer = Mock()
handler.framer.buildPacket.return_value = b"message"
handler.request = Mock()
handler.socket = Mock()
handler.server = Mock()
handler.request.recv.return_value = b"\x12\x34"
# exit if we are not running
handler.running = False
handler.handle()
self.assertEqual(handler.framer.processIncomingPacket.call_count, 0)
# run forever if we are running
def _callback1(a, b, *args, **kwargs):
handler.running = False # stop infinite loop
handler.framer.processIncomingPacket.side_effect = _callback1
handler.running = True
# Ugly hack
handler.server.context = ModbusServerContext(slaves={-1: None},
single=False)
handler.handle()
self.assertEqual(handler.framer.processIncomingPacket.call_count, 1)
# exceptions are simply ignored
def _callback2(a, b, *args, **kwargs):
if handler.framer.processIncomingPacket.call_count == 2:
raise Exception("example exception")
else: handler.running = False # stop infinite loop
handler.framer.processIncomingPacket.side_effect = _callback2
handler.running = True
handler.handle()
self.assertEqual(handler.framer.processIncomingPacket.call_count, 3)
#-----------------------------------------------------------------------#
# Test Connected Request Handler
#-----------------------------------------------------------------------#
def testModbusConnectedRequestHandlerSend(self):
handler = socketserver.BaseRequestHandler(None, None, None)
handler.__class__ = ModbusConnectedRequestHandler
handler.framer = Mock()
handler.framer.buildPacket.return_value = b"message"
handler.request = Mock()
request = ReadCoilsResponse([1])
handler.send(request)
self.assertEqual(handler.request.send.call_count, 1)
request.should_respond = False
handler.send(request)
self.assertEqual(handler.request.send.call_count, 1)
def testModbusConnectedRequestHandlerHandle(self):
handler = socketserver.BaseRequestHandler(None, None, None)
handler.__class__ = ModbusConnectedRequestHandler
handler.server = Mock()
# handler.server.context.slaves = Mock()
# protocol.factory.store.single = True
handler.framer = Mock()
handler.framer.buildPacket.return_value = b"message"
handler.request = Mock()
handler.request.recv.return_value = b"\x12\x34"
# exit if we are not running
handler.running = False
handler.handle()
self.assertEqual(handler.framer.processIncomingPacket.call_count, 0)
# run forever if we are running
def _callback(a, b, *args, **kwargs):
handler.running = False # stop infinite loop
handler.framer.processIncomingPacket.side_effect = _callback
handler.running = True
handler.handle()
self.assertEqual(handler.framer.processIncomingPacket.call_count, 1)
# socket errors cause the client to disconnect
handler.framer.processIncomingPacket.side_effect = socket.error()
handler.running = True
handler.handle()
self.assertEqual(handler.framer.processIncomingPacket.call_count, 2)
# every other exception causes the client to disconnect
handler.framer.processIncomingPacket.side_effect = Exception()
handler.running = True
handler.handle()
self.assertEqual(handler.framer.processIncomingPacket.call_count, 3)
# receiving no data causes the client to disconnect
handler.request.recv.return_value = None
handler.running = True
handler.handle()
self.assertEqual(handler.framer.processIncomingPacket.call_count, 4)
#-----------------------------------------------------------------------#
# Test Disconnected Request Handler
#-----------------------------------------------------------------------#
def testModbusDisconnectedRequestHandlerSend(self):
handler = socketserver.BaseRequestHandler(None, None, None)
handler.__class__ = ModbusDisconnectedRequestHandler
handler.framer = Mock()
handler.server = Mock()
handler.framer.buildPacket.return_value = b"message"
handler.request = Mock()
handler.socket = Mock()
request = ReadCoilsResponse([1])
handler.send(request)
self.assertEqual(handler.socket.sendto.call_count, 1)
request.should_respond = False
handler.send(request)
self.assertEqual(handler.socket.sendto.call_count, 1)
def testModbusDisconnectedRequestHandlerHandle(self):
handler = socketserver.BaseRequestHandler(None, None, None)
handler.__class__ = ModbusDisconnectedRequestHandler
handler.framer = Mock()
handler.server = Mock()
handler.framer.buildPacket.return_value = b"message"
handler.request = (b"\x12\x34", handler.request)
# exit if we are not running
handler.running = False
handler.handle()
self.assertEqual(handler.framer.processIncomingPacket.call_count, 0)
# run forever if we are running
def _callback(a, b):
handler.running = False # stop infinite loop
handler.framer.processIncomingPacket.side_effect = _callback
handler.running = True
handler.handle()
self.assertEqual(handler.framer.processIncomingPacket.call_count, 1)
# socket errors cause the client to disconnect
handler.request = (b"\x12\x34", handler.request)
handler.framer.processIncomingPacket.side_effect = socket.error()
handler.running = True
handler.handle()
self.assertEqual(handler.framer.processIncomingPacket.call_count, 2)
# every other exception causes the client to disconnect
handler.request = (b"\x12\x34", handler.request)
handler.framer.processIncomingPacket.side_effect = Exception()
handler.running = True
handler.handle()
self.assertEqual(handler.framer.processIncomingPacket.call_count, 3)
# receiving no data causes the client to disconnect
handler.request = (None, handler.request)
handler.running = True
handler.handle()
self.assertEqual(handler.framer.processIncomingPacket.call_count, 4)
#-----------------------------------------------------------------------#
# Test TCP Server
#-----------------------------------------------------------------------#
def testTcpServerClose(self):
''' test that the synchronous TCP server closes correctly '''
with patch.object(socket.socket, 'bind') as mock_socket:
identity = ModbusDeviceIdentification(info={0x00: 'VendorName'})
server = ModbusTcpServer(context=None, identity=identity)
server.threads.append(Mock(**{'running': True}))
server.server_close()
self.assertEqual(server.control.Identity.VendorName, 'VendorName')
self.assertFalse(server.threads[0].running)
def testTcpServerProcess(self):
''' test that the synchronous TCP server processes requests '''
with patch('pymodbus.compat.socketserver.ThreadingTCPServer') as mock_server:
server = ModbusTcpServer(None)
server.process_request('request', 'client')
self.assertTrue(mock_server.process_request.called)
#-----------------------------------------------------------------------#
# Test UDP Server
#-----------------------------------------------------------------------#
def testUdpServerClose(self):
''' test that the synchronous UDP server closes correctly '''
with patch.object(socket.socket, 'bind') as mock_socket:
identity = ModbusDeviceIdentification(info={0x00: 'VendorName'})
server = ModbusUdpServer(context=None, identity=identity)
server.threads.append(Mock(**{'running': True}))
server.server_close()
self.assertEqual(server.control.Identity.VendorName, 'VendorName')
self.assertFalse(server.threads[0].running)
def testUdpServerProcess(self):
''' test that the synchronous UDP server processes requests '''
with patch('pymodbus.compat.socketserver.ThreadingUDPServer') as mock_server:
server = ModbusUdpServer(None)
request = ('data', 'socket')
server.process_request(request, 'client')
self.assertTrue(mock_server.process_request.called)
#-----------------------------------------------------------------------#
# Test Serial Server
#-----------------------------------------------------------------------#
def testSerialServerConnect(self):
with patch.object(serial, 'Serial') as mock_serial:
# mock_serial.return_value = "socket"
mock_serial.write = lambda x: len(x)
mock_serial.read = lambda size: '\x00' * size
identity = ModbusDeviceIdentification(info={0x00: 'VendorName'})
server = ModbusSerialServer(context=None, identity=identity, port="dummy")
# # mock_serial.return_value = "socket"
# self.assertEqual(server.socket.port, "dummy")
self.assertEquals(server.handler.__class__.__name__, "CustomSingleRequestHandler")
self.assertEqual(server.control.Identity.VendorName, 'VendorName')
server._connect()
# self.assertEqual(server.socket, "socket")
with patch.object(serial, 'Serial') as mock_serial:
mock_serial.write = lambda x: len(x)
mock_serial.read = lambda size: '\x00' * size
mock_serial.side_effect = serial.SerialException()
server = ModbusSerialServer(None, port="dummy")
self.assertEqual(server.socket, None)
def testSerialServerServeForever(self):
''' test that the synchronous serial server closes correctly '''
with patch.object(serial, 'Serial') as mock_serial:
with patch('pymodbus.server.sync.CustomSingleRequestHandler') as mock_handler:
server = ModbusSerialServer(None)
instance = mock_handler.return_value
instance.handle.side_effect = server.server_close
server.serve_forever()
instance.handle.assert_any_call()
def testSerialServerClose(self):
''' test that the synchronous serial server closes correctly '''
with patch.object(serial, 'Serial') as mock_serial:
instance = mock_serial.return_value
server = ModbusSerialServer(None)
server.server_close()
instance.close.assert_any_call()
#-----------------------------------------------------------------------#
# Test Synchronous Factories
#-----------------------------------------------------------------------#
def testStartTcpServer(self):
''' Test the tcp server starting factory '''
with patch.object(ModbusTcpServer, 'serve_forever') as mock_server:
with patch.object(socketserver.TCPServer, 'server_bind') as mock_binder:
StartTcpServer()
def testStartUdpServer(self):
''' Test the udp server starting factory '''
with patch.object(ModbusUdpServer, 'serve_forever') as mock_server:
with patch.object(socketserver.UDPServer, 'server_bind') as mock_binder:
StartUdpServer()
def testStartSerialServer(self):
''' Test the serial server starting factory '''
with patch.object(ModbusSerialServer, 'serve_forever') as mock_server:
StartSerialServer(port=SERIAL_PORT)
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_transaction.py 0000664 0000000 0000000 00000054435 13355134677 0020322 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import pytest
import unittest
from binascii import a2b_hex
from pymodbus.pdu import *
from pymodbus.transaction import *
from pymodbus.transaction import (
ModbusTransactionManager, ModbusSocketFramer, ModbusAsciiFramer,
ModbusRtuFramer, ModbusBinaryFramer
)
from pymodbus.factory import ServerDecoder
from pymodbus.compat import byte2int
from mock import MagicMock
from pymodbus.exceptions import (
NotImplementedException, ModbusIOException, InvalidMessageReceivedException
)
class ModbusTransactionTest(unittest.TestCase):
"""
This is the unittest for the pymodbus.transaction module
"""
# ----------------------------------------------------------------------- #
# Test Construction
# ----------------------------------------------------------------------- #
def setUp(self):
""" Sets up the test environment """
self.client = None
self.decoder = ServerDecoder()
self._tcp = ModbusSocketFramer(decoder=self.decoder, client=None)
self._rtu = ModbusRtuFramer(decoder=self.decoder, client=None)
self._ascii = ModbusAsciiFramer(decoder=self.decoder, client=None)
self._binary = ModbusBinaryFramer(decoder=self.decoder, client=None)
self._manager = DictTransactionManager(self.client)
self._queue_manager = FifoTransactionManager(self.client)
self._tm = ModbusTransactionManager(self.client)
def tearDown(self):
""" Cleans up the test environment """
del self._manager
del self._tcp
del self._rtu
del self._ascii
# ----------------------------------------------------------------------- #
# Base transaction manager
# ----------------------------------------------------------------------- #
def testCalculateExpectedResponseLength(self):
self._tm.client = MagicMock()
self._tm.client.framer = MagicMock()
self._tm._set_adu_size()
self.assertEqual(self._tm._calculate_response_length(0), None)
self._tm.base_adu_size = 10
self.assertEqual(self._tm._calculate_response_length(5), 15)
def testCalculateExceptionLength(self):
for framer, exception_length in [('ascii', 11),
('binary', 7),
('rtu', 5),
('tcp', 9),
('dummy', None)]:
self._tm.client = MagicMock()
if framer == "ascii":
self._tm.client.framer = self._ascii
elif framer == "binary":
self._tm.client.framer = self._binary
elif framer == "rtu":
self._tm.client.framer = self._rtu
elif framer == "tcp":
self._tm.client.framer = self._tcp
else:
self._tm.client.framer = MagicMock()
self._tm._set_adu_size()
self.assertEqual(self._tm._calculate_exception_length(),
exception_length)
def testExecute(self):
client = MagicMock()
client.framer = self._ascii
client.framer._buffer = b'deadbeef'
client.framer.processIncomingPacket = MagicMock()
client.framer.processIncomingPacket.return_value = None
client.framer.buildPacket = MagicMock()
client.framer.buildPacket.return_value = b'deadbeef'
client.framer.sendPacket = MagicMock()
client.framer.sendPacket.return_value = len(b'deadbeef')
request = MagicMock()
request.get_response_pdu_size.return_value = 10
request.unit_id = 1
tm = ModbusTransactionManager(client)
tm._recv = MagicMock(return_value=b'abcdef')
self.assertEqual(tm.retries, 3)
self.assertEqual(tm.retry_on_empty, False)
# tm._transact = MagicMock()
# some response
# tm._transact.return_value = (b'abcdef', None)
tm.getTransaction = MagicMock()
tm.getTransaction.return_value = 'response'
response = tm.execute(request)
self.assertEqual(response, 'response')
# No response
tm._recv = MagicMock(return_value=b'abcdef')
# tm._transact.return_value = (b'', None)
tm.transactions = []
tm.getTransaction = MagicMock()
tm.getTransaction.return_value = None
response = tm.execute(request)
self.assertIsInstance(response, ModbusIOException)
# No response with retries
tm.retry_on_empty = True
tm._recv = MagicMock(side_effect=iter([b'', b'abcdef']))
# tm._transact.side_effect = [(b'', None), (b'abcdef', None)]
response = tm.execute(request)
self.assertIsInstance(response, ModbusIOException)
# Unable to decode response
tm._recv = MagicMock(side_effect=ModbusIOException())
# tm._transact.side_effect = [(b'abcdef', None)]
client.framer.processIncomingPacket.side_effect = MagicMock(side_effect=ModbusIOException())
self.assertIsInstance(tm.execute(request), ModbusIOException)
# ----------------------------------------------------------------------- #
# Dictionary based transaction manager
# ----------------------------------------------------------------------- #
def testDictTransactionManagerTID(self):
""" Test the dict transaction manager TID """
for tid in range(1, self._manager.getNextTID() + 10):
self.assertEqual(tid+1, self._manager.getNextTID())
self._manager.reset()
self.assertEqual(1, self._manager.getNextTID())
def testGetDictTransactionManagerTransaction(self):
""" Test the dict transaction manager """
class Request: pass
self._manager.reset()
handle = Request()
handle.transaction_id = self._manager.getNextTID()
handle.message = b"testing"
self._manager.addTransaction(handle)
result = self._manager.getTransaction(handle.transaction_id)
self.assertEqual(handle.message, result.message)
def testDeleteDictTransactionManagerTransaction(self):
""" Test the dict transaction manager """
class Request: pass
self._manager.reset()
handle = Request()
handle.transaction_id = self._manager.getNextTID()
handle.message = b"testing"
self._manager.addTransaction(handle)
self._manager.delTransaction(handle.transaction_id)
self.assertEqual(None, self._manager.getTransaction(handle.transaction_id))
# ----------------------------------------------------------------------- #
# Queue based transaction manager
# ----------------------------------------------------------------------- #
def testFifoTransactionManagerTID(self):
""" Test the fifo transaction manager TID """
for tid in range(1, self._queue_manager.getNextTID() + 10):
self.assertEqual(tid+1, self._queue_manager.getNextTID())
self._queue_manager.reset()
self.assertEqual(1, self._queue_manager.getNextTID())
def testGetFifoTransactionManagerTransaction(self):
""" Test the fifo transaction manager """
class Request: pass
self._queue_manager.reset()
handle = Request()
handle.transaction_id = self._queue_manager.getNextTID()
handle.message = b"testing"
self._queue_manager.addTransaction(handle)
result = self._queue_manager.getTransaction(handle.transaction_id)
self.assertEqual(handle.message, result.message)
def testDeleteFifoTransactionManagerTransaction(self):
""" Test the fifo transaction manager """
class Request: pass
self._queue_manager.reset()
handle = Request()
handle.transaction_id = self._queue_manager.getNextTID()
handle.message = b"testing"
self._queue_manager.addTransaction(handle)
self._queue_manager.delTransaction(handle.transaction_id)
self.assertEqual(None, self._queue_manager.getTransaction(handle.transaction_id))
# ----------------------------------------------------------------------- #
# TCP tests
# ----------------------------------------------------------------------- #
def testTCPFramerTransactionReady(self):
""" Test a tcp frame transaction """
msg = b"\x00\x01\x12\x34\x00\x04\xff\x02\x12\x34"
self.assertFalse(self._tcp.isFrameReady())
self.assertFalse(self._tcp.checkFrame())
self._tcp.addToFrame(msg)
self.assertTrue(self._tcp.isFrameReady())
self.assertTrue(self._tcp.checkFrame())
self._tcp.advanceFrame()
self.assertFalse(self._tcp.isFrameReady())
self.assertFalse(self._tcp.checkFrame())
self.assertEqual(b'', self._ascii.getFrame())
def testTCPFramerTransactionFull(self):
""" Test a full tcp frame transaction """
msg = b"\x00\x01\x12\x34\x00\x04\xff\x02\x12\x34"
self._tcp.addToFrame(msg)
self.assertTrue(self._tcp.checkFrame())
result = self._tcp.getFrame()
self.assertEqual(msg[7:], result)
self._tcp.advanceFrame()
def testTCPFramerTransactionHalf(self):
""" Test a half completed tcp frame transaction """
msg1 = b"\x00\x01\x12\x34\x00"
msg2 = b"\x04\xff\x02\x12\x34"
self._tcp.addToFrame(msg1)
self.assertFalse(self._tcp.checkFrame())
result = self._tcp.getFrame()
self.assertEqual(b'', result)
self._tcp.addToFrame(msg2)
self.assertTrue(self._tcp.checkFrame())
result = self._tcp.getFrame()
self.assertEqual(msg2[2:], result)
self._tcp.advanceFrame()
def testTCPFramerTransactionHalf2(self):
""" Test a half completed tcp frame transaction """
msg1 = b"\x00\x01\x12\x34\x00\x04\xff"
msg2 = b"\x02\x12\x34"
self._tcp.addToFrame(msg1)
self.assertFalse(self._tcp.checkFrame())
result = self._tcp.getFrame()
self.assertEqual(b'', result)
self._tcp.addToFrame(msg2)
self.assertTrue(self._tcp.checkFrame())
result = self._tcp.getFrame()
self.assertEqual(msg2, result)
self._tcp.advanceFrame()
def testTCPFramerTransactionHalf3(self):
""" Test a half completed tcp frame transaction """
msg1 = b"\x00\x01\x12\x34\x00\x04\xff\x02\x12"
msg2 = b"\x34"
self._tcp.addToFrame(msg1)
self.assertFalse(self._tcp.checkFrame())
result = self._tcp.getFrame()
self.assertEqual(msg1[7:], result)
self._tcp.addToFrame(msg2)
self.assertTrue(self._tcp.checkFrame())
result = self._tcp.getFrame()
self.assertEqual(msg1[7:] + msg2, result)
self._tcp.advanceFrame()
def testTCPFramerTransactionShort(self):
""" Test that we can get back on track after an invalid message """
msg1 = b"\x99\x99\x99\x99\x00\x01\x00\x01"
msg2 = b"\x00\x01\x12\x34\x00\x04\xff\x02\x12\x34"
self._tcp.addToFrame(msg1)
self.assertFalse(self._tcp.checkFrame())
result = self._tcp.getFrame()
self.assertEqual(b'', result)
self._tcp.advanceFrame()
self._tcp.addToFrame(msg2)
self.assertEqual(10, len(self._tcp._buffer))
self.assertTrue(self._tcp.checkFrame())
result = self._tcp.getFrame()
self.assertEqual(msg2[7:], result)
self._tcp.advanceFrame()
def testTCPFramerPopulate(self):
""" Test a tcp frame packet build """
expected = ModbusRequest()
expected.transaction_id = 0x0001
expected.protocol_id = 0x1234
expected.unit_id = 0xff
msg = b"\x00\x01\x12\x34\x00\x04\xff\x02\x12\x34"
self._tcp.addToFrame(msg)
self.assertTrue(self._tcp.checkFrame())
actual = ModbusRequest()
self._tcp.populateResult(actual)
for name in ['transaction_id', 'protocol_id', 'unit_id']:
self.assertEqual(getattr(expected, name), getattr(actual, name))
self._tcp.advanceFrame()
def testTCPFramerPacket(self):
""" Test a tcp frame packet build """
old_encode = ModbusRequest.encode
ModbusRequest.encode = lambda self: b''
message = ModbusRequest()
message.transaction_id = 0x0001
message.protocol_id = 0x1234
message.unit_id = 0xff
message.function_code = 0x01
expected = b"\x00\x01\x12\x34\x00\x02\xff\x01"
actual = self._tcp.buildPacket(message)
self.assertEqual(expected, actual)
ModbusRequest.encode = old_encode
# ----------------------------------------------------------------------- #
# RTU tests
# ----------------------------------------------------------------------- #
def testRTUFramerTransactionReady(self):
""" Test if the checks for a complete frame work """
self.assertFalse(self._rtu.isFrameReady())
msg_parts = [b"\x00\x01\x00", b"\x00\x00\x01\xfc\x1b"]
self._rtu.addToFrame(msg_parts[0])
self.assertTrue(self._rtu.isFrameReady())
self.assertFalse(self._rtu.checkFrame())
self._rtu.addToFrame(msg_parts[1])
self.assertTrue(self._rtu.isFrameReady())
self.assertTrue(self._rtu.checkFrame())
def testRTUFramerTransactionFull(self):
""" Test a full rtu frame transaction """
msg = b"\x00\x01\x00\x00\x00\x01\xfc\x1b"
stripped_msg = msg[1:-2]
self._rtu.addToFrame(msg)
self.assertTrue(self._rtu.checkFrame())
result = self._rtu.getFrame()
self.assertEqual(stripped_msg, result)
self._rtu.advanceFrame()
def testRTUFramerTransactionHalf(self):
""" Test a half completed rtu frame transaction """
msg_parts = [b"\x00\x01\x00", b"\x00\x00\x01\xfc\x1b"]
stripped_msg = b"".join(msg_parts)[1:-2]
self._rtu.addToFrame(msg_parts[0])
self.assertFalse(self._rtu.checkFrame())
self._rtu.addToFrame(msg_parts[1])
self.assertTrue(self._rtu.isFrameReady())
self.assertTrue(self._rtu.checkFrame())
result = self._rtu.getFrame()
self.assertEqual(stripped_msg, result)
self._rtu.advanceFrame()
def testRTUFramerPopulate(self):
""" Test a rtu frame packet build """
request = ModbusRequest()
msg = b"\x00\x01\x00\x00\x00\x01\xfc\x1b"
self._rtu.addToFrame(msg)
self._rtu.populateHeader()
self._rtu.populateResult(request)
header_dict = self._rtu._header
self.assertEqual(len(msg), header_dict['len'])
self.assertEqual(byte2int(msg[0]), header_dict['uid'])
self.assertEqual(msg[-2:], header_dict['crc'])
self.assertEqual(0x00, request.unit_id)
def testRTUFramerPacket(self):
""" Test a rtu frame packet build """
old_encode = ModbusRequest.encode
ModbusRequest.encode = lambda self: b''
message = ModbusRequest()
message.unit_id = 0xff
message.function_code = 0x01
expected = b"\xff\x01\x81\x80" # only header + CRC - no data
actual = self._rtu.buildPacket(message)
self.assertEqual(expected, actual)
ModbusRequest.encode = old_encode
def testRTUDecodeException(self):
""" Test that the RTU framer can decode errors """
message = b"\x00\x90\x02\x9c\x01"
actual = self._rtu.addToFrame(message)
result = self._rtu.checkFrame()
self.assertTrue(result)
def testProcess(self):
class MockResult(object):
def __init__(self, code):
self.function_code = code
def mock_callback(self):
pass
mock_result = MockResult(code=0)
self._rtu.getRawFrame = self._rtu.getFrame = MagicMock()
self._rtu.decoder = MagicMock()
self._rtu.decoder.decode = MagicMock(return_value=mock_result)
self._rtu.populateResult = MagicMock()
self._rtu.advanceFrame = MagicMock()
self._rtu._process(mock_callback)
self._rtu.populateResult.assert_called_with(mock_result)
self._rtu.advanceFrame.assert_called_with()
self.assertTrue(self._rtu.advanceFrame.called)
#Check errors
self._rtu.decoder.decode = MagicMock(return_value=None)
self.assertRaises(ModbusIOException, lambda: self._rtu._process(mock_callback))
def testRTUProcessIncomingPAkcets(self):
mock_data = b"\x00\x01\x00\x00\x00\x01\xfc\x1b"
unit = 0x00
def mock_callback(self):
pass
self._rtu.addToFrame = MagicMock()
self._rtu._process = MagicMock()
self._rtu.isFrameReady = MagicMock(return_value=False)
self._rtu._buffer = mock_data
self._rtu.processIncomingPacket(mock_data, mock_callback, unit)
# ----------------------------------------------------------------------- #
# ASCII tests
# ----------------------------------------------------------------------- #
def testASCIIFramerTransactionReady(self):
""" Test a ascii frame transaction """
msg = b':F7031389000A60\r\n'
self.assertFalse(self._ascii.isFrameReady())
self.assertFalse(self._ascii.checkFrame())
self._ascii.addToFrame(msg)
self.assertTrue(self._ascii.isFrameReady())
self.assertTrue(self._ascii.checkFrame())
self._ascii.advanceFrame()
self.assertFalse(self._ascii.isFrameReady())
self.assertFalse(self._ascii.checkFrame())
self.assertEqual(b'', self._ascii.getFrame())
def testASCIIFramerTransactionFull(self):
""" Test a full ascii frame transaction """
msg = b'sss:F7031389000A60\r\n'
pack = a2b_hex(msg[6:-4])
self._ascii.addToFrame(msg)
self.assertTrue(self._ascii.checkFrame())
result = self._ascii.getFrame()
self.assertEqual(pack, result)
self._ascii.advanceFrame()
def testASCIIFramerTransactionHalf(self):
""" Test a half completed ascii frame transaction """
msg1 = b'sss:F7031389'
msg2 = b'000A60\r\n'
pack = a2b_hex(msg1[6:] + msg2[:-4])
self._ascii.addToFrame(msg1)
self.assertFalse(self._ascii.checkFrame())
result = self._ascii.getFrame()
self.assertEqual(b'', result)
self._ascii.addToFrame(msg2)
self.assertTrue(self._ascii.checkFrame())
result = self._ascii.getFrame()
self.assertEqual(pack, result)
self._ascii.advanceFrame()
def testASCIIFramerPopulate(self):
""" Test a ascii frame packet build """
request = ModbusRequest()
self._ascii.populateResult(request)
self.assertEqual(0x00, request.unit_id)
def testASCIIFramerPacket(self):
""" Test a ascii frame packet build """
old_encode = ModbusRequest.encode
ModbusRequest.encode = lambda self: b''
message = ModbusRequest()
message.unit_id = 0xff
message.function_code = 0x01
expected = b":FF0100\r\n"
actual = self._ascii.buildPacket(message)
self.assertEqual(expected, actual)
ModbusRequest.encode = old_encode
def testAsciiProcessIncomingPakcets(self):
mock_data = msg = b':F7031389000A60\r\n'
unit = 0x00
def mock_callback(mock_data, *args, **kwargs):
pass
self._ascii.processIncomingPacket(mock_data, mock_callback, unit)
# Test failure:
self._ascii.checkFrame = MagicMock(return_value=False)
self._ascii.processIncomingPacket(mock_data, mock_callback, unit)
# ----------------------------------------------------------------------- #
# Binary tests
# ----------------------------------------------------------------------- #
def testBinaryFramerTransactionReady(self):
""" Test a binary frame transaction """
msg = b'\x7b\x01\x03\x00\x00\x00\x05\x85\xC9\x7d'
self.assertFalse(self._binary.isFrameReady())
self.assertFalse(self._binary.checkFrame())
self._binary.addToFrame(msg)
self.assertTrue(self._binary.isFrameReady())
self.assertTrue(self._binary.checkFrame())
self._binary.advanceFrame()
self.assertFalse(self._binary.isFrameReady())
self.assertFalse(self._binary.checkFrame())
self.assertEqual(b'', self._binary.getFrame())
def testBinaryFramerTransactionFull(self):
""" Test a full binary frame transaction """
msg = b'\x7b\x01\x03\x00\x00\x00\x05\x85\xC9\x7d'
pack = msg[2:-3]
self._binary.addToFrame(msg)
self.assertTrue(self._binary.checkFrame())
result = self._binary.getFrame()
self.assertEqual(pack, result)
self._binary.advanceFrame()
def testBinaryFramerTransactionHalf(self):
""" Test a half completed binary frame transaction """
msg1 = b'\x7b\x01\x03\x00'
msg2 = b'\x00\x00\x05\x85\xC9\x7d'
pack = msg1[2:] + msg2[:-3]
self._binary.addToFrame(msg1)
self.assertFalse(self._binary.checkFrame())
result = self._binary.getFrame()
self.assertEqual(b'', result)
self._binary.addToFrame(msg2)
self.assertTrue(self._binary.checkFrame())
result = self._binary.getFrame()
self.assertEqual(pack, result)
self._binary.advanceFrame()
def testBinaryFramerPopulate(self):
""" Test a binary frame packet build """
request = ModbusRequest()
self._binary.populateResult(request)
self.assertEqual(0x00, request.unit_id)
def testBinaryFramerPacket(self):
""" Test a binary frame packet build """
old_encode = ModbusRequest.encode
ModbusRequest.encode = lambda self: b''
message = ModbusRequest()
message.unit_id = 0xff
message.function_code = 0x01
expected = b'\x7b\xff\x01\x81\x80\x7d'
actual = self._binary.buildPacket(message)
self.assertEqual(expected, actual)
ModbusRequest.encode = old_encode
def testBinaryProcessIncomingPacket(self):
mock_data = b'\x7b\x01\x03\x00\x00\x00\x05\x85\xC9\x7d'
unit = 0x00
def mock_callback(mock_data):
pass
self._binary.processIncomingPacket(mock_data, mock_callback, unit)
# Test failure:
self._binary.checkFrame = MagicMock(return_value=False)
self._binary.processIncomingPacket(mock_data, mock_callback, unit)
# ----------------------------------------------------------------------- #
# Main
# ----------------------------------------------------------------------- #
if __name__ == "__main__":
pytest.main()
pymodbus-2.1.0/test/test_utilities.py 0000664 0000000 0000000 00000005734 13355134677 0020006 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
import struct
from pymodbus.utilities import pack_bitstring, unpack_bitstring
from pymodbus.utilities import checkCRC, checkLRC
from pymodbus.utilities import dict_property, default
_test_master = {4 : 'd'}
class DictPropertyTester(object):
def __init__(self):
self.test = {1 : 'a'}
self._test = {2 : 'b'}
self.__test = {3 : 'c'}
l1 = dict_property(lambda s: s.test, 1)
l2 = dict_property(lambda s: s._test, 2)
l3 = dict_property(lambda s: s.__test, 3)
s1 = dict_property('test', 1)
s2 = dict_property('_test', 2)
g1 = dict_property(_test_master, 4)
class SimpleUtilityTest(unittest.TestCase):
'''
This is the unittest for the pymod.utilities module
'''
def setUp(self):
''' Initializes the test environment '''
self.data = struct.pack('>HHHH', 0x1234, 0x2345, 0x3456, 0x4567)
self.string = b"test the computation"
self.bits = [True, False, True, False, True, False, True, False]
def tearDown(self):
''' Cleans up the test environment '''
del self.bits
del self.string
def testDictProperty(self):
''' Test all string <=> bit packing functions '''
d = DictPropertyTester()
self.assertEqual(d.l1, 'a')
self.assertEqual(d.l2, 'b')
self.assertEqual(d.l3, 'c')
self.assertEqual(d.s1, 'a')
self.assertEqual(d.s2, 'b')
self.assertEqual(d.g1, 'd')
for store in 'l1 l2 l3 s1 s2 g1'.split(' '):
setattr(d, store, 'x')
self.assertEqual(d.l1, 'x')
self.assertEqual(d.l2, 'x')
self.assertEqual(d.l3, 'x')
self.assertEqual(d.s1, 'x')
self.assertEqual(d.s2, 'x')
self.assertEqual(d.g1, 'x')
def testDefaultValue(self):
''' Test all string <=> bit packing functions '''
self.assertEqual(default(1), 0)
self.assertEqual(default(1.1), 0.0)
self.assertEqual(default(1+1j), 0j)
self.assertEqual(default('string'), '')
self.assertEqual(default([1,2,3]), [])
self.assertEqual(default({1:1}), {})
self.assertEqual(default(True), False)
def testBitPacking(self):
''' Test all string <=> bit packing functions '''
self.assertEqual(unpack_bitstring(b'\x55'), self.bits)
self.assertEqual(pack_bitstring(self.bits), b'\x55')
def testLongitudinalRedundancyCheck(self):
''' Test the longitudinal redundancy check code '''
self.assertTrue(checkLRC(self.data, 0x1c))
self.assertTrue(checkLRC(self.string, 0x0c))
def testCyclicRedundancyCheck(self):
''' Test the cyclic redundancy check code '''
self.assertTrue(checkCRC(self.data, 0xe2db))
self.assertTrue(checkCRC(self.string, 0x889e))
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/test/test_version.py 0000664 0000000 0000000 00000001464 13355134677 0017454 0 ustar 00root root 0000000 0000000 #!/usr/bin/env python
import unittest
from pymodbus.version import Version
class ModbusVersionTest(unittest.TestCase):
'''
This is the unittest for the pymodbus._version code
'''
def setUp(self):
''' Initializes the test environment '''
pass
def tearDown(self):
''' Cleans up the test environment '''
pass
def testVersionClass(self):
version = Version('test', 1,2,3, "sometag")
short = version.short()
self.assertEqual(version.short(), '1.2.3.sometag')
self.assertEqual(str(version), '[test, version 1.2.3.sometag]')
#---------------------------------------------------------------------------#
# Main
#---------------------------------------------------------------------------#
if __name__ == "__main__":
unittest.main()
pymodbus-2.1.0/tox.ini 0000664 0000000 0000000 00000000656 13355134677 0014714 0 ustar 00root root 0000000 0000000 # Tox (http://tox.testrun.org/) is a tool for running tests in multiple
# virtualenvs. This configuration file will run the test suite on all supported
# python versions. To use it, "pip install tox" and then run "tox" from this
# directory.
[tox]
envlist = py27, py34, py35, py36, pypy
[testenv]
deps = -requirements-tests.txt
commands = py.test {posargs}
[flake8]
exclude = .tox
ignore = D211,D400,E731
max-line-length = 120