testgres 1.13.4__tar.gz → 1.13.6__tar.gz

{testgres-1.13.4/testgres.egg-info → testgres-1.13.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testgres
-Version: 1.13.4
+Version: 1.13.6
 Summary: Testing utility for PostgreSQL and its extensions
 Author-email: Postgres Professional <testgres@postgrespro.ru>
 License: PostgreSQL
@@ -27,7 +27,7 @@ Requires-Dist: port-for>=0.4
 Requires-Dist: six>=1.9.0
 Requires-Dist: psutil
 Requires-Dist: packaging
-Requires-Dist: testgres.os_ops<3.0.0,>=2.0.2
+Requires-Dist: testgres.os_ops<3.0.0,>=2.1.0
 Dynamic: license-file
 
 [![CI Status](https://img.shields.io/github/actions/workflow/status/postgrespro/testgres/.github/workflows/package-verification.yml?label=CI)](https://github.com/postgrespro/testgres/actions/workflows/package-verification.yml)

{testgres-1.13.4 → testgres-1.13.6}/pyproject.toml

@@ -9,9 +9,17 @@ build-backend = "setuptools.build_meta"
 extend-ignore = ["E501"]
 exclude = [".git", "__pycache__", "env", "venv"]
 
+# Pytest settings
+[tool.pytest.ini_options]
+
+testpaths = ["tests"]
+log_file_level = "NOTSET"
+log_file_format = "%(levelname)8s [%(asctime)s] %(message)s"
+log_file_date_format = "%Y-%m-%d %H:%M:%S"
+
 [project]
 name = "testgres"
-version = "1.13.4"
+version = "1.13.6"
 
 description = "Testing utility for PostgreSQL and its extensions"
 readme = "README.md"
@@ -54,7 +62,7 @@ dependencies = [
     "six>=1.9.0",
     "psutil",
     "packaging",
-    "testgres.os_ops>=2.0.2,<3.0.0",
+    "testgres.os_ops>=2.1.0,<3.0.0",
 ]
 
 [project.urls]

{testgres-1.13.4 → testgres-1.13.6}/src/backup.py

@@ -160,7 +160,7 @@ class NodeBackup(object):
             node = NodeClass(name=name, base_dir=base_dir, conn_params=self.original_node.os_ops.conn_params)
 
         assert node is not None
-        assert type(node) == self.original_node.__class__  # noqa: E721
+        assert type(node) is self.original_node.__class__
 
         with clean_on_error(node) as node:
             # Set a new port

{testgres-1.13.4 → testgres-1.13.6}/src/cache.py

@@ -34,7 +34,7 @@ def cached_initdb(data_dir, logfile=None, params=None, os_ops: OsOperations = No
 
     def make_utility_path(name):
         assert name is not None
-        assert type(name) == str  # noqa: E721
+        assert type(name) is str
 
         if bin_path:
             return os_ops.build_path(bin_path, name)

{testgres-1.13.4 → testgres-1.13.6}/src/exceptions.py

@@ -15,14 +15,14 @@ class PortForException(TestgresException):
         self,
         message: typing.Optional[str] = None,
     ):
-        assert message is None or type(message) == str  # noqa: E721
+        assert message is None or type(message) is str
         super().__init__(message)
         self._message = message
         return
 
     @property
     def message(self) -> str:
-        assert self._message is None or type(self._message) == str  # noqa: E721
+        assert self._message is None or type(self._message) is str
         if self._message is None:
             return ""
         return self._message
@@ -53,8 +53,8 @@ class QueryException(TestgresException):
         message: typing.Optional[str] = None,
         query: typing.Optional[str] = None
     ):
-        assert message is None or type(message) == str  # noqa: E721
-        assert query is None or type(query) == str  # noqa: E721
+        assert message is None or type(message) is str
+        assert query is None or type(query) is str
 
         super().__init__(message)
 
@@ -64,8 +64,8 @@ class QueryException(TestgresException):
 
     @property
     def message(self) -> str:
-        assert self._description is None or type(self._description) == str  # noqa: E721
-        assert self._query is None or type(self._query) == str  # noqa: E721
+        assert self._description is None or type(self._description) is str
+        assert self._query is None or type(self._query) is str
 
         msg = []
 
@@ -76,17 +76,17 @@ class QueryException(TestgresException):
             msg.append(u'Query: {}'.format(self._query))
 
         r = six.text_type('\n').join(msg)
-        assert type(r) == str  # noqa: E721
+        assert type(r) is str
         return r
 
     @property
     def description(self) -> typing.Optional[str]:
-        assert self._description is None or type(self._description) == str  # noqa: E721
+        assert self._description is None or type(self._description) is str
         return self._description
 
     @property
     def query(self) -> typing.Optional[str]:
-        assert self._query is None or type(self._query) == str  # noqa: E721
+        assert self._query is None or type(self._query) is str
         return self._query
 
     def __repr__(self) -> str:
@@ -114,8 +114,8 @@ class QueryTimeoutException(QueryException):
         message: typing.Optional[str] = None,
         query: typing.Optional[str] = None
     ):
-        assert message is None or type(message) == str  # noqa: E721
-        assert query is None or type(query) == str  # noqa: E721
+        assert message is None or type(message) is str
+        assert query is None or type(query) is str
 
         super().__init__(message, query)
         return
@@ -133,14 +133,14 @@ class CatchUpException(TestgresException):
         self,
         message: typing.Optional[str] = None,
     ):
