Merge branch 'master' into skip-ssl-check

dmitry-lipetsk · dmitry-lipetsk · commit 67f23a71b0a7 · 2024-12-08T17:48:38.000+03:00
diff --git a/testgres/operations/local_ops.py b/testgres/operations/local_ops.py
@@ -58,47 +58,55 @@ def _process_output(encoding, temp_file_path):
                 output = output.decode(encoding)
             return output, None  # In Windows stderr writing in stdout
 
-    def _run_command(self, cmd, shell, input, stdin, stdout, stderr, get_process, timeout, encoding):
-        """Execute a command and return the process and its output."""
-        if os.name == 'nt' and stdout is None:  # Windows
-            with tempfile.NamedTemporaryFile(mode='w+b', delete=False) as temp_file:
-                stdout = temp_file
-                stderr = subprocess.STDOUT
-                process = subprocess.Popen(
-                    cmd,
-                    shell=shell,
-                    stdin=stdin or subprocess.PIPE if input is not None else None,
-                    stdout=stdout,
-                    stderr=stderr,
-                )
-                if get_process:
-                    return process, None, None
-                temp_file_path = temp_file.name
-
-            # Wait process finished
-            process.wait()
-
-            output, error = self._process_output(encoding, temp_file_path)
-            return process, output, error
-        else:  # Other OS
+    def _run_command__nt(self, cmd, shell, input, stdin, stdout, stderr, get_process, timeout, encoding):
+        with tempfile.NamedTemporaryFile(mode='w+b', delete=False) as temp_file:
+            stdout = temp_file
+            stderr = subprocess.STDOUT
             process = subprocess.Popen(
                 cmd,
                 shell=shell,
                 stdin=stdin or subprocess.PIPE if input is not None else None,
-                stdout=stdout or subprocess.PIPE,
-                stderr=stderr or subprocess.PIPE,
+                stdout=stdout,
+                stderr=stderr,
             )
             if get_process:
                 return process, None, None
