moved control-related modules to a sub-package; minor corrections

tests/test_control/test_client.py

@@ -0,0 +1,209 @@
+__author__ = "Daniil Fajnberg"
+__copyright__ = "Copyright © 2022 Daniil Fajnberg"
+__license__ = """GNU LGPLv3.0
+
+This file is part of asyncio-taskpool.
+
+asyncio-taskpool is free software: you can redistribute it and/or modify it under the terms of
+version 3.0 of the GNU Lesser General Public License as published by the Free Software Foundation.
+
+asyncio-taskpool is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with asyncio-taskpool. 
+If not, see <https://www.gnu.org/licenses/>."""
+
+__doc__ = """
+Unittests for the `asyncio_taskpool.client` module.
+"""
+
+
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+from unittest import IsolatedAsyncioTestCase, skipIf
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from asyncio_taskpool.control import client
+from asyncio_taskpool.constants import CLIENT_INFO, SESSION_MSG_BYTES
+
+
+FOO, BAR = 'foo', 'bar'
+
+
+class ControlClientTestCase(IsolatedAsyncioTestCase):
+
+    def setUp(self) -> None:
+        self.abstract_patcher = patch('asyncio_taskpool.control.client.ControlClient.__abstractmethods__', set())
+        self.print_patcher = patch.object(client, 'print')
+        self.mock_abstract_methods = self.abstract_patcher.start()
+        self.mock_print = self.print_patcher.start()
+        self.kwargs = {FOO: 123, BAR: 456}
+        self.client = client.ControlClient(**self.kwargs)
+
+        self.mock_read = AsyncMock(return_value=FOO.encode())
+        self.mock_write, self.mock_drain = MagicMock(), AsyncMock()
+        self.mock_reader = MagicMock(read=self.mock_read)
+        self.mock_writer = MagicMock(write=self.mock_write, drain=self.mock_drain)
+
+    def tearDown(self) -> None:
+        self.abstract_patcher.stop()
+        self.print_patcher.stop()
+
+    def test_client_info(self):
+        self.assertEqual({CLIENT_INFO.TERMINAL_WIDTH: shutil.get_terminal_size().columns},
+                         client.ControlClient.client_info())
+
+    async def test_abstract(self):
+        with self.assertRaises(NotImplementedError):
+            await self.client._open_connection(**self.kwargs)
+
+    def test_init(self):
+        self.assertEqual(self.kwargs, self.client._conn_kwargs)
+        self.assertFalse(self.client._connected)
+
+    @patch.object(client.ControlClient, 'client_info')
+    async def test__server_handshake(self, mock_client_info: MagicMock):
+        mock_client_info.return_value = mock_info = {FOO: 1, BAR: 9999}
+        self.assertIsNone(await self.client._server_handshake(self.mock_reader, self.mock_writer))
+        self.assertTrue(self.client._connected)
+        mock_client_info.assert_called_once_with()
+        self.mock_write.assert_called_once_with(json.dumps(mock_info).encode())
+        self.mock_drain.assert_awaited_once_with()
+        self.mock_read.assert_awaited_once_with(SESSION_MSG_BYTES)
+        self.mock_print.assert_called_once_with("Connected to", self.mock_read.return_value.decode())
+
+    @patch.object(client, 'input')
+    def test__get_command(self, mock_input: MagicMock):
+        self.client._connected = True
+
+        mock_input.return_value = ' ' + FOO.upper() + ' '
+        mock_close = MagicMock()
+        mock_writer = MagicMock(close=mock_close)
+        output = self.client._get_command(mock_writer)
+        self.assertEqual(FOO, output)
+        mock_input.assert_called_once()
+        mock_close.assert_not_called()
+        self.assertTrue(self.client._connected)
+
+        mock_input.reset_mock()
+        mock_input.side_effect = KeyboardInterrupt
+        self.assertIsNone(self.client._get_command(mock_writer))
+        mock_input.assert_called_once()
+        mock_close.assert_not_called()
+        self.assertTrue(self.client._connected)
+
+        mock_input.reset_mock()
+        mock_input.side_effect = EOFError
+        self.assertIsNone(self.client._get_command(mock_writer))
+        mock_input.assert_called_once()
+        mock_close.assert_called_once()
+        self.assertFalse(self.client._connected)
+
+    @patch.object(client.ControlClient, '_get_command')
+    async def test__interact(self, mock__get_command: MagicMock):
+        self.client._connected = True
+
+        mock__get_command.return_value = None
+        self.assertIsNone(await self.client._interact(self.mock_reader, self.mock_writer))
+        self.mock_write.assert_not_called()
+        self.mock_drain.assert_not_awaited()
+        self.mock_read.assert_not_awaited()
+        self.mock_print.assert_not_called()
+        self.assertTrue(self.client._connected)
+
+        mock__get_command.return_value = cmd = FOO + BAR + ' 123'
+        self.mock_drain.side_effect = err = ConnectionError()
+        self.assertIsNone(await self.client._interact(self.mock_reader, self.mock_writer))
+        self.mock_write.assert_called_once_with(cmd.encode())
+        self.mock_drain.assert_awaited_once_with()
+        self.mock_read.assert_not_awaited()
+        self.mock_print.assert_called_once_with(err, file=sys.stderr)
+        self.assertFalse(self.client._connected)
+
+        self.client._connected = True
+        self.mock_write.reset_mock()
+        self.mock_drain.reset_mock(side_effect=True)
+        self.mock_print.reset_mock()
+
+        self.assertIsNone(await self.client._interact(self.mock_reader, self.mock_writer))
+        self.mock_write.assert_called_once_with(cmd.encode())
+        self.mock_drain.assert_awaited_once_with()
+        self.mock_read.assert_awaited_once_with(SESSION_MSG_BYTES)
+        self.mock_print.assert_called_once_with(FOO)
+        self.assertTrue(self.client._connected)
+
+    @patch.object(client.ControlClient, '_interact')
+    @patch.object(client.ControlClient, '_server_handshake')
+    @patch.object(client.ControlClient, '_open_connection')
+    async def test_start(self, mock__open_connection: AsyncMock, mock__server_handshake: AsyncMock,
+                         mock__interact: AsyncMock):
+        mock__open_connection.return_value = None, None
+        self.assertIsNone(await self.client.start())
+        mock__open_connection.assert_awaited_once_with(**self.kwargs)
+        mock__server_handshake.assert_not_awaited()
+        mock__interact.assert_not_awaited()
+        self.mock_print.assert_called_once_with("Failed to connect.", file=sys.stderr)
+
+        mock__open_connection.reset_mock()
+        self.mock_print.reset_mock()
+
+        mock__open_connection.return_value = self.mock_reader, self.mock_writer
+        self.assertIsNone(await self.client.start())
+        mock__open_connection.assert_awaited_once_with(**self.kwargs)
+        mock__server_handshake.assert_awaited_once_with(self.mock_reader, self.mock_writer)
+        mock__interact.assert_not_awaited()
+        self.mock_print.assert_called_once_with("Disconnected from control server.")
+
+        mock__open_connection.reset_mock()
+        mock__server_handshake.reset_mock()
+        self.mock_print.reset_mock()
+
+        self.client._connected = True
+        def disconnect(*_args, **_kwargs) -> None: self.client._connected = False
+        mock__interact.side_effect = disconnect
+        self.assertIsNone(await self.client.start())
+        mock__open_connection.assert_awaited_once_with(**self.kwargs)
+        mock__server_handshake.assert_awaited_once_with(self.mock_reader, self.mock_writer)
+        mock__interact.assert_awaited_once_with(self.mock_reader, self.mock_writer)
+        self.mock_print.assert_called_once_with("Disconnected from control server.")
+
+
+@skipIf(os.name == 'nt', "No Unix sockets on Windows :(")
+class UnixControlClientTestCase(IsolatedAsyncioTestCase):
+
+    def setUp(self) -> None:
+        self.base_init_patcher = patch.object(client.ControlClient, '__init__')
+        self.mock_base_init = self.base_init_patcher.start()
+        self.path = '/tmp/asyncio_taskpool'
+        self.kwargs = {FOO: 123, BAR: 456}
+        self.client = client.UnixControlClient(socket_path=self.path, **self.kwargs)
+
+    def tearDown(self) -> None:
+        self.base_init_patcher.stop()
+
+    def test_init(self):
+        self.assertEqual(Path(self.path), self.client._socket_path)
+        self.mock_base_init.assert_called_once_with(**self.kwargs)
+
+    @patch.object(client, 'print')
+    async def test__open_connection(self, mock_print: MagicMock):
+        expected_output = 'something'
+        self.client._open_unix_connection = mock_open_unix_connection = AsyncMock(return_value=expected_output)
+        kwargs = {'a': 1, 'b': 2}
+        output = await self.client._open_connection(**kwargs)
+        self.assertEqual(expected_output, output)
+        mock_open_unix_connection.assert_awaited_once_with(Path(self.path), **kwargs)
+        mock_print.assert_not_called()
+
+        mock_open_unix_connection.reset_mock()
+
+        mock_open_unix_connection.side_effect = FileNotFoundError
+        output1, output2 = await self.client._open_connection(**kwargs)
+        self.assertIsNone(output1)
+        self.assertIsNone(output2)
+        mock_open_unix_connection.assert_awaited_once_with(Path(self.path), **kwargs)
+        mock_print.assert_called_once_with("No socket at", Path(self.path), file=sys.stderr)