-        assert message is None or type(message) == str  # noqa: E721
+        assert message is None or type(message) is str
         super().__init__(message)
         self._message = message
         return
 
     @property
     def message(self) -> str:
-        assert self._message is None or type(self._message) == str  # noqa: E721
+        assert self._message is None or type(self._message) is str
         if self._message is None:
             return ""
         return self._message
@@ -171,7 +171,7 @@ class StartNodeException(TestgresException):
         message: typing.Optional[str] = None,
         files: typing.Optional[typing.Iterable] = None
     ):
-        assert message is None or type(message) == str  # noqa: E721
+        assert message is None or type(message) is str
         assert files is None or isinstance(files, typing.Iterable)
 
         super().__init__(message)
@@ -182,7 +182,7 @@ class StartNodeException(TestgresException):
 
     @property
     def message(self) -> str:
-        assert self._description is None or type(self._description) == str  # noqa: E721
+        assert self._description is None or type(self._description) is str
         assert self._files is None or isinstance(self._files, typing.Iterable)
 
         msg = []
@@ -191,15 +191,15 @@ class StartNodeException(TestgresException):
             msg.append(self._description)
 
         for f, lines in self._files or []:
-            assert type(f) == str  # noqa: E721
-            assert type(lines) in [str, bytes]  # noqa: E721
+            assert type(f) is str
+            assert type(lines) in [str, bytes]
             msg.append(u'{}\n----\n{}\n'.format(f, lines))
 
         return six.text_type('\n').join(msg)
 
     @property
     def description(self) -> typing.Optional[str]:
-        assert self._description is None or type(self._description) == str  # noqa: E721
+        assert self._description is None or type(self._description) is str
         return self._description
 
     @property
@@ -233,14 +233,14 @@ class InitNodeException(TestgresException):
         self,
         message: typing.Optional[str] = None,
     ):
-        assert message is None or type(message) == str  # noqa: E721
+        assert message is None or type(message) is str
         super().__init__(message)
         self._message = message
         return
 
     @property
     def message(self) -> str:
-        assert self._message is None or type(self._message) == str  # noqa: E721
+        assert self._message is None or type(self._message) is str
         if self._message is None:
             return ""
         return self._message
@@ -268,14 +268,14 @@ class BackupException(TestgresException):
         self,
         message: typing.Optional[str] = None,
     ):
-        assert message is None or type(message) == str  # noqa: E721
+        assert message is None or type(message) is str
         super().__init__(message)
         self._message = message
         return
 
     @property
     def message(self) -> str:
