More validations and make tests better

* Reduce copy-paste amount between tests.
* Do not require external mock: py36 version contains everything

Signed-off-by: Aleksei Stepanov <penguinolog@gmail.com>

Author: penguinolog

CI_REQUIREMENTS.txt

@@ -1,2 +1 @@
-mock  # no assert_called_once in py35
 -r requirements.txt

exec_helpers/async_api/subprocess_runner.py

@@ -68,7 +68,10 @@ class Subprocess(api.ExecHelper, metaclass=metaclasses.SingleLock):
     __slots__ = ()
 
     def __init__(
-        self, log_mask_re: typing.Optional[str] = None, *, logger: logging.Logger = logging.getLogger(__name__)
+        self,
+        log_mask_re: typing.Optional[str] = None,
+        *,
+        logger: logging.Logger = logging.getLogger(__name__),  # noqa: B008
     ) -> None:
         """Subprocess helper with timeouts and lock-free FIFO.
 

exec_helpers/subprocess_runner.py

@@ -64,7 +64,10 @@ class Subprocess(api.ExecHelper, metaclass=metaclasses.SingleLock):
     """Subprocess helper with timeouts and lock-free FIFO."""
 
     def __init__(
-        self, log_mask_re: typing.Optional[str] = None, *, logger: logging.Logger = logging.getLogger(__name__)
+        self,
+        log_mask_re: typing.Optional[str] = None,
+        *,
+        logger: logging.Logger = logging.getLogger(__name__),  # noqa: B008
     ) -> None:
         """Subprocess helper with timeouts and lock-free FIFO.
 

pytest.ini

@@ -1,4 +1,4 @@
 [pytest]
 addopts = -vvv -s -p no:django -p no:ipdb
 testpaths = test
-mock_use_standalone_module = true
+mock_use_standalone_module = false

test/async_api/test_subprocess.py

@@ -16,9 +16,9 @@
 import logging
 import random
 import typing
+from unittest import mock
 
 import asynctest
-import mock
 import pytest
 
 import exec_helpers
@@ -104,6 +104,7 @@ async def read_stream(stream: FakeFileStream):
 
 
 def pytest_generate_tests(metafunc):