tests/test_control/test_parser.py

@@ -0,0 +1,259 @@
+__author__ = "Daniil Fajnberg"
+__copyright__ = "Copyright © 2022 Daniil Fajnberg"
+__license__ = """GNU LGPLv3.0
+
+This file is part of asyncio-taskpool.
+
+asyncio-taskpool is free software: you can redistribute it and/or modify it under the terms of
+version 3.0 of the GNU Lesser General Public License as published by the Free Software Foundation.
+
+asyncio-taskpool is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with asyncio-taskpool. 
+If not, see <https://www.gnu.org/licenses/>."""
+
+__doc__ = """
+Unittests for the `asyncio_taskpool.control.parser` module.
+"""
+
+
+from argparse import ArgumentParser, HelpFormatter, ArgumentDefaultsHelpFormatter, RawTextHelpFormatter, SUPPRESS
+from inspect import signature
+from unittest import TestCase
+from unittest.mock import MagicMock, call, patch
+
+from asyncio_taskpool.control import parser
+from asyncio_taskpool.exceptions import HelpRequested
+
+
+FOO, BAR = 'foo', 'bar'
+
+
+class ControlServerTestCase(TestCase):
+
+    def setUp(self) -> None:
+        self.help_formatter_factory_patcher = patch.object(parser.ControlParser, 'help_formatter_factory')
+        self.mock_help_formatter_factory = self.help_formatter_factory_patcher.start()
+        self.mock_help_formatter_factory.return_value = RawTextHelpFormatter
+        self.stream_writer, self.terminal_width = MagicMock(), 420
+        self.kwargs = {
+            'stream_writer': self.stream_writer,
+            'terminal_width': self.terminal_width,
+            parser.FORMATTER_CLASS: FOO
+        }
+        self.parser = parser.ControlParser(**self.kwargs)
+
+    def tearDown(self) -> None:
+        self.help_formatter_factory_patcher.stop()
+
+    def test_help_formatter_factory(self):
+        self.help_formatter_factory_patcher.stop()
+
+        class MockBaseClass(HelpFormatter):
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+
+        terminal_width = 123456789
+        cls = parser.ControlParser.help_formatter_factory(terminal_width, MockBaseClass)
+        self.assertTrue(issubclass(cls, MockBaseClass))
+        instance = cls('prog')
+        self.assertEqual(terminal_width, getattr(instance, '_width'))
+
+        cls = parser.ControlParser.help_formatter_factory(terminal_width)
+        self.assertTrue(issubclass(cls, ArgumentDefaultsHelpFormatter))
+        instance = cls('prog')
+        self.assertEqual(terminal_width, getattr(instance, '_width'))
+
+    def test_init(self):
+        self.assertIsInstance(self.parser, ArgumentParser)
+        self.assertEqual(self.stream_writer, self.parser._stream_writer)
+        self.assertEqual(self.terminal_width, self.parser._terminal_width)
+        self.mock_help_formatter_factory.assert_called_once_with(self.terminal_width, FOO)
+        self.assertFalse(getattr(self.parser, 'exit_on_error'))
+        self.assertEqual(RawTextHelpFormatter, getattr(self.parser, 'formatter_class'))
+        self.assertSetEqual(set(), self.parser._flags)
+        self.assertIsNone(self.parser._commands)
+
+    @patch.object(parser, 'get_first_doc_line')
+    def test_add_function_command(self, mock_get_first_doc_line: MagicMock):
+        def foo_bar(): pass
+        mock_subparser = MagicMock()
+        mock_add_parser = MagicMock(return_value=mock_subparser)
+        self.parser._commands = MagicMock(add_parser=mock_add_parser)
+        mock_get_first_doc_line.return_value = mock_help = 'help 123'
+        kwargs = {FOO: 1, BAR: 2, parser.DESCRIPTION: FOO + BAR}
+        expected_name = 'foo-bar'
+        expected_kwargs = {parser.NAME: expected_name, parser.PROG: expected_name, parser.HELP: mock_help} | kwargs
+        to_omit = ['abc', 'xyz']
+        output = self.parser.add_function_command(foo_bar, omit_params=to_omit, **kwargs)
+        self.assertEqual(mock_subparser, output)
+        mock_add_parser.assert_called_once_with(**expected_kwargs)
+        mock_subparser.add_function_args.assert_called_once_with(foo_bar, to_omit)
+
+    @patch.object(parser, 'get_first_doc_line')
+    def test_add_property_command(self, mock_get_first_doc_line: MagicMock):
+        def get_prop(_self): pass
+        def set_prop(_self, _value): pass
+        prop = property(get_prop)
+        mock_subparser = MagicMock()
+        mock_add_parser = MagicMock(return_value=mock_subparser)
+        self.parser._commands = MagicMock(add_parser=mock_add_parser)
+        mock_get_first_doc_line.return_value = mock_help = 'help 123'
+        kwargs = {FOO: 1, BAR: 2, parser.DESCRIPTION: FOO + BAR}
+        expected_name = 'get-prop'
+        expected_kwargs = {parser.NAME: expected_name, parser.PROG: expected_name, parser.HELP: mock_help} | kwargs
+        output = self.parser.add_property_command(prop, **kwargs)
+        self.assertEqual(mock_subparser, output)
+        mock_get_first_doc_line.assert_called_once_with(get_prop)
+        mock_add_parser.assert_called_once_with(**expected_kwargs)
+        mock_subparser.add_function_arg.assert_not_called()
+
+        mock_get_first_doc_line.reset_mock()
+        mock_add_parser.reset_mock()
+
+        prop = property(get_prop, set_prop)
+        expected_help = f"Get/set the `.{expected_name}` property"
+        expected_kwargs = {parser.NAME: expected_name, parser.PROG: expected_name, parser.HELP: expected_help} | kwargs
+        output = self.parser.add_property_command(prop, **kwargs)
+        self.assertEqual(mock_subparser, output)
+        mock_get_first_doc_line.assert_has_calls([call(get_prop), call(set_prop)])
+        mock_add_parser.assert_called_once_with(**expected_kwargs)
+        mock_subparser.add_function_arg.assert_called_once_with(
+            tuple(signature(set_prop).parameters.values())[1],
+            nargs='?',
+            default=SUPPRESS,
+            help=f"If provided: {mock_help} If omitted: {mock_help}"
+        )
+
+    @patch.object(parser.ControlParser, 'add_property_command')
+    @patch.object(parser.ControlParser, 'add_function_command')
+    def test_add_class_commands(self, mock_add_function_command: MagicMock, mock_add_property_command: MagicMock):
+        class FooBar:
+            some_attribute = None
+
+            def _protected(self, _): pass
+
+            def __private(self, _): pass
+
+            def to_omit(self, _): pass
+
+            def method(self, _): pass
+
+            @property
+            def prop(self): return None
+
+        mock_set_defaults = MagicMock()
+        mock_subparser = MagicMock(set_defaults=mock_set_defaults)
+        mock_add_function_command.return_value = mock_add_property_command.return_value = mock_subparser
+        x = 'x'
+        common_kwargs = {parser.STREAM_WRITER: self.parser._stream_writer,
+                         parser.CLIENT_INFO.TERMINAL_WIDTH: self.parser._terminal_width}
+        expected_output = {'method': mock_subparser, 'prop': mock_subparser}
+        output = self.parser.add_class_commands(FooBar, public_only=True, omit_members=['to_omit'], member_arg_name=x)
+        self.assertDictEqual(expected_output, output)
+        mock_add_function_command.assert_called_once_with(FooBar.method, **common_kwargs)
+        mock_add_property_command.assert_called_once_with(FooBar.prop, FooBar.__name__, **common_kwargs)
+        mock_set_defaults.assert_has_calls([call(**{x: FooBar.method}), call(**{x: FooBar.prop})])
+
+    def test__print_message(self):
+        self.stream_writer.write = MagicMock()
+        self.assertIsNone(self.parser._print_message(''))
+        self.stream_writer.write.assert_not_called()
+        msg = 'foo bar baz'
+        self.assertIsNone(self.parser._print_message(msg))
+        self.stream_writer.write.assert_called_once_with(msg.encode())
+
+    @patch.object(parser.ControlParser, '_print_message')
+    def test_exit(self, mock__print_message: MagicMock):
+        self.assertIsNone(self.parser.exit(123, ''))
+        mock__print_message.assert_not_called()
+        msg = 'foo bar baz'
+        self.assertIsNone(self.parser.exit(123, msg))
+        mock__print_message.assert_called_once_with(msg)
+
+    @patch.object(parser.ArgumentParser, 'error')
+    def test_error(self, mock_supercls_error: MagicMock):
+        with self.assertRaises(HelpRequested):
+            self.parser.error(FOO + BAR)
+        mock_supercls_error.assert_called_once_with(message=FOO + BAR)
+
+    @patch.object(parser.ArgumentParser, 'print_help')
+    def test_print_help(self, mock_print_help: MagicMock):
+        arg = MagicMock()
+        with self.assertRaises(HelpRequested):
+            self.parser.print_help(arg)
+        mock_print_help.assert_called_once_with(arg)
+
+    @patch.object(parser, 'get_arg_type_wrapper')
+    @patch.object(parser.ArgumentParser, 'add_argument')
+    def test_add_function_arg(self, mock_add_argument: MagicMock, mock_get_arg_type_wrapper: MagicMock):
+        mock_add_argument.return_value = expected_output = 'action'
+        mock_get_arg_type_wrapper.return_value = mock_type = 'fake'
+
+        foo_type, args_type, bar_type, baz_type, boo_type = tuple, str, int, float, complex
+        bar_default, baz_default, boo_default = 1, 0.1, 1j
+
+        def func(foo: foo_type, *args: args_type, bar: bar_type = bar_default, baz: baz_type = baz_default,
+                 boo: boo_type = boo_default, flag: bool = False):
+            return foo, args, bar, baz, boo, flag
+
+        param_foo, param_args, param_bar, param_baz, param_boo, param_flag = signature(func).parameters.values()
+        kwargs = {FOO + BAR: 'xyz'}
+        self.assertEqual(expected_output, self.parser.add_function_arg(param_foo, **kwargs))
+        mock_add_argument.assert_called_once_with('foo', type=mock_type, **kwargs)
+        mock_get_arg_type_wrapper.assert_called_once_with(foo_type)
+
+        mock_add_argument.reset_mock()
+        mock_get_arg_type_wrapper.reset_mock()
+
+        self.assertEqual(expected_output, self.parser.add_function_arg(param_args, **kwargs))
+        mock_add_argument.assert_called_once_with('args', nargs='*', type=mock_type, **kwargs)
+        mock_get_arg_type_wrapper.assert_called_once_with(args_type)
+
+        mock_add_argument.reset_mock()
+        mock_get_arg_type_wrapper.reset_mock()
+
+        self.assertEqual(expected_output, self.parser.add_function_arg(param_bar, **kwargs))
+        mock_add_argument.assert_called_once_with('-b', '--bar', default=bar_default, type=mock_type, **kwargs)
+        mock_get_arg_type_wrapper.assert_called_once_with(bar_type)
+
+        mock_add_argument.reset_mock()
+        mock_get_arg_type_wrapper.reset_mock()
+
+        self.assertEqual(expected_output, self.parser.add_function_arg(param_baz, **kwargs))
+        mock_add_argument.assert_called_once_with('-B', '--baz', default=baz_default, type=mock_type, **kwargs)
+        mock_get_arg_type_wrapper.assert_called_once_with(baz_type)
+
+        mock_add_argument.reset_mock()
+        mock_get_arg_type_wrapper.reset_mock()
+
+        self.assertEqual(expected_output, self.parser.add_function_arg(param_boo, **kwargs))
+        mock_add_argument.assert_called_once_with('--boo', default=boo_default, type=mock_type, **kwargs)
+        mock_get_arg_type_wrapper.assert_called_once_with(boo_type)
+
+        mock_add_argument.reset_mock()
+        mock_get_arg_type_wrapper.reset_mock()
+
+        self.assertEqual(expected_output, self.parser.add_function_arg(param_flag, **kwargs))
+        mock_add_argument.assert_called_once_with('-f', '--flag', action='store_true', **kwargs)
+        mock_get_arg_type_wrapper.assert_not_called()
+
+    @patch.object(parser.ControlParser, 'add_function_arg')
+    def test_add_function_args(self, mock_add_function_arg: MagicMock):
+        def func(foo: str, *args: int, bar: float = 0.1):
+            return foo, args, bar
+        _, param_args, param_bar = signature(func).parameters.values()
+        self.assertIsNone(self.parser.add_function_args(func, omit=['foo']))
+        mock_add_function_arg.assert_has_calls([
+            call(param_args, help=repr(param_args.annotation)),
+            call(param_bar, help=repr(param_bar.annotation)),
+        ])
+
+
+class RestTestCase(TestCase):
+    def test_get_arg_type_wrapper(self):
+        type_wrap = parser.get_arg_type_wrapper(int)
+        self.assertEqual(SUPPRESS, type_wrap(SUPPRESS))
+        self.assertEqual(13, type_wrap('13'))