-        assert self._message is None or type(self._message) == str  # noqa: E721
+        assert self._message is None or type(self._message) is str
         if self._message is None:
             return ""
         return self._message

testgres-1.13.6/src/impl/internal_utils.py

@@ -0,0 +1,20 @@
+import logging
+
+
+def send_log(level: int, msg: str) -> None:
+    assert type(level) is int
+    assert type(msg) is str
+
+    return logging.log(level, "[testgres] " + msg)
+
+
+def send_log_info(msg: str) -> None:
+    assert type(msg) is str
+
+    return send_log(logging.INFO, msg)
+
+
+def send_log_debug(msg: str) -> None:
+    assert type(msg) is str
+
+    return send_log(logging.DEBUG, msg)

testgres-1.13.6/src/impl/platforms/internal_platform_utils.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import enum
+import typing
+
+from testgres.operations.os_ops import OsOperations
+
+
+class InternalPlatformUtils:
+    class FindPostmasterResultCode(enum.Enum):
+        ok = 0
+        not_found = 1,
+        not_implemented = 2
+        many_processes = 3
+        has_problems = 4
+
+    class FindPostmasterResult:
+        code: InternalPlatformUtils.FindPostmasterResultCode
+        pid: typing.Optional[int]
+
+        def __init__(
+            self,
+            code: InternalPlatformUtils.FindPostmasterResultCode,
+            pid: typing.Optional[int]
+        ):
+            assert type(code) is InternalPlatformUtils.FindPostmasterResultCode
+            assert pid is None or type(pid) is int
+            self.code = code
+            self.pid = pid
+            return
+
+        @staticmethod
+        def create_ok(pid: int) -> InternalPlatformUtils.FindPostmasterResult:
+            assert type(pid) is int
+            return __class__(InternalPlatformUtils.FindPostmasterResultCode.ok, pid)
+
+        @staticmethod
+        def create_not_found() -> InternalPlatformUtils.FindPostmasterResult:
+            return __class__(InternalPlatformUtils.FindPostmasterResultCode.not_found, None)
+
+        @staticmethod
+        def create_not_implemented() -> InternalPlatformUtils.FindPostmasterResult:
+            return __class__(InternalPlatformUtils.FindPostmasterResultCode.not_implemented, None)
+
+        @staticmethod
+        def create_many_processes() -> InternalPlatformUtils.FindPostmasterResult:
+            return __class__(InternalPlatformUtils.FindPostmasterResultCode.many_processes, None)
+
+        @staticmethod
+        def create_has_problems() -> InternalPlatformUtils.FindPostmasterResult:
+            return __class__(InternalPlatformUtils.FindPostmasterResultCode.has_problems, None)
+
+    def FindPostmaster(
+        self,
+        os_ops: OsOperations,
+        bin_dir: str,
+        data_dir: str
+    ) -> FindPostmasterResult:
+        assert isinstance(os_ops, OsOperations)
+        assert type(bin_dir) is str
+        assert type(data_dir) is str
+        raise NotImplementedError("InternalPlatformUtils::FindPostmaster is not implemented.")

testgres-1.13.6/src/impl/platforms/internal_platform_utils_factory.py

@@ -0,0 +1,23 @@
+from .internal_platform_utils import InternalPlatformUtils
+
+from testgres.operations.os_ops import OsOperations
+
+
+def create_internal_platform_utils(
+    os_ops: OsOperations
+) -> InternalPlatformUtils:
+    assert isinstance(os_ops, OsOperations)
+
+    platform_name = os_ops.get_platform()
+    assert type(platform_name) is str
+
+    if platform_name == "linux":
+        from .linux import internal_platform_utils as x
+        return x.InternalPlatformUtils()
+
+    if platform_name == "win32":
+        from .win32 import internal_platform_utils as x
+        return x.InternalPlatformUtils()
+
+    # not implemented
+    return InternalPlatformUtils()