+    """Tests parametrization."""
     if "run_parameters" in metafunc.fixturenames:
         metafunc.parametrize(
             "run_parameters",
@@ -123,6 +124,7 @@ def pytest_generate_tests(metafunc):
 
 @pytest.fixture
 def run_parameters(request):
+    """Tests configuration apply."""
     return configs[request.param]
 
 
@@ -190,10 +192,12 @@ def create_mock(
 
 @pytest.fixture
 def logger(mocker):
+    """Simple mock of logger instance."""
     return mocker.patch("exec_helpers.async_api.subprocess_runner.Subprocess.logger", autospec=True)
 
 
 async def test_001_execute_async(create_subprocess_shell, logger, run_parameters) -> None:
+    """Test low level API."""
     runner = exec_helpers.async_api.Subprocess()
     res = await runner.execute_async(
         command,
@@ -246,6 +250,7 @@ async def test_001_execute_async(create_subprocess_shell, logger, run_parameters
 
 
 async def test_002_execute(create_subprocess_shell, logger, exec_result, run_parameters) -> None:
+    """Test API without checkers."""
     runner = exec_helpers.async_api.Subprocess()
     res = await runner.execute(command, stdin=run_parameters["stdin"])
     assert isinstance(res, exec_helpers.async_api.ExecResult)
@@ -256,6 +261,7 @@ async def test_002_execute(create_subprocess_shell, logger, exec_result, run_par
 
 
 async def test_003_context_manager(monkeypatch, create_subprocess_shell, logger, exec_result, run_parameters) -> None:
+    """Test context manager for threads synchronization."""
     lock = asynctest.CoroutineMock()
     lock.attach_mock(asynctest.CoroutineMock("acquire"), "acquire")
     lock.attach_mock(mock.Mock("release"), "release")
@@ -272,6 +278,7 @@ async def test_003_context_manager(monkeypatch, create_subprocess_shell, logger,
 
 
 async def test_004_check_call(execute, exec_result, logger) -> None:
+    """Test exit code validator."""
     runner = exec_helpers.async_api.Subprocess()
     if exec_result.exit_code == exec_helpers.ExitCodes.EX_OK:
         assert await runner.check_call(command, stdin=exec_result.stdin) == exec_result
@@ -294,6 +301,7 @@ async def test_004_check_call(execute, exec_result, logger) -> None:
 
 
 async def test_005_check_call_no_raise(execute, exec_result, logger) -> None:
+    """Test exit code validator in permissive mode."""
     runner = exec_helpers.async_api.Subprocess()
     res = await runner.check_call(command, stdin=exec_result.stdin, raise_on_err=False)
     assert res == exec_result
@@ -306,11 +314,13 @@ async def test_005_check_call_no_raise(execute, exec_result, logger) -> None:
 
 
 async def test_006_check_call_expect(execute, exec_result, logger) -> None:
+    """Test exit code validator with custom return codes."""
     runner = exec_helpers.async_api.Subprocess()
     assert await runner.check_call(command, stdin=exec_result.stdin, expected=[exec_result.exit_code]) == exec_result
 
 
 async def test_007_check_stderr(execute, exec_result, logger) -> None:
+    """Test STDERR content validator."""
     runner = exec_helpers.async_api.Subprocess()
     if not exec_result.stderr:
         assert (
@@ -335,6 +345,7 @@ async def test_007_check_stderr(execute, exec_result, logger) -> None:
 
 
 async def test_008_check_stderr_no_raise(execute, exec_result, logger) -> None:
+    """Test STDERR content validator in permissive mode."""
     runner = exec_helpers.async_api.Subprocess()
     assert (
         await runner.check_stderr(
@@ -345,6 +356,7 @@ async def test_008_check_stderr_no_raise(execute, exec_result, logger) -> None:
 
 
 async def test_009_call(create_subprocess_shell, logger, exec_result, run_parameters) -> None:
+    """Test callable."""
     runner = exec_helpers.async_api.Subprocess()
     res = await runner(command, stdin=run_parameters["stdin"])
     assert isinstance(res, exec_helpers.async_api.ExecResult)

test/async_api/test_subprocess_special.py

@@ -17,9 +17,9 @@
 import logging
 import random
 import typing
+from unittest import mock
 
 import asynctest
-import mock
 import pytest
 
 import exec_helpers
@@ -104,6 +104,7 @@ async def read_stream(stream: FakeFileStream):
 
 
 def pytest_generate_tests(metafunc):
+    """Tests parametrization."""
     if "run_parameters" in metafunc.fixturenames:
         metafunc.parametrize(
             "run_parameters",
@@ -129,6 +130,7 @@ def pytest_generate_tests(metafunc):
 
 @pytest.fixture
 def run_parameters(request):
+    """Tests configuration apply."""
     return configs[request.param]
 
 
@@ -198,6 +200,7 @@ def logger(mocker):
 
 
 async def test_special_cases(create_subprocess_shell, exec_result, logger, run_parameters) -> None:
+    """Parametrized validation of special cases."""
     runner = exec_helpers.async_api.Subprocess(log_mask_re=run_parameters.get("init_log_mask_re", None))
     if "expect_exc" not in run_parameters:
         res = await runner.execute(

test/conftest.py

@@ -0,0 +1,47 @@
+#    Copyright 2019 Alexey Stepanov aka penguinolog.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+
+import pytest
+
+
+@pytest.fixture
+def paramiko_ssh_client(mocker):
+    """Minimal paramiko.SSHClient mock."""
+    mocker.patch("time.sleep")
+    return mocker.patch("paramiko.SSHClient")
+
+
+@pytest.fixture
+def auto_add_policy(mocker):
+    """Minimal paramiko.AutoAddPolicy mock."""
+    return mocker.patch("paramiko.AutoAddPolicy", return_value="AutoAddPolicy")
+
+
+@pytest.fixture
+def ssh_auth_logger(mocker):
+    """Minimal exec_helpers.ssh_auth.logger mock."""
+    return mocker.patch("exec_helpers.ssh_auth.logger")
+
+
+@pytest.fixture
+def subprocess_logger(mocker):
+    """Minimal exec_helpers.subprocess_runner.Subprocess.logger mock."""
+    return mocker.patch("exec_helpers.subprocess_runner.Subprocess.logger", autospec=True)
+
+
+@pytest.fixture
+def get_logger(mocker):
+    """Minimal logging.getLogger mock."""
+    return mocker.patch("logging.getLogger")

test/test_exec_result.py

@@ -31,7 +31,7 @@
 class TestExecResult(unittest.TestCase):
     @mock.patch("exec_helpers.exec_result.logger")
     def test_create_minimal(self, logger):
-        """Test defaults"""
+        """Test defaults."""
         result = exec_helpers.ExecResult(cmd=cmd)
         self.assertEqual(result.cmd, cmd)
         self.assertEqual(result.cmd, result["cmd"])
@@ -86,14 +86,15 @@ def test_create_minimal(self, logger):
 
     @mock.patch("exec_helpers.exec_result.logger", autospec=True)
     def test_not_implemented(self, logger):
-        """Test assertion on non implemented deserializer"""
+        """Test assertion on non implemented deserializer."""
         result = exec_helpers.ExecResult(cmd=cmd)
         deserialize = getattr(result, "_ExecResult__deserialize")
         with self.assertRaises(NotImplementedError):
             deserialize("tst")
         logger.assert_has_calls((mock.call.error("{fmt} deserialize target is not implemented".format(fmt="tst")),))
 
     def test_setters(self):
+        """Test setters: unlocked and final."""
         result = exec_helpers.ExecResult(cmd=cmd)
         self.assertEqual(result.exit_code, exec_helpers.ExitCodes.EX_INVALID)
 
@@ -136,12 +137,13 @@ def test_setters(self):
         self.assertEqual(result.stderr_brief, stderr_brief)
 
     def test_json(self):
+        """Test json extraction."""
         result = exec_helpers.ExecResult("test", stdout=[b'{"test": true}'])
         self.assertEqual(result.stdout_json, {"test": True})
 
     @mock.patch("exec_helpers.exec_result.logger", autospec=True)
     def test_wrong_result(self, logger):
-        """Test logging exception if stdout if not a correct json"""
+        """Test logging exception if stdout if not a correct json."""
         cmd = r"ls -la | awk '{print $1\}'"
         result = exec_helpers.ExecResult(cmd=cmd)
         with self.assertRaises(exec_helpers.ExecHelperError):
@@ -189,22 +191,27 @@ def test_finalize(self):
             result.read_stderr([b"err"])
 
     def test_stdin_none(self):
+        """Test with empty STDIN."""
         result = exec_helpers.ExecResult(cmd, exit_code=0)
         self.assertIsNone(result.stdin)
 
     def test_stdin_utf(self):
+        """Test with string in STDIN."""
         result = exec_helpers.ExecResult(cmd, stdin="STDIN", exit_code=0)
         self.assertEqual(result.stdin, "STDIN")
 
     def test_stdin_bytes(self):
+        """Test with bytes STDIN."""
         result = exec_helpers.ExecResult(cmd, stdin=b"STDIN", exit_code=0)
         self.assertEqual(result.stdin, "STDIN")
 
     def test_stdin_bytearray(self):
+        """Test with bytearray STDIN."""
         result = exec_helpers.ExecResult(cmd, stdin=bytearray(b"STDIN"), exit_code=0)
         self.assertEqual(result.stdin, "STDIN")
 
     def test_started(self):
+        """Test timestamp."""
         started = datetime.datetime.utcnow()
         result = exec_helpers.ExecResult(cmd, exit_code=0, started=started)
         spent = (result.timestamp - started).seconds
@@ -229,6 +236,7 @@ def test_started(self):
         )
 
     def test_indexed_lines_access(self):
+        """Test custom indexes usage for construction string from output."""
         result = exec_helpers.ExecResult(
             cmd,
             stdout=(

test/test_sftp.py

@@ -20,8 +20,8 @@
 import posixpath
 import stat
 import unittest
+from unittest import mock
 
-import mock
 import paramiko
 
 import exec_helpers

test/test_ssh_client_execute.py

@@ -15,8 +15,8 @@
 import datetime
 import logging
 import typing
+from unittest import mock
 
-import mock
 import pytest
 
 import exec_helpers
@@ -122,6 +122,7 @@ def read_stream(stream: FakeFileStream) -> typing.Tuple[bytes, ...]:
 
 
 def pytest_generate_tests(metafunc):
+    """Tests parametrization."""
     if "run_parameters" in metafunc.fixturenames:
         metafunc.parametrize(
             "run_parameters",
@@ -143,20 +144,10 @@ def pytest_generate_tests(metafunc):
 
 @pytest.fixture
 def run_parameters(request):
+    """Tests configuration apply."""
     return configs[request.param]
 
 
-@pytest.fixture
-def auto_add_policy(mocker):
-    return mocker.patch("paramiko.AutoAddPolicy", return_value="AutoAddPolicy")
-
-
-@pytest.fixture
-def paramiko_ssh_client(mocker):
-    mocker.patch("time.sleep")
-    return mocker.patch("paramiko.SSHClient")
-
-
 @pytest.fixture
 def chan_makefile(run_parameters):
     class MkFile:
@@ -197,16 +188,6 @@ def ssh_transport_channel(paramiko_ssh_client, chan_makefile, run_parameters):
     return chan
 
 
-@pytest.fixture
-def ssh_auth_logger(mocker):
-    return mocker.patch("exec_helpers.ssh_auth.logger")
-
-
-@pytest.fixture
-def get_logger(mocker):
-    return mocker.patch("logging.getLogger")
-
-
 @pytest.fixture
 def ssh(paramiko_ssh_client, ssh_transport_channel, auto_add_policy, ssh_auth_logger, get_logger):
     return exec_helpers.SSHClient(host=host, port=port, auth=exec_helpers.SSHAuth(username=username, password=password))