tests/test_control/test_server.py

@@ -0,0 +1,166 @@
+__author__ = "Daniil Fajnberg"
+__copyright__ = "Copyright © 2022 Daniil Fajnberg"
+__license__ = """GNU LGPLv3.0
+
+This file is part of asyncio-taskpool.
+
+asyncio-taskpool is free software: you can redistribute it and/or modify it under the terms of
+version 3.0 of the GNU Lesser General Public License as published by the Free Software Foundation.
+
+asyncio-taskpool is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with asyncio-taskpool. 
+If not, see <https://www.gnu.org/licenses/>."""
+
+__doc__ = """
+Unittests for the `asyncio_taskpool.server` module.
+"""
+
+
+import asyncio
+import logging
+import os
+from pathlib import Path
+from unittest import IsolatedAsyncioTestCase, skipIf
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from asyncio_taskpool.control import server
+from asyncio_taskpool.control.client import ControlClient, UnixControlClient
+
+
+FOO, BAR = 'foo', 'bar'
+
+
+class ControlServerTestCase(IsolatedAsyncioTestCase):
+    log_lvl: int
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.log_lvl = server.log.level
+        server.log.setLevel(999)
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        server.log.setLevel(cls.log_lvl)
+
+    def setUp(self) -> None:
+        self.abstract_patcher = patch('asyncio_taskpool.control.server.ControlServer.__abstractmethods__', set())
+        self.mock_abstract_methods = self.abstract_patcher.start()
+        self.mock_pool = MagicMock()
+        self.kwargs = {FOO: 123, BAR: 456}
+        self.server = server.ControlServer(pool=self.mock_pool, **self.kwargs)
+
+    def tearDown(self) -> None:
+        self.abstract_patcher.stop()
+
+    def test_client_class_name(self):
+        self.assertEqual(ControlClient.__name__, server.ControlServer.client_class_name)
+
+    async def test_abstract(self):
+        with self.assertRaises(NotImplementedError):
+            args = [AsyncMock()]
+            await self.server._get_server_instance(*args)
+        with self.assertRaises(NotImplementedError):
+            self.server._final_callback()
+
+    def test_init(self):
+        self.assertEqual(self.mock_pool, self.server._pool)
+        self.assertEqual(self.kwargs, self.server._server_kwargs)
+        self.assertIsNone(self.server._server)
+
+    def test_pool(self):
+        self.assertEqual(self.mock_pool, self.server.pool)
+
+    def test_is_serving(self):
+        self.server._server = MagicMock(is_serving=MagicMock(return_value=FOO + BAR))
+        self.assertEqual(FOO + BAR, self.server.is_serving())
+
+    @patch.object(server, 'ControlSession')
+    async def test__client_connected_cb(self, mock_client_session_cls: MagicMock):
+        mock_client_handshake, mock_listen = AsyncMock(), AsyncMock()
+        mock_client_session_cls.return_value = MagicMock(client_handshake=mock_client_handshake, listen=mock_listen)
+        mock_reader, mock_writer = MagicMock(), MagicMock()
+        self.assertIsNone(await self.server._client_connected_cb(mock_reader, mock_writer))
+        mock_client_session_cls.assert_called_once_with(self.server, mock_reader, mock_writer)
+        mock_client_handshake.assert_awaited_once_with()
+        mock_listen.assert_awaited_once_with()
+
+    @patch.object(server.ControlServer, '_final_callback')
+    async def test__serve_forever(self, mock__final_callback: MagicMock):
+        mock_aenter, mock_serve_forever = AsyncMock(), AsyncMock(side_effect=asyncio.CancelledError)
+        self.server._server = MagicMock(__aenter__=mock_aenter, serve_forever=mock_serve_forever)
+        with self.assertLogs(server.log, logging.DEBUG):
+            self.assertIsNone(await self.server._serve_forever())
+        mock_aenter.assert_awaited_once_with()
+        mock_serve_forever.assert_awaited_once_with()
+        mock__final_callback.assert_called_once_with()
+
+        mock_aenter.reset_mock()
+        mock_serve_forever.reset_mock(side_effect=True)
+        mock__final_callback.reset_mock()
+
+        self.assertIsNone(await self.server._serve_forever())
+        mock_aenter.assert_awaited_once_with()
+        mock_serve_forever.assert_awaited_once_with()
+        mock__final_callback.assert_called_once_with()
+
+    @patch.object(server, 'create_task')
+    @patch.object(server.ControlServer, '_serve_forever', new_callable=MagicMock())
+    @patch.object(server.ControlServer, '_get_server_instance')
+    async def test_serve_forever(self, mock__get_server_instance: AsyncMock, mock__serve_forever: MagicMock,
+                                 mock_create_task: MagicMock):
+        mock__serve_forever.return_value = mock_awaitable = 'some_coroutine'
+        mock_create_task.return_value = expected_output = 12345
+        output = await self.server.serve_forever()
+        self.assertEqual(expected_output, output)
+        mock__get_server_instance.assert_awaited_once_with(self.server._client_connected_cb, **self.kwargs)
+        mock__serve_forever.assert_called_once_with()
+        mock_create_task.assert_called_once_with(mock_awaitable)
+
+
+@skipIf(os.name == 'nt', "No Unix sockets on Windows :(")
+class UnixControlServerTestCase(IsolatedAsyncioTestCase):
+    log_lvl: int
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.log_lvl = server.log.level
+        server.log.setLevel(999)
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        server.log.setLevel(cls.log_lvl)
+
+    def setUp(self) -> None:
+        self.base_init_patcher = patch.object(server.ControlServer, '__init__')
+        self.mock_base_init = self.base_init_patcher.start()
+        self.mock_pool = MagicMock()
+        self.path = '/tmp/asyncio_taskpool'
+        self.kwargs = {FOO: 123, BAR: 456}
+        self.server = server.UnixControlServer(pool=self.mock_pool, path=self.path, **self.kwargs)
+
+    def tearDown(self) -> None:
+        self.base_init_patcher.stop()
+
+    def test__client_class(self):
+        self.assertEqual(UnixControlClient, self.server._client_class)
+
+    def test_init(self):
+        self.assertEqual(Path(self.path), self.server._socket_path)
+        self.mock_base_init.assert_called_once_with(self.mock_pool, **self.kwargs)
+
+    async def test__get_server_instance(self):
+        expected_output = 'totally_a_server'
+        self.server._start_unix_server = mock_start_unix_server = AsyncMock(return_value=expected_output)
+        mock_callback, mock_kwargs = MagicMock(), {'a': 1, 'b': 2}
+        args = [mock_callback]
+        output = await self.server._get_server_instance(*args, **mock_kwargs)
+        self.assertEqual(expected_output, output)
+        mock_start_unix_server.assert_called_once_with(mock_callback, Path(self.path), **mock_kwargs)
+
+    def test__final_callback(self):
+        self.server._socket_path = MagicMock()
+        self.assertIsNone(self.server._final_callback())
+        self.server._socket_path.unlink.assert_called_once_with()