-            try:
-                output, error = process.communicate(input=input.encode(encoding) if input else None, timeout=timeout)
-                if encoding:
-                    output = output.decode(encoding)
-                    error = error.decode(encoding)
-                return process, output, error
-            except subprocess.TimeoutExpired:
-                process.kill()
-                raise ExecUtilException("Command timed out after {} seconds.".format(timeout))
+            temp_file_path = temp_file.name
+
+        # Wait process finished
+        process.wait()
+
+        output, error = self._process_output(encoding, temp_file_path)
+        return process, output, error
+
+    def _run_command__generic(self, cmd, shell, input, stdin, stdout, stderr, get_process, timeout, encoding):
+        process = subprocess.Popen(
+            cmd,
+            shell=shell,
+            stdin=stdin or subprocess.PIPE if input is not None else None,
+            stdout=stdout or subprocess.PIPE,
+            stderr=stderr or subprocess.PIPE,
+        )
+        if get_process:
+            return process, None, None
+        try:
+            output, error = process.communicate(input=input.encode(encoding) if input else None, timeout=timeout)
+            if encoding:
+                output = output.decode(encoding)
+                error = error.decode(encoding)
+            return process, output, error
+        except subprocess.TimeoutExpired:
+            process.kill()
+            raise ExecUtilException("Command timed out after {} seconds.".format(timeout))
+
+    def _run_command(self, cmd, shell, input, stdin, stdout, stderr, get_process, timeout, encoding):
+        """Execute a command and return the process and its output."""
+        if os.name == 'nt' and stdout is None:  # Windows
+            method = __class__._run_command__nt
+        else:  # Other OS
+            method = __class__._run_command__generic
+
+        return method(self, cmd, shell, input, stdin, stdout, stderr, get_process, timeout, encoding)
 
     def exec_command(self, cmd, wait_exit=False, verbose=False, expect_error=False, encoding=None, shell=False,
                      text=False, input=None, stdin=None, stdout=None, stderr=None, get_process=False, timeout=None,
diff --git a/testgres/operations/remote_ops.py b/testgres/operations/remote_ops.py
@@ -68,26 +68,26 @@ def exec_command(self, cmd, wait_exit=False, verbose=False, expect_error=False,
 
         exit_status = process.returncode
 
-        if encoding:
-            result = result.decode(encoding)
-            error = error.decode(encoding)
-
-        if expect_error:
-            raise Exception(result, error)
+        assert type(result) == bytes  # noqa: E721
+        assert type(error) == bytes  # noqa: E721
 
         if not error:
-            error_found = 0
+            error_found = False
         else:
-            error = normalize_error(error)
             error_found = exit_status != 0 or any(
-                marker in error for marker in ['error', 'Permission denied', 'fatal', 'No such file or directory']
+                marker in error for marker in [b'error', b'Permission denied', b'fatal', b'No such file or directory']
             )
 
-        if not ignore_errors and error_found:
-            if isinstance(error, bytes):
-                message = b"Utility exited with non-zero code. Error: " + error
-            else:
-                message = f"Utility exited with non-zero code. Error: {error}"
+        assert type(error_found) == bool  # noqa: E721
+
+        if encoding:
+            result = result.decode(encoding)
+            error = error.decode(encoding)
+
+        if not ignore_errors and error_found and not expect_error:
+            error = normalize_error(error)
+            assert type(error) == str  # noqa: E721
+            message = "Utility exited with non-zero code. Error: " + error
             raise ExecUtilException(message=message, command=cmd, exit_code=exit_status, out=result)
 
         if verbose:
diff --git a/tests/__init__.py b/tests/__init__.py
diff --git a/tests/helpers/__init__.py b/tests/helpers/__init__.py
diff --git a/tests/helpers/run_conditions.py b/tests/helpers/run_conditions.py
@@ -0,0 +1,11 @@
+import pytest
+import platform
+
+
+class RunConditions:
+    # It is not a test kit!
+    __test__ = False
+
+    def skip_if_windows():
+        if platform.system().lower() == "windows":
+            pytest.skip("This test does not support Windows.")
diff --git a/tests/test_local.py b/tests/test_local.py
@@ -0,0 +1,54 @@
+import pytest
+
+from testgres import ExecUtilException
+from testgres import LocalOperations
+
+from .helpers.run_conditions import RunConditions
+
+
+class TestLocalOperations:
+
+    @pytest.fixture(scope="function", autouse=True)
+    def setup(self):
+        self.operations = LocalOperations()
+
+    def test_exec_command_success(self):
+        """
+        Test exec_command for successful command execution.
+        """
+        RunConditions.skip_if_windows()
+
+        cmd = "python3 --version"
+        response = self.operations.exec_command(cmd, wait_exit=True, shell=True)
+
+        assert b'Python 3.' in response
+
+    def test_exec_command_failure(self):
+        """
+        Test exec_command for command execution failure.
+        """
+        RunConditions.skip_if_windows()
+
+        cmd = "nonexistent_command"
+        while True:
+            try:
+                self.operations.exec_command(cmd, wait_exit=True, shell=True)
+            except ExecUtilException as e:
+                error = e.message
+                break
+            raise Exception("We wait an exception!")
+        assert error == "Utility exited with non-zero code. Error `b'/bin/sh: 1: nonexistent_command: not found\\n'`"
+
+    def test_exec_command_failure__expect_error(self):
+        """
+        Test exec_command for command execution failure.
+        """
+        RunConditions.skip_if_windows()
+
+        cmd = "nonexistent_command"
+
+        exit_status, result, error = self.operations.exec_command(cmd, verbose=True, wait_exit=True, shell=True, expect_error=True)
+
+        assert error == b'/bin/sh: 1: nonexistent_command: not found\n'
+        assert exit_status == 127
+        assert result == b''
diff --git a/tests/test_remote.py b/tests/test_remote.py
@@ -30,12 +30,27 @@ def test_exec_command_failure(self):
         Test exec_command for command execution failure.
         """
         cmd = "nonexistent_command"
-        try:
-            exit_status, result, error = self.operations.exec_command(cmd, verbose=True, wait_exit=True)
-        except ExecUtilException as e:
-            error = e.message
+        while True:
+            try:
+                self.operations.exec_command(cmd, verbose=True, wait_exit=True)
+            except ExecUtilException as e:
+                error = e.message
+                break
+            raise Exception("We wait an exception!")
         assert error == 'Utility exited with non-zero code. Error: bash: line 1: nonexistent_command: command not found\n'
 
+    def test_exec_command_failure__expect_error(self):
+        """
+        Test exec_command for command execution failure.
+        """
+        cmd = "nonexistent_command"
+
+        exit_status, result, error = self.operations.exec_command(cmd, verbose=True, wait_exit=True, shell=True, expect_error=True)
+
+        assert error == b'bash: line 1: nonexistent_command: command not found\n'
+        assert exit_status == 127
+        assert result == b''
+
     def test_is_executable_true(self):
         """
         Test is_executable for an existing executable.
diff --git a/tests/test_simple.py b/tests/test_simple.py
@@ -153,7 +153,6 @@ def test_init_unique_system_id(self):
 
         with scoped_config(cache_initdb=True,
                            cached_initdb_unique=True) as config:
-
             self.assertTrue(config.cache_initdb)
             self.assertTrue(config.cached_initdb_unique)
 
@@ -376,21 +375,18 @@ def test_backup_multiple(self):
 
             with node.backup(xlog_method='fetch') as backup1, \
                     node.backup(xlog_method='fetch') as backup2:
-
                 self.assertNotEqual(backup1.base_dir, backup2.base_dir)
 
             with node.backup(xlog_method='fetch') as backup:
                 with backup.spawn_primary('node1', destroy=False) as node1, \
                         backup.spawn_primary('node2', destroy=False) as node2:
-
                     self.assertNotEqual(node1.base_dir, node2.base_dir)
 
     def test_backup_exhaust(self):
         with get_new_node() as node:
             node.init(allow_streaming=True).start()
 
             with node.backup(xlog_method='fetch') as backup:
-
                 # exhaust backup by creating new node
                 with backup.spawn_primary():
                     pass
@@ -778,7 +774,6 @@ def test_pg_config(self):
 
         # modify setting for this scope
         with scoped_config(cache_pg_config=False) as config:
-
             # sanity check for value
             self.assertFalse(config.cache_pg_config)
 
@@ -810,7 +805,6 @@ def test_config_stack(self):
             self.assertEqual(c1.cached_initdb_dir, d1)
 
             with scoped_config(cached_initdb_dir=d2) as c2:
-
                 stack_size = len(testgres.config.config_stack)
 
                 # try to break a stack
@@ -840,7 +834,6 @@ def test_unix_sockets(self):
     def test_auto_name(self):
         with get_new_node().init(allow_streaming=True).start() as m:
             with m.replicate().start() as r:
-
                 # check that nodes are running
                 self.assertTrue(m.status())
                 self.assertTrue(r.status())
diff --git a/tests/test_simple_remote.py b/tests/test_simple_remote.py
@@ -94,7 +94,6 @@ def removing(f):
 
 
 class TestgresRemoteTests(unittest.TestCase):
-
     def test_node_repr(self):
         with get_remote_node() as node:
             pattern = r"PostgresNode\(name='.+', port=.+, base_dir='.+'\)"
@@ -748,6 +747,7 @@ def test_pg_config(self):
 
         # save right before config change
         c1 = get_pg_config()
+
         # modify setting for this scope
         with scoped_config(cache_pg_config=False) as config:
             # sanity check for value