testgres-1.13.6/src/impl/platforms/linux/internal_platform_utils.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from .. import internal_platform_utils as base
+from ... import internal_utils
+
+from testgres.operations.os_ops import OsOperations
+from testgres.operations.exceptions import ExecUtilException
+
+import re
+import shlex
+
+
+class InternalPlatformUtils(base.InternalPlatformUtils):
+    C_BASH_EXE = "/bin/bash"
+
+    sm_exec_env = {
+        "LANG": "en_US.UTF-8",
+        "LC_ALL": "en_US.UTF-8",
+    }
+
+    # --------------------------------------------------------------------
+    def FindPostmaster(
+        self,
+        os_ops: OsOperations,
+        bin_dir: str,
+        data_dir: str
+    ) -> InternalPlatformUtils.FindPostmasterResult:
+        assert isinstance(os_ops, OsOperations)
+        assert type(bin_dir) is str
+        assert type(data_dir) is str
+        assert type(__class__.C_BASH_EXE) is str
+        assert type(__class__.sm_exec_env) is dict
+        assert len(__class__.C_BASH_EXE) > 0
+        assert len(bin_dir) > 0
+        assert len(data_dir) > 0
+
+        pg_path_e = re.escape(os_ops.build_path(bin_dir, "postgres"))
+        data_dir_e = re.escape(data_dir)
+
+        assert type(pg_path_e) is str
+        assert type(data_dir_e) is str
+
+        regexp = r"^\s*[0-9]+\s+" + pg_path_e + r"(\s+.*)?\s+\-[D]\s+" + data_dir_e + r"(\s+.*)?"
+
+        cmd = [
+            __class__.C_BASH_EXE,
+            "-c",
+            "ps -ewwo \"pid=,args=\" | grep -E " + shlex.quote(regexp),
+        ]
+
+        exit_status, output_b, error_b = os_ops.exec_command(
+            cmd=cmd,
+            ignore_errors=True,
+            verbose=True,
+            exec_env=__class__.sm_exec_env,
+        )
+
+        assert type(output_b) is bytes
+        assert type(error_b) is bytes
+
+        output = output_b.decode("utf-8")
+        error = error_b.decode("utf-8")
+
+        assert type(output) is str
+        assert type(error) is str
+
+        if exit_status == 1:
+            return __class__.FindPostmasterResult.create_not_found()
+
+        if exit_status != 0:
+            errMsg = f"test command returned an unexpected exit code: {exit_status}"
+            raise ExecUtilException(
+                message=errMsg,
+                command=cmd,
+                exit_code=exit_status,
+                out=output,
+                error=error,
+            )
+
+        lines = output.splitlines()
+        assert type(lines) is list
+
+        if len(lines) == 0:
+            return __class__.FindPostmasterResult.create_not_found()
+
+        if len(lines) > 1:
+            msgs = []
+            msgs.append("Many processes like a postmaster are found: {}.".format(len(lines)))
+
+            for i in range(len(lines)):
+                assert type(lines[i]) is str
+                lines.append("[{}] '{}'".format(i, lines[i]))
+                continue
+
+            internal_utils.send_log_debug("\n".join(lines))
+            return __class__.FindPostmasterResult.create_many_processes()
+
+        def is_space_or_tab(ch) -> bool:
+            assert type(ch) is str
+            return ch == " " or ch == "\t"
+
+        line = lines[0]
+        start = 0
+        while start < len(line) and is_space_or_tab(line[start]):
+            start += 1
+
+        pos = start
+        while pos < len(line) and line[pos].isnumeric():
+            pos += 1
+
+        if pos == start:
+            return __class__.FindPostmasterResult.create_has_problems()
+
+        if pos != len(line) and not line[pos].isspace():
+            return __class__.FindPostmasterResult.create_has_problems()
+
+        pid = int(line[start:pos])
+        assert type(pid) is int
+
+        return __class__.FindPostmasterResult.create_ok(pid)