tests/test_control/test_session.py

@@ -0,0 +1,194 @@
+__author__ = "Daniil Fajnberg"
+__copyright__ = "Copyright © 2022 Daniil Fajnberg"
+__license__ = """GNU LGPLv3.0
+
+This file is part of asyncio-taskpool.
+
+asyncio-taskpool is free software: you can redistribute it and/or modify it under the terms of
+version 3.0 of the GNU Lesser General Public License as published by the Free Software Foundation.
+
+asyncio-taskpool is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
+without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with asyncio-taskpool. 
+If not, see <https://www.gnu.org/licenses/>."""
+
+__doc__ = """
+Unittests for the `asyncio_taskpool.session` module.
+"""
+
+
+import json
+from argparse import ArgumentError, Namespace
+from unittest import IsolatedAsyncioTestCase
+from unittest.mock import AsyncMock, MagicMock, patch, call
+
+from asyncio_taskpool.control import session
+from asyncio_taskpool.constants import CLIENT_INFO, CMD, SESSION_MSG_BYTES, STREAM_WRITER
+from asyncio_taskpool.exceptions import HelpRequested
+from asyncio_taskpool.pool import SimpleTaskPool
+
+
+FOO, BAR = 'foo', 'bar'
+
+
+class ControlServerTestCase(IsolatedAsyncioTestCase):
+    log_lvl: int
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.log_lvl = session.log.level
+        session.log.setLevel(999)
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        session.log.setLevel(cls.log_lvl)
+
+    def setUp(self) -> None:
+        self.mock_pool = MagicMock(spec=SimpleTaskPool(AsyncMock()))
+        self.mock_client_class_name = FOO + BAR
+        self.mock_server = MagicMock(pool=self.mock_pool,
+                                     client_class_name=self.mock_client_class_name)
+        self.mock_reader = MagicMock()
+        self.mock_writer = MagicMock()
+        self.session = session.ControlSession(self.mock_server, self.mock_reader, self.mock_writer)
+
+    def test_init(self):
+        self.assertEqual(self.mock_server, self.session._control_server)
+        self.assertEqual(self.mock_pool, self.session._pool)
+        self.assertEqual(self.mock_client_class_name, self.session._client_class_name)
+        self.assertEqual(self.mock_reader, self.session._reader)
+        self.assertEqual(self.mock_writer, self.session._writer)
+        self.assertIsNone(self.session._parser)
+
+    @patch.object(session, 'return_or_exception')
+    async def test__exec_method_and_respond(self, mock_return_or_exception: AsyncMock):
+        def method(self, arg1, arg2, *var_args, **rest): pass
+        test_arg1, test_arg2, test_var_args, test_rest = 123, 'xyz', [0.1, 0.2, 0.3], {'aaa': 1, 'bbb': 11}
+        kwargs = {'arg1': test_arg1, 'arg2': test_arg2, 'var_args': test_var_args} | test_rest
+        mock_return_or_exception.return_value = None
+        self.assertIsNone(await self.session._exec_method_and_respond(method, **kwargs))
+        mock_return_or_exception.assert_awaited_once_with(
+            method, self.mock_pool, test_arg1, test_arg2, *test_var_args, **test_rest
+        )
+        self.mock_writer.write.assert_called_once_with(session.CMD_OK)
+
+    @patch.object(session, 'return_or_exception')
+    async def test__exec_property_and_respond(self, mock_return_or_exception: AsyncMock):
+        def prop_get(_): pass
+        def prop_set(_): pass
+        prop = property(prop_get, prop_set)
+        kwargs = {'value': 'something'}
+        mock_return_or_exception.return_value = None
+        self.assertIsNone(await self.session._exec_property_and_respond(prop, **kwargs))
+        mock_return_or_exception.assert_awaited_once_with(prop_set, self.mock_pool, **kwargs)
+        self.mock_writer.write.assert_called_once_with(session.CMD_OK)
+
+        mock_return_or_exception.reset_mock()
+        self.mock_writer.write.reset_mock()
+
+        mock_return_or_exception.return_value = val = 420.69
+        self.assertIsNone(await self.session._exec_property_and_respond(prop))
+        mock_return_or_exception.assert_awaited_once_with(prop_get, self.mock_pool)
+        self.mock_writer.write.assert_called_once_with(str(val).encode())
+
+    @patch.object(session, 'ControlParser')
+    async def test_client_handshake(self, mock_parser_cls: MagicMock):
+        mock_add_subparsers, mock_add_class_commands = MagicMock(), MagicMock()
+        mock_parser = MagicMock(add_subparsers=mock_add_subparsers, add_class_commands=mock_add_class_commands)
+        mock_parser_cls.return_value = mock_parser
+        width = 5678
+        msg = ' ' + json.dumps({CLIENT_INFO.TERMINAL_WIDTH: width, FOO: BAR}) + '  '
+        mock_read = AsyncMock(return_value=msg.encode())
+        self.mock_reader.read = mock_read
+        self.mock_writer.drain = AsyncMock()
+        expected_parser_kwargs = {
+            STREAM_WRITER: self.mock_writer,
+            CLIENT_INFO.TERMINAL_WIDTH: width,
+            'prog': '',
+            'usage': f'[-h] [{CMD}] ...'
+        }
+        expected_subparsers_kwargs = {
+            'title': "Commands",
+            'metavar': "(A command followed by '-h' or '--help' will show command-specific help.)"
+        }
+        self.assertIsNone(await self.session.client_handshake())
+        self.assertEqual(mock_parser, self.session._parser)
+        mock_read.assert_awaited_once_with(SESSION_MSG_BYTES)
+        mock_parser_cls.assert_called_once_with(**expected_parser_kwargs)
+        mock_add_subparsers.assert_called_once_with(**expected_subparsers_kwargs)
+        mock_add_class_commands.assert_called_once_with(self.mock_pool.__class__)
+        self.mock_writer.write.assert_called_once_with(str(self.mock_pool).encode())
+        self.mock_writer.drain.assert_awaited_once_with()
+
+    @patch.object(session.ControlSession, '_exec_property_and_respond')
+    @patch.object(session.ControlSession, '_exec_method_and_respond')
+    async def test__parse_command(self, mock__exec_method_and_respond: AsyncMock,
+                                  mock__exec_property_and_respond: AsyncMock):
+        def method(_): pass
+        prop = property(method)
+        msg = 'asdf asd as a'
+        kwargs = {FOO: BAR, 'hello': 'python'}
+        mock_parse_args = MagicMock(return_value=Namespace(**{CMD: method}, **kwargs))
+        self.session._parser = MagicMock(parse_args=mock_parse_args)
+        self.mock_writer.write = MagicMock()
+        self.assertIsNone(await self.session._parse_command(msg))
+        mock_parse_args.assert_called_once_with(msg.split(' '))
+        self.mock_writer.write.assert_not_called()
+        mock__exec_method_and_respond.assert_awaited_once_with(method, **kwargs)
+        mock__exec_property_and_respond.assert_not_called()
+
+        mock__exec_method_and_respond.reset_mock()
+        mock_parse_args.reset_mock()
+
+        mock_parse_args = MagicMock(return_value=Namespace(**{CMD: prop}, **kwargs))
+        self.session._parser = MagicMock(parse_args=mock_parse_args)
+        self.mock_writer.write = MagicMock()
+        self.assertIsNone(await self.session._parse_command(msg))
+        mock_parse_args.assert_called_once_with(msg.split(' '))
+        self.mock_writer.write.assert_not_called()
+        mock__exec_method_and_respond.assert_not_called()
+        mock__exec_property_and_respond.assert_awaited_once_with(prop, **kwargs)
+
+        mock__exec_property_and_respond.reset_mock()
+        mock_parse_args.reset_mock()
+
+        mock_parse_args.side_effect = exc = ArgumentError(MagicMock(), "oops")
+        self.assertIsNone(await self.session._parse_command(msg))
+        mock_parse_args.assert_called_once_with(msg.split(' '))
+        self.mock_writer.write.assert_called_once_with(str(exc).encode())
+        mock__exec_method_and_respond.assert_not_awaited()
+        mock__exec_property_and_respond.assert_not_awaited()
+
+        self.mock_writer.write.reset_mock()
+        mock_parse_args.reset_mock()
+
+        mock_parse_args.side_effect = HelpRequested()
+        self.assertIsNone(await self.session._parse_command(msg))
+        mock_parse_args.assert_called_once_with(msg.split(' '))
+        self.mock_writer.write.assert_not_called()
+        mock__exec_method_and_respond.assert_not_awaited()
+        mock__exec_property_and_respond.assert_not_awaited()
+
+    @patch.object(session.ControlSession, '_parse_command')
+    async def test_listen(self, mock__parse_command: AsyncMock):
+        def make_reader_return_empty():
+            self.mock_reader.read.return_value = b''
+        self.mock_writer.drain = AsyncMock(side_effect=make_reader_return_empty)
+        msg = "fascinating"
+        self.mock_reader.read = AsyncMock(return_value=f' {msg} '.encode())
+        self.assertIsNone(await self.session.listen())
+        self.mock_reader.read.assert_has_awaits([call(SESSION_MSG_BYTES), call(SESSION_MSG_BYTES)])
+        mock__parse_command.assert_awaited_once_with(msg)
+        self.mock_writer.drain.assert_awaited_once_with()
+
+        self.mock_reader.read.reset_mock()
+        mock__parse_command.reset_mock()
+        self.mock_writer.drain.reset_mock()
+
+        self.mock_server.is_serving = MagicMock(return_value=False)
+        self.assertIsNone(await self.session.listen())
+        self.mock_reader.read.assert_not_awaited()
+        mock__parse_command.assert_not_awaited()
+        self.mock_writer.drain.assert_not_awaited()