testgres-1.13.6/src/impl/platforms/win32/internal_platform_utils.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from .. import internal_platform_utils as base
+from testgres.operations.os_ops import OsOperations
+
+
+class InternalPlatformUtils(base.InternalPlatformUtils):
+    def FindPostmaster(
+        self,
+        os_ops: OsOperations,
+        bin_dir: str,
+        data_dir: str
+    ) -> InternalPlatformUtils.FindPostmasterResult:
+        assert isinstance(os_ops, OsOperations)
+        assert type(bin_dir) is str
+        assert type(data_dir) is str
+        return __class__.FindPostmasterResult.create_not_implemented()

{testgres-1.13.4 → testgres-1.13.6}/src/impl/port_manager__generic.py

@@ -38,8 +38,8 @@ class PortManager__Generic(PortManager):
 
     def reserve_port(self) -> int:
         assert self._guard is not None
-        assert type(self._available_ports) == set  # noqa: E721t
-        assert type(self._reserved_ports) == set  # noqa: E721
+        assert type(self._available_ports) is set
+        assert type(self._reserved_ports) is set
 
         with self._guard:
             t = tuple(self._available_ports)
@@ -48,8 +48,8 @@ class PortManager__Generic(PortManager):
             t = None
 
             for port in sampled_ports:
-                assert type(port) == int  # noqa: E721
-                assert not (port in self._reserved_ports)
+                assert type(port) is int
+                assert port not in self._reserved_ports
                 assert port in self._available_ports
 
                 assert port >= __class__._C_MIN_PORT_NUMBER
@@ -61,26 +61,26 @@ class PortManager__Generic(PortManager):
                 self._reserved_ports.add(port)
                 self._available_ports.discard(port)
                 assert port in self._reserved_ports
-                assert not (port in self._available_ports)
+                assert port not in self._available_ports
                 __class__.helper__send_debug_msg("Port {} is reserved.", port)
                 return port
 
         raise PortForException("Can't select a port.")
 
     def release_port(self, number: int) -> None:
-        assert type(number) == int  # noqa: E721
+        assert type(number) is int
         assert number >= __class__._C_MIN_PORT_NUMBER
         assert number <= __class__._C_MAX_PORT_NUMBER
 
         assert self._guard is not None
-        assert type(self._reserved_ports) == set  # noqa: E721
+        assert type(self._reserved_ports) is set
 
         with self._guard:
             assert number in self._reserved_ports
-            assert not (number in self._available_ports)
+            assert number not in self._available_ports
             self._available_ports.add(number)
             self._reserved_ports.discard(number)
-            assert not (number in self._reserved_ports)
+            assert number not in self._reserved_ports
             assert number in self._available_ports
             __class__.helper__send_debug_msg("Port {} is released.", number)
         return
@@ -89,8 +89,8 @@ class PortManager__Generic(PortManager):
     def helper__send_debug_msg(msg_template: str, *args) -> None:
         assert msg_template is not None
         assert args is not None
-        assert type(msg_template) == str  # noqa: E721
-        assert type(args) == tuple  # noqa: E721
+        assert type(msg_template) is str
+        assert type(args) is tuple
         assert msg_template != ""
         s = "[port manager] "
         s += msg_template.format(*args)

{testgres-1.13.4 → testgres-1.13.6}/src/impl/port_manager__this_host.py

@@ -15,19 +15,19 @@ class PortManager__ThisHost(PortManager):
         assert __class__.sm_single_instance_guard is not None
 
         if __class__.sm_single_instance is not None:
-            assert type(__class__.sm_single_instance) == __class__  # noqa: E721
+            assert type(__class__.sm_single_instance) is __class__
             return __class__.sm_single_instance
 
         with __class__.sm_single_instance_guard:
             if __class__.sm_single_instance is None:
                 __class__.sm_single_instance = __class__()
         assert __class__.sm_single_instance is not None
-        assert type(__class__.sm_single_instance) == __class__  # noqa: E721
+        assert type(__class__.sm_single_instance) is __class__
         return __class__.sm_single_instance
 
     def reserve_port(self) -> int:
         return utils.reserve_port()
 
     def release_port(self, number: int) -> None:
-        assert type(number) == int  # noqa: E721
+        assert type(number) is int
         return utils.release_port(